一：继承的基本介绍和示意图

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends声明继承父类即可。
image.png

二：继承基本语法

  1. //class 子类 extends 父类｛
  2. //｝
  3. class father{
  5. }
  6. class son extends father{
  8. }
  9. //之就会自动拥有父类定义的属性和方法
  10. //父类有叫超类，基类
  11. //父类又叫派生类

:::danger 继承带来的好处：
代码的复用性提高了
代码的扩展性和维护性提高了 :::

三：继承的深入理解/细节(重要关系到面向对象能不能理解)

  • 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
  • 子类必须调用父类的构造器， 完成父类的初始化 ```java public class test01 { public static void main(String[] args) {
    1.   //同时会调用父类的无参构造器，完成父类的初始化    
    2.   Girl girl = new Girl();
    } } class Person{ public Person() {
    1.   System.out.println("Person的无参构造器被调用");
    } } class Girl extends Person{ public Girl() {
    1.   System.out.println("Girl的无参构造器被调用");
    } }
  2. - **_当创建子类对象时，__不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，__如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作__，否则，编译不会通过(怎么理解。) [举例说明]_**
  3. ```java
  4. class Person{
  5.     String name ;
  6.     int age;
  7.     public Person(String name, int age) {
  8.         this.name = name;
  9.         this.age = age;
  10.         System.out.println("父类的有参构造器被调用");
  11.     }
  12. }
  13. class Boy extends Person{
  14.     public Boy() {
  15.         //不用super指定会报错
  16.         super("sakura",20);
  17.         System.out.println("Boy的无参构造器被调用");
  18.     }
  19. }
  20. //运行结果：
  21. //父类的有参构造器被调用
  22. //Boy的无参构造器被调用

  • 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)

    1. class Person{
    2.   String name ;
    3.   int age;
    5.   public Person() {
    6.       System.out.println("person的无参构造器");
    7.   }
    8.   public Person(String name) {
    9.       this.name = name;
    10.       System.out.println("person一个参数构造器");
    11.   }
    12.   public Person(String name, int age) {
    13.       this.name = name;
    14.       this.age = age;
    15.       System.out.println("父类的有参构造器被调用");
    16.   }
    17. }
    18. class Boy extends Person{
    19.   public Boy() {
    20.       //父类有三个构造器，用super指定
    21.       //super("sakura",20);
    22.       super("sakura");
    23.       System.out.println("Boy的无参构造器被调用");
    24.   }
    25. }

  • super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)

  • super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
  • java 所有类都是 Object 类的子类, Object 是所有类的基类
  • 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
  • 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。

  • 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

    • 猫cat是动物animal

    • girl女孩是人person

      四：继承的本质分析(重要)

      1：内存分析

      image.png
      image.png

      2：返回信息规则

      1. public class ExtendsTheory { 
      2. public static void main(String[] args) { 
      3.    Son son = new Son();
      4.    //内存的布局 //?-> 这时请大家注意，要按照查找关系来返回信息 
      5.    //(1) 首先看子类是否有该属性 
      6.    //(2) 如果子类有这个属性，并且可以访问，则返回信息 
      7.    //(3) 如果子类没有这个属性，就看父类有没有这个属性
      8.    //(如果父类有该属性，并且可以访问，就返回信息..) 
      9.    //(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object... 
      10.    System.out.println(son.name);//返回就是大头儿子 
      11.    System.out.println(son.age);//返回的就是 39 
      12.    System.out.println(son.getAge());//返回的就是 39 
      13.    System.out.println(son.hobby); //返回的就是旅游
      14. }
      15. }
      16. class GrandPa { //爷类 
      17. String name = "大头爷爷";
      18. String hobby = "旅游"; }
      19. class Father extends GrandPa {
      20. //父类 
      21. String name = "大头爸爸"; 
      22. private int age = 39; 
      24. public int getAge() { 
      25.    return age; 
      26. } 
      27. }
      28. class Son extends Father { //子类 
      29. String name = "大头儿子"; 
      30. }

      五：练习

      image.png ```java package Date0731.test01; /**

      • 作者：sakura

      • 日期：2022年07月31日 15:35 */ public class Test { public static void main(String[] args) { PC pc = new PC(“intel”, 32, 512, “sakura”); NotePad notePad = new NotePad(“intel”, 32, 512, “黑色”);

        notePad.printInfo();

        pc.printInfo(); } }

  1. ```java
  2. package Date0731.test01;
  4. /**
  5.  * 作者：sakura
  6.  * 日期：2022年07月31日 15:35
  7.  */
  8. public class Computer {
  9.     private String cpu;
  10.     private int memory;
  11.     private int disk;
  13.     public Computer(String cpu, int memory, int disk) {
  14.         this.cpu = cpu;
  15.         this.memory = memory;
  16.         this.disk = disk;
  17.     }
  19.     public String getCpu() {
  20.         return cpu;
  21.     }
  23.     public void setCpu(String cpu) {
  24.         this.cpu = cpu;
  25.     }
  27.     public int getMemory() {
  28.         return memory;
  29.     }
  31.     public void setMemory(int memory) {
  32.         this.memory = memory;
  33.     }
  35.     public int getDisk() {
  36.         return disk;
  37.     }
  39.     public void setDisk(int disk) {
  40.         this.disk = disk;
  41.     }
  43.     public String getdetail(){
  44.         return "cpu =" +cpu + " memory = " + memory + "disk = " + disk;
  45.     }
  46. }
  1. package Date0731.test01;
  3. /**
  4.  * 作者：sakura
  5.  * 日期：2022年07月31日 15:41
  6.  */
  7. public class PC extends Computer{
  9.     private String brand;
  11.     public PC(String cpu, int memory, int disk, String brand) {
  12.         super(cpu, memory, disk);
  13.         this.brand = brand;
  14.     }
  16.     public String getBrand() {
  17.         return brand;
  18.     }
  20.     public void setBrand(String brand) {
  21.         this.brand = brand;
  22.     }
  24.     public void printInfo(){
  25.         System.out.println("pc信息为：");
  26.         System.out.println(getdetail()+" brand = "+getBrand());
  27.     }
  29. }