4.1 概念

定义：

继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基类或超类，而新产生的类称为子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法

优点：

  1. 实现代码共享，减少创建类的工作量，使子类可以拥有父类的方法和属性。
  2. 提高代码维护性和可重用性。
  3. 提高代码的可扩展性，更好的实现父类的方法。

缺点：

  1. 继承是侵入性的。只要继承，就必须拥有父类的属性和方法。
  2. 降低代码灵活性。子类拥有父类的属性和方法后多了些约束。
  3. 增强代码耦合性（开发项目的原则为高内聚低耦合）。当父类的常量、变量和方法被修改时，需要考虑子类的修改，有可能会导致大段的代码需要重构。

4.2 格式

  1. 修饰符 class class_name extends extend_class {
  2.     // 类的主体
  3. }
  5. //示例：
  6. class Person {
  7.     private String name;
  8.     private int age;
  10.     public String getName() {...}
  11.     public void setName(String name) {...}
  12.     public int getAge() {...}
  13.     public void setAge(int age) {...}
  14. }
  16. class Student extends Person {
  17.     // 不要重复name和age字段/方法,
  18.     // 只需要定义新增score字段/方法:
  19.     private int score;
  21.     public int getScore() { … }
  22.     public void setScore(int score) { … }
  23. }

在OOP的术语中，我们把Person称为超类（super class），父类（parent class），基类（base class），把Student称为子类（subclass），扩展类（extended class）

注意点：

  1. 子类一般比父类包含更多的属性和方法。
  2. 父类中的 private 成员在子类中是不可见的，因此在子类中不能直接使用它们。

  3. 父类和其子类间必须存在“是一个”即“is-a”的关系，否则不能用继承。但也并不是所有符合“is-a”关系的都应该用继承。

    例如，正方形是一个矩形，但不能让正方形类来继承矩形类，因为正方形不能从矩形扩展得到任何东西。正确的继承关系是正方形类继承图形类。

  4. Java 只允许单一继承（即一个子类只能有一个直接父类），C++ 可以多重继承（即一个子类有多个直接父类）

4.3 继承-成员变量

变量不重名

此时没有影响，可直接使用

class Fu{
    int num = 5;
}

class Zi extends Fu{
    int num1= 6;

    public void show(){
        System.out.println(num); 
        System.out.println(num1);
    }
}

变量重名

若子类出现重名变量，若需访问父类中单成员变量，需使用**super**关键字

super.父类变量

class Fu{
    int num = 5;
}

class Zi extends Fu{
    int num= 6;

    public void show(){
        System.out.println(this.num);  //父类变量
        System.out.println(super.num); //子类变量
    }
}

4.4 继承-成员方法

不重名

若子类出现不重名的成员方法，此时可直接调用

不在举例

重名（Override）

概念：

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖

重写规则

  • 参数列表必须完全与被重写的方法参数列表相同。
  • 返回的类型必须与被重写的方法的返回类型相同（1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
  • 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
  • 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常

注意事项

  • 重写的方法可以使用 @Override 注解来标识。
  • 父类的成员方法只能被它的子类重写。
  • 声明为 final 的方法不能被重写。
  • 声明为 static 的方法不能被重写，但是能够再次声明。
  • 构造方法不能被重写。
  • 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
  • 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
  • 如果不能继承一个方法，则不能重写这个方法。

4.5 继承-构造方法

  • 子类无法继承父类的构造方法
  • 子类初始化时，必须先执行父类的初始化动作。任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();
class Person {
    protected String name;
    protected int age;

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

/*
构造方法实际上是这样,但是，Person类并没有无参数的构造方法，因此，编译失败
class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(); // 自动调用父类的构造方法
        this.score = score;
    }
}
*/

//解决方法是调用Person类存在的某个构造方法
class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(name, age); // 调用父类的构造方法Person(String, int)
        this.score = score;
    }
}
  • 如果父类没有默认的构造方法，子类就必须显式调用**super()**并给出参数以便让编译器定位到父类的一个合适的构造方法。
  • 即子类不会继承任何父类的构造方法。子类默认的构造方法是编译器自动生成的，不是继承的

4.6 向上（下）转换

注：所说的对象类型转换，是指存在继承关系的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，会抛出 Java 强制类型转换（java.lang.ClassCastException）异常

1）向上转型

父类引用指向子类对象为向上转型，语法格式如下：

fatherClass obj = new sonClass();
Animal animal = new Dog();    // 向上转型，把Dog类型转换为Animal类型

其中，fatherClass 是父类名称或接口名称，obj 是创建的对象，sonClass 是子类名称。

向上转型就是把子类对象直接赋给父类引用，不用强制转换。使用向上转型可以调用父类类型中的所有成员，不能调用子类类型中特有成员，最终运行效果看子类的具体实现。

2）向下转型

与向上转型相反，子类对象指向父类引用为向下转型，语法格式如下：

sonClass obj = (sonClass) fatherClass;
Dog dog = (Dog) animal; // 向下转型，把Animal类型转换为Dog类型

其中，fatherClass 是父类名称，obj 是创建的对象，sonClass 是子类名称。

向下转型可以调用子类类型中所有的成员，不过需要注意的是如果父类引用对象指向的是子类对象，那么在向下转型的过程中是安全的，也就是编译是不会出错误。

但是如果父类引用对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现我们开始提到的 Java 强制类型转换异常，一般使用 instanceof 运算符来避免出此类错误

3）强制对象类型转换

Java 编译器允许在具有直接或间接继承关系的类之间进行类型转换。

对于向下转型，必须进行强制类型转换；且有可能失败报错

对于向上转型，不必使用强制类型转换

类型强制转换时想运行成功就必须保证父类引用指向的对象一定是该子类对象，最好使用 instanceof 运算符判断后，再强转，例如：

Person p = new Student();
if (p instanceof Student) {
    // 只有判断成功才会向下转型:
    Student s = (Student) p; // 一定会成功
}

4.7 protected

继承有个特点，就是子类无法访问父类的private字段或者private方法

为了让子类可以访问父类的字段，我们需要把private改为protected。用protected修饰的字段可以被子类访问

class Person {
    protected String name;
    protected int age;
}

class Student extends Person {
    public String hello() {
        return "Hello, " + name; // OK!
    }
}

4.8 继承和组合

简单的说，继承是is-a，组合是has-a

class Student extends Person { // 继承
    protected Book book; //组合
    protected int score;
}

4.9 final关键字

正常情况下，只要某个class没有final修饰符，那么任何类都可以从该class继承。

从Java 15开始，允许使用sealed修饰class，并通过permits明确写出能够从该class继承的子类名称

后续将汇总几个关键字，此处知道使用final后无法继承即可