Java面向对象：继承、方法覆盖、super关键字

继承

• 程序中的继承，是类与类之间特征和行为的一种赠予或获得。

• 类与类之间必须满足 is a 的关系。

①父类的选择：

• 功能越精细，重合点越多的，就越接近直接父类。

②父类的抽象：

• 根据程序需要使用到的多个具体类，进行共性提取，进而定义父类。

• 在一组相同或类似的类中，抽取特征和行为，定义在父类中，实现重用。

③继承语法：

• class 子类名 extends 父类名{ } //定义子类时，显式定义父类

• 产生继承关系之后，子类可以使用父类的属性和方法，也可以定义子类独有的属性和方法。

④完整的子类：

• 完整子类 = 父类共性 + 子类独有

• 好处：提高代码的复用性，又提高代码的可扩展性

• Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加。

不可继承：

• 构造方法：类中的构造方法，只负责创建本类对象，不可继承；

• private修饰的属性/方法：仅本类可见，不可继承；

• 父子类不在同一个package中，default修饰的属性和方法，不可继承；

访问权限修饰符-继承访问权限

• 汇总：

  • 本类都可访问

  • public都可访问

  • default同包内可以访问

  • protected非同包子类，有继承关系

• 跨包访问

  • 写全限定名（包名.类名），eg: java.util.Arrays.copyOf(...);

  • 导包（import），eg: import java.util.Arrays;

方法的覆盖

• 当父类提供的方法无法满足子类的需求时，可在子类中定义和父类相同的方法进行覆盖（Override）

• 方法覆盖原则：

  • 方法名称、参数列表、返回值类型必须与父类相同；

  • 访问修饰符应与父类相同或更宽泛；

• 执行机制：子类覆盖父类方法后，调用时优先执行子类覆盖后的方法；

super 关键字

• 子类去访问父类重名的属性或方法时(属性遮蔽/方法覆盖)，使用super.专项访问

• super() 默认调用父类无参构造方法，隐式存在

• super(参数) 指定调用父类有参构造方法，显式调用

public class TestSuper {
      public static void main(String[] args) {
            Son s = new Son();
            s.method();
      }
}
class Father {
      int field = 10;

      public void method() {
            System.out.println("Father-method()");
      }
}
class Son extends Father {
      int field = 20;

      public void method() {
            int field = 30;
            System.out.println(field);//30
            System.out.println(super.field); //10,子类与父类重名时,super修饰为父类的属性
            System.out.println(this.field); //20

            super.method(); // 子类与父类方法重名时，super访问父类的同名方法，且不能省略
            System.out.println("Son-method()"); // 再叠加额外的功能代码，组成新的功能
      }
}
输出：
30
10
20
Father-method()
Son-method()

• this与super：

  • 同一个子类构造方法中，super()和this()不可同时存在

  • 当子类构造中使用了this()或this(实参)，即不可再同时书写super()或super(实参)，会由this()指向的构造方法完成super()的调用

• 继承关系下的对象创建：

  • 继承关系下构建子类对象时，会先构建父类对象

  • 由"父类共性" + "子类独有" 组合成一个完整的子类对象

• 继承关系下的对象创建流程

  • ① 构建父类对象

  • ② 初始化自身属性

  • ③ 执行自身构造方法中的逻辑代码

/* 继承关系下的对象创建流程 */
public class TestCreateSort { // extends Object 隐式继承存在
      public static void main(String[] args) {
            new C();

            System.out.println("end...");
      }
}
class A { // extends Object 隐式继承存在
      // [总]第 1 步
      String fieldA = "A：field"; // ① 初始化属性

      // [总]第 2 步
      public A () {
            System.out.println(fieldA); // 非null
            System.out.println("--- A() ---"); // ② 执行构造方法中的逻辑代码
      }
}
class B extends A {
      // [总]第 3 步
      String fieldB = "B：field"; // ② 初始化属性

      // [总]第 4 步
      public B () {
            super();// ① 调用父类的构造方法(默认调用父类无参构造方法)  super()写不写都隐式存在于构造方法的首行
            System.out.println(fieldB); // 非null
            System.out.println("--- B() ---"); // ③ 执行构造方法中的逻辑代码
      }
}
class C extends B {
      // [总]第 5 步
      String fieldC = "C：field"; // ② 初始化属性

      // [总]第 6 步
      public C () {
            super();// ① 调用父类的构造方法(默认调用父类无参构造方法)  super()写不写都隐式存在于构造方法的首行
            System.out.println(fieldC); // 非null
            System.out.println("--- C() ---"); // ③ 执行构造方法中的逻辑代码
      }
}
输出：
A：field
--- A() ---
B：field
--- B() ---
C：field
--- C() ---
end...