封装，重写

合集 - 学习Java狂神(17)

1.JDK,JRE,JVM，helloworld2023-06-112.硬件，软件，Dos命令笔记2023-06-103.基本语法12023-06-134.基础语法2运算符2023-06-185.输入，选择，while循环2023-06-226.for循环2023-06-267.java方法2023-06-268.递归，计算器2023-06-269.数组2023-06-2810.面向对象,方法复习2023-06-2911. 对象2023-06-30

12.封装，重写2023-07-02

13.多态2023-07-0214.static总结,抽象2023-07-0515.接口，内部类2023-07-0616.异常2023-07-0617.javaSE总结2023-07-07

收起

封装，重写

封装

• 该露的露，该藏的藏
  我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
• 封装（数据的隐藏)
  通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 记住这句话就够了:属性私有，get/set

作用

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了

package com.oop.demo04;
//类
public class Student {
    //private:属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄
    //提供一些可以操作这个属性的方法
    //提供一些public的get,set方法

    //get 获取这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
// alt+inset.自动生成get，set

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>0&&age<100){//合法
            this.age = age;
        }
        else {
            this.age=3;
        }
    }
}
=============
    package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("青江");
        System.out.println(s1.getName());
        s1.setAge(119);
        System.out.println(s1.getAge());//3
    }
}

---

继承

1. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
2. extends的意思是“扩展”。子类是父类的扩展。
3. JAVA中类只有单继承，没有多继承!(一父多子)
4. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
5. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
6. 子类和父类之间,从意义上讲应该具有"is a"的关系.
7. object类
8. super
9. 方法重写

package com.oop.demo05;
//Person  人   父类
//在Java中，所有的类都默认直接或者间接继承object
//Ctrl+h,查看父子类关系
public class Person {
    //public  公共的，子类可以继承
    //protected  受保护的，
    //default  默认的
    //private  私有的，子类不可以继承，需要get,set
    public int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}
============
    package com.oop.demo05;
//Student  is  Person   ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
}
===============
    package com.oop.demo05;
//Teacher is Person ：派生类，子类
public class Teacher extends Person{
}
===========
    package com.oop;

import com.oop.demo05.Student;//注意调取地址

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}

super注意点:

1. super调用父类的构造方法，必须在构造方法的第一个
2. super 必须只能出现在子类的方法或者构造方法中!
3. super和 this 不能同时调用构造方法!

Vs this:

代表的对象不同:

• this:本身调用者这个对象
• super:代表父类对象的应用

前提

• this:没有继承也可以使用
• super:只能在继承条件才可以使用

构造方法

• this();本类的构造

• super():父类的构造!

package com.oop.demo05;
//Person  人   父类
//在Java中，所有的类都默认直接或者间接继承object
//Ctrl+h,查看父子类关系
public class Person {

    public Person() {
        System.out.println("Person无参执行了");
    }

    public int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }

    protected String name="kuangshen";
    public void print(){
        System.out.println("Person");
    }
}
===============
   package com.oop.demo05;
//Student  is  Person   ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
    public Student() {//隐藏代码，调用了父类的无参构造，先父后子
        super();//调用父类的构造器，必须在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name="qinjiang";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
    public void test (String name){
        System.out.println(name);//青江
        System.out.println(this.name);//qinjiang
        System.out.println(super.name);//kuangshen
    }
}
 ============
     package com.oop;

import com.oop.demo05.Student;//注意调取地址

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
//        student.say();
//        System.out.println(student.money);
        //student.test("青江");
       // student.test1();
    }
}

---

重写:方法覆盖

需要有继承关系，子类重写父类的方法!

1．方法名必须相同
2．参数列表必须相同
3．修饰符:范围可以扩大但不能缩小:public>protected>Default>private
4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException -->Exception(大)

重写，子类的方法和父类必须一致;方法体不同!

为什么需要重写:
1．父类的功能，子类不一定需要，或者不一定满足!

Alt +Insert ; override;

package com.oop.demo05;
//重写都是方法的重写，与属性无关
public class B {
    public /*static*/ void test(){
        System.out.println("B=>test()");
    }
}
==========
    package com.oop.demo05;

public class A extends B{
    @Override//注解：有功能的注释。Override重写
    public void test() {
        System.out.println("A=>test()");
    }
}
=================
    package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;


public class Application {
    //静态方法和非静态方法区别很大
    //静态方法：方法的调用只和左边定义的数据类型有关
    //非静态:子类重写了父类的方法
    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();//A
        B b=new A();//父类的引用指向了子类
        //子类重写了父类的方法（非静态）
        b.test();//B
    }
}