【狂神说Java】封装、继承

封装

• 该露的露，该藏的藏
  • 高内聚：类内部的操作自己完成，不允许外部干涉；
  • 低耦合：仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常，禁止直接访问对象中的属性，而应该通过操作接口来访问，这称为信息隐藏

记住下面的话：

属性私有（private），get/set 方法访问，idea 中可以用 alt+insert 补全

public class Person{
    public Person(String name){
        this.name = name;
    }
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

封装的目的

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

---

继承

• 继承的本质是对某一批类的抽象。
• extends的意思是扩展。子类是父类的扩展
• Java中只有单继承，没有多继承。
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends。
• 子类能继承父类的所有属性，但父类的私有属性，子类只是拥有，无法使用。

public class Boys extends Person{
    // 由于Person中没有无参数的构造方法，在这需要实现子类构造方法
    public Boys(String name) {
        super(name);
    }

    @Override // 重写方法
    public void setName(String name) {
        System.out.println("重写方法");
        super.setName(name);
    }
    // 重载
    public void setName(String name,String name2) {
        System.out.println("重载方法");
        super.setName(name+name2);
    }
}

super注意点：

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

---

• this：本身调用这个对象，没有继承也可以使用

• super：代表父类对象的应用，只能在继承后使用

• this()：调用本类的构造方法

• super():调用父类的构造方法

为什么要重写

父类的功能，不能满足子类的要求，所以需要重写

方法重写

• 静态方法的调用只和左边定义的数据类型有关。

// 文件B.java
public class B{
    public static void test(){
        System.out.println("B==>test");
    }
}
// 文件A.java
//继承
public class A extends B{
    public static void test(){
        System.out.println("A==>test");
    }
}
// 文件Application.java
public class Application {
    public static void main(String[] args) {
        // 方法的调用只和左边定义的数据类型有关
        A a = new A();
        B b = new A();// 父类的引用指向子类
        a.test(); // A==>test
        b.test(); // B==>test
    }
}

• 重写只和非静态方法有关。

// 文件B.java
public class B{
    public void test(){
        System.out.println("B==>test");
    }
}
// 文件A.java
//继承
public class A extends B{
    @Override
    public void test(){
        System.out.println("A==>test");
    }
}
// 文件Application.java
public class Application {
    public static void main(String[] args) {
        A a = new A();
        B b = new A();// 父类的引用指向子类，A重写了B的test方法
        a.test(); // A==>test
        b.test(); // A==>test
    }
}

继承后重写注意点：

• 重写：要有继承关系，子类重写父类方法！
• 参数列表必须相同。
• 修饰符：子类范围要大于等于父类，private无法重写。
  • public > protected > default > private
• 抛出的异常：范围可以缩小，但不能扩大。