🎼 继承

面向对象三大特征之一

一个类的对象可以使用另一个类的对象中的成员，这种关系就称为继承

继承的格式

  1. class A {
  3. }
  5. class B extends A {
  7. }
  8. 类B 继承 类A

类A：父类，超类，基类
类B：子类，派生类

继承的好处

  1. 提高了代码的复用性
  2. 让类与类之间产生了继承关系，这是构成多态的前提条件

继承的弊端

提高了代码的耦合性

开发原则：高内聚，低耦合

高内聚：是指一个人的能力越强越好
低耦合：是指一个人的关系越少越好

父类出现变化，子类也会发生改变

继承的特点

在Java中，类只支持单继承，不可以多继承，可以多层继承，不可以循环继承。

单继承：

  1. class Fu {
  3. }
  5. class Zi extends Fu {
  7. }

多层继承：

  1. class Ye {
  3. }
  5. class Fu extends Ye {
  7. }
  9. class Zi extends Fu {
  11. }

循环继承：

  1. class Fu extends Zi {
  3. }
  5. class Zi extends Fu {
  7. }

image.png

继承的注意事项

  1. 子类不能继承父类中被private关键字所修饰的成员变量和成员方法

    1. class Fu {
    2.  private String name;
    3.  int age;
    5.  public void eat() {
    7.  }
    9.  private void drink() {
    11.  }
    12. }
    13. class Zi extends Fu {
    14.  public void print() {
    15.      System.out.println(name);//编译报错，因为父类的name被私有了
    16.      System.out.println(age);
    17.      eat();
    18.      drink();//编译报错，因为父了drink()被私有了
    19.  }
    20. }

  2. 子类不能继承父类中的构造方法

什么时候使用继承

当两个类之间存在”is a”的关系的时候，我们就可以使用继承

举例子：
人类
学生类
老师类
狗类

人类 is a 学生类 XXX 所以人类不能继承学生类
人类 is a 老师类 XXX 所以人类不能继承老师类
人类 is a 狗类 XXX 所以人类不能继承狗类
学生类 is a 人类 所以学生类可以继承人类
学生类 is a 老师类 XXX 所以学生类不能继承老师类
学生类 is a 狗类 XXX 所以学生类不能继承狗类
老师类 is a 人类 所以老师类可以继承人类
老师类 is a 学生类 XXX 所以老师类不能继承学生类
老师类 is a 狗类 XXX 所以老师类不可以继承狗类

  1. class Person {}
  3. class Student extends Person {}
  5. class Teacher extends Person {}
  7. class Dog {}

注意：我们不能单单为了获取某个功能而瞎去继承一个类

  1. class Bird {
  2.     public void fly() {
  4.     }
  5. }
  7. class Person extends Bird {
  8.     /*
  9.     public void fly() {
  11.     }
  12.     */
  13. }
  15. class Demo {
  16.     public static void main(String[] args) {
  17.         Person p = new Person();
  18.         p.fly();
  19.     }
  20. }

在子父类继承中成员变量的关系

假如在父类中有一个成员变量，在子类中有一个成员变量，在子类的成员方法中有一个局部变量

如果这三个变量的名字都不同的话：

  1. class Fu {
  2.     int i = 1;
  3. }
  5. class Zi extends Fu {
  6.     int j = 2;
  8.     public void print() {
  9.         int a = 3;
  10.         System.out.println(a);//3
  11.         System.out.println(j);//2
  12.         System.out.println(i);//1
  13.         //可以一起共存
  14.     }
  15. }
  17. class Demo {
  18.     public static void main(String[] args) {
  19.         Zi zi = new Zi();
  20.         zi.print();
  21.     }
  22. }

如果这三个变量的名都相同的话：

  1. class Fu {
  2.     int i = 1;
  3. }
  5. class Zi extends Fu {
  6.     int i = 2;
  8.     public void print() {
  9.         int i = 3;
  11.         System.out.println(i);//3
  12.         System.out.println(i);//3  就近原则
  13.         System.out.println(i);//3
  14.     }
  15. }
  17. class Demo {
  18.     public static void main(String[] args) {
  19.         Zi zi = new Zi();
  20.         zi.print();
  21.     }
  22. }

那如果想要分别打印出1,2,3该怎么办？

  1. class Fu {
  2.     int i = 1;
  3. }
  5. class Zi extends Fu {
  6.     int i = 2;
  8.     public void print() {
  9.         int i = 3;
  11.         System.out.println(i);//3
  12.         System.out.println(this.i);//2
  13.         System.out.println(super.i);//1
  14.     }
  15. }
  17. class Demo {
  18.     public static void main(String[] args) {
  19.         Zi zi = new Zi();
  20.         zi.print();
  21.     }
  22. }

在子父类继承中构造方法的关系

  1. 子类在中的所有的构造方法的第一行，默认都有一个super() ```java class Fu { String name;

    public Fu() {

    1.  System.out.pintln("父类的构造方法被调用了");

    } }

class Zi extends Fu { public Zi() { //super();//默认调用父类的空参构造 }

  1. public Zi(String name) {
  2.     //super();//调用父类的空参构造
  3. }
  5. public Zi(int age) {
  6.     //super();//调用父类的空参构造
  7. }
  9. public Zi(String name, int age) {
  10.     //super();//调用父类的空参构造
  11. }

}

class Demo { public static void main(String[] args) { Zi zi = new Zi(); System.out.pintln(zi.name);//null 调用了父类的构造方法 } }

  1. 为什么会有这样的现象呢？<br />因为有继承，说明子类可以使用父类的成员变量，那也就意味着父类的成员变量一定要有一直才可以被使用，所以在创建类对象的时候，会调用子类的构造方法，而子类的构造方法中会先去调用父类的构造方法，目的就是给父类的额成员变量默认初始化
  3. 2. **子类中的所有的构造方法中，第一行要么是super(参数)，要么是this(参数)，他们不可以共存**
  4. ```java
  5. class Fu {
  7. }
  9. class Zi extends Fu {
  10.     public Zi() {
  11.         this("");//调用了下面的有参构造方法 ，this调用本类
  12.     }
  14.     public Zi(String name) {
  15.         //super(); //没写this默认就是super
  16.     }
  17. }
  1. 子类中所有的构造方法中必须要有至少有一个构造方法里面调用的是super(参数) ```java class Fu { //5 }

class Zi extends Fu { public Zi() { this(“aaa”);//1 }

  1. public Zi(String name) {
  2.     this(18);//2
  3. }
  5. public Zi(int age) {
  6.     this("aaa", 18);//3
  7. }
  9. public Zi(String name, int age) {
  10.     //4
  11.     //this("");会重新调用会1，所以要有
  12.     super();//要防止进入死循环
  13. }

}

class Demo { public static void main(String[] args) { Zi zi = new Zi(); } }

  3. <a name="DoZtQ"></a>
  4. ## 在子父类继承中成员方法的关系
  6. 在父类中有一个成员方法，在子类中有一个成员方法
  8. - 如果这两个方法的名字都不同的话：
  9. ```java
  10. class Demo {
  11.     public static void main(String[] args) {
  12.         Zi zi = new Zi();
  13.         zi.printFu();//fu
  14.         zi.printZi();//zi
  15.     }
  16. }
  18. class Fu {
  19.     public void printFu() {
  20.         System.out.println("fu...");
  21.     }
  22. }
  24. class Zi extends Fu {
  25.     public void printZi() {
  26.         System.out.println("zi...");
  27.     }
  28. }
  • 如果这两个方法的名字都相同的话： ```java class Demo { public static void main(String[] args) {
    1.   Zi zi = new Zi();
    2.   zi.print();//zi
    3.   zi.print();//zi
    } }

class Fu { public void print() { System.out.println(“fu…”); } }

class Zi extends Fu { public void print() { System.out.println(“zi…”); } } 通过观察，如果两个方法的名字相同的话，结果打印出来的子类中的内容

  2. 这里面涉及到一个知识点，叫做方法的重写，也叫作覆盖
  5. <a name="FpasW"></a>
  6. # 🎤 super关键字
  8. > super是父类内存空间的标记，在用法上，我们可以当做父类对象的引用来使用，但是我们不能说super就是父类对象的引用
  11. <a name="NEcWJ"></a>
  12. ## 调用构造方法
  13. ```java
  14. super(参数);
  15. 调用父类的构造方法
  16. this(参数);
  17. 调用本类的构造方法

调用成员方法

  1. super.方法名();
  2. 调用父类中的成员方法
  3. this.方法名();
  4. 调用本类中的成员方法

调用成员变量

  1. super.变量名;
  2. 调用父类中的成员变量
  3. this.变量名;
  4. 调用本类中的成员变量

🏇 方法的重写(Override)

在子父类继承中，子类中出现与父类方法的声明完全一致的方法，就称为方法的重写(不完全正确)

方法的重写(Overide)和方法的重载(Overload)的区别

  • 重载：在同一个类，两个方法的名字相同，参数列表不同
  • 重写：在子父类继承中，子类中的方法和父类中方法名是完全一致，参数列表也一致

我们怎么证明该方法是重写方法呢？
只需要在方法的声明上面加上@Override（判断是否方法重写），满足是不报红的，

重写的注意事项

  1. 子类不能重写父类中的私有（private)的成员方法
  2. 子类的方法的访问权限修饰符要大于等于父类的方法的访问权限修饰符

public > protected > 默认 > private

  1. class Fu {
  2.     protected void print() {
  4.     }
  5. }
  7. class Zi extends Fu {
  8.     public void print() {
  10.     }
  11. }

  1. 子类的方法的返回值类型可以和父类重写方法的返回值类不一致的，但是有条件，父类方法的返回值类型是子类方法的返回值类型的父类 ```java class Fu { public Person print() {

    } }

class Zi extends Fu { public Student print() {

  1. }

}

  1. ```java
  2. class Fu {
  3.     public Animal print(） {
  4.         return new Animal();
  5.     }
  6. }
  8. class Zi extends Fu {
  9.     @Override
  10.     public Dog print() {
  11.         return new Dog();
  12.     }
  13. }
  15. class Animal {}
  17. class Dog extends Animal {}
  18. class Cat extends Animal {}
  1. 静态方法只能重写静态方法

只要和静态相关的，三大特征都不会适用，因为静态超出了面向对象的范围

  1. class Fu{
  2.     public static void show() { //
  3.     }
  4. }
  6. class Zi extends Fu {
  7.     @Override
  8.     public static void show(){ //
  9.     }
  10. }

🤼‍♀️ 多态

面向对象三大特征之一

是指一个对象在不同的时刻，表现出来的不同的状态

比如说：
一个水滴
液态，气态，固态

多态的前提条件

  1. 要有继承关系
  2. 要有方法的重写(可以没有，但没意义)
  3. 要有父类引用指向子类对象

多态的代码体现

  1. class Fu {
  2.     public void print() {
  4.     }
  5. }
  7. class Zi extends Fu {//有继承关系
  8.     public void print(){//有方法重写
  10.     }
  11. }
  13. class Demo {
  14.     public static void main(String[] args) {
  15.         Fu fu = new Zi();//父类引用指向子类对象
  16.     }
  17. }

多态间子父类之间成员变量的关系

假如父类中有一个成员变量，子类中有一个成员变量

  • 如果这两个变量的名字不同的话： ```java class Fu { int i = 1; }

class Zi extends Fu { int j = 2; }

class Demo { public static void main(String[] args) { Fu fu = new Zi(); System.out.println(fu.i);//1 System.out.println(fu.j);//编译报错 } }

  1. **通过结果分析，父类引用不能使用子类中特有的成员变量**![image.png](https://cdn.nlark.com/yuque/0/2022/png/21490994/1647686154762-88d340ba-6797-4ae3-bd4f-1cf226161e8c.png#clientId=u64418b52-a230-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=629&id=ubc3b7de4&margin=%5Bobject%20Object%5D&name=image.png&originHeight=1258&originWidth=2800&originalType=binary&ratio=1&rotation=0&showTitle=false&size=832311&status=done&style=none&taskId=u878746f9-1dd1-4de8-a333-dbe38b3cff5&title=&width=1400)
  3. - 如果这两个方法的名字都相同的话
  4. ```java
  5. class Fu {
  6.     int i = 1;
  7. }
  9. class Zi extends Fu {
  10.     int i = 2;
  11. }
  13. class Demo {
  14.     public stati c void main(String[] args) {
  15.         Fu fu = new Zi();
  16.         System.out.println(fu.i);//1
  17.         System.out.println(fu.i);//1
  18.     }
  19. }

通过结果分析，父类引用只能使用自身带的成员变量，不能使用子类中成员变量

口诀： 多态的前提下，调用成员变量的时候，编译看左边，运行看左边

多态间子父类之间成员方法的关系

父类中有一个成员方法，子类中有一个成员方法

  • 如果这两个方法的名字都不同的话： ```java class Fu { public void printFu() {
    1.   System.out.println("fu");
    } }

class Zi extends Fu { //继承父类的成员方法 public void printZi() {
System.out.println(“zi”);
} }

class Demo { public static void main(String[] args) { Fu fu = new Zi(); fu.printFu();//fu fu.printZi();//编译报错 } }

  1. **通过结果分析，父类引用不能使用子类中特有的成员方法**
  4. - 如果这两个方法的名字都相同的话：
  5. ```java
  6. class Demo {
  7.     public static void main(String[] args) {
  8.         Fu fu = new Zi();
  9.         fu.print();//zi
  10.         fu.print();//zi
  11.     }
  12. }
  14. class Fu {
  15.     public void print() {
  16.         System.out.println("fu");
  17.     }
  18. }
  20. class Zi extends Fu {
  21.     public void print() { //方法重写了
  22.         System.out.println("zi");
  23.     }
  24. }

通过结果分析，父类引用可以使用子类中重写父类的方法
image.png口诀：多态的前提下，调用成员方法，编译看左边，运行看右边

多态间子父类在之间静态成员的关系

  1. class Fu {
  2.     static int i = 1;
  3. }
  5. class Zi extends Fu {
  6.     static int j = 2;
  7. }
  9. class Demo {
  10.     public static void main(String[] args) {
  11.         Fu fu = new Zi();
  12.         System.out.println(fu.i);
  13.         System.out.println(fu.j);
  14.     }
  15. }
  17. -----------------------------------------------
  19. class Fu {
  20.        public static void print() {
  21.         System.out.println("fu");
  22.         }
  23.     }
  25. class Zi extends Fu {
  26.     public static void print() {
  27.         System.out.println("zi");
  28.     }
  29. }
  31. class Demo {
  32.     public static void main(String[] args) {
  33.         Fu fu = new Zi();
  34.         fu.print();//fu
  35.     }
  36. }

口诀：多态的前提下，静态的 成员变量和成员方法，编译看左边，运行看看左边

多态的好处

提高了代码的扩展性

父类引用作为形参，子类对象作为实参

  1. public class Demo02 {
  2.     public static void main(String[] args) {
  3.            AnimalTool.print(new Cat()); 
  4.         AnimalTool.print(new Dog());
  5.         AnimalTool.print(new Pig());
  6.         AnimalTool.print(new Bird());
  7.         AnimalTool.print(new Sheep());
  8.     }
  9. }
  11. //动物工具类
  12. class AnimalTool {
  13.     public static void print(Animal animal) {//Animal animal = new Cat()
  14.         animal.eat();
  15.     }
  16. }
  18. class Animal {
  19.     public void eat() {
  20.     }
  21. }
  23. class Dog extends Animal {
  24.     public void eat() {
  25.         System.out.println("吃骨头");
  26.     }
  27. }
  28. class Cat extends Animal {
  29.     public void eat() {
  30.         System.out.println("吃鱼");
  31.     }
  32. }
  33. class Pig extends Animal {
  34.     public void eat() {
  35.         System.out.println("吃白菜");
  36.     }
  37. }
  38. class Bird extends Animal {
  39.     public void eat() {
  40.         System.out.println("吃虫子");
  41.     }
  42. }
  43. class Sheep extends Animal {
  44.     public void eat() {
  45.         System.out.println("吃草");
  46.     }
  47. }
  1. 例子：
  2. public class Demo02 {
  3.     public static void main(String[] args) {
  5.         public static void print(Cat cat) { //Cat cat = new Cat()
  6.             cat.eat();
  7.          }
  8.         public static void print(Dog dog) {
  9.             dog.eat();
  10.          }
  11.          public static void print(Pig pig) {
  12.             pig.eat();
  13.          }
  14.     }
  15. }
  17. //动物工具类
  18. class AnimalTool {
  20.    public static void print(Cat cat) {
  21.         cat.eat();
  22.     }
  23.     public static void print(Dog dog) {
  24.         dog.eat();
  25.     }
  26.     public static void print(Pig pig) {
  27.         pig.eat();
  28.     }
  30. }
  32. class Dog{
  33.     public void eat() {
  34.         System.out.println("吃骨头");
  35.     }
  36. }
  37. class Cat{
  38.     public void eat() {
  39.         System.out.println("吃鱼");
  40.     }
  41. }
  42. class Pig{
  43.     public void eat() {
  44.         System.out.println("吃白菜");
  45.     }
  46. }
  47. class Bird{
  48.     public void eat() {
  49.         System.out.println("吃虫子");
  50.     }
  51. }
  52. class Sheep{
  53.     public void eat() {
  54.         System.out.println("吃草");
  55.     }
  56. }

image.png

多态的弊端

父类引用不能使用子类中特有的内容

怎么解决？
向下转型来解决这个问题

  1. 向上转型：Fu fu = new Zi();
  2. 向下转型：Zi zi = (Zi)fu;
  1. class demo {
  2.     public static void main(String[] args) {
  4.         Person p = new Student();//向上转型
  5.         p.eat();//吃肉
  7.         //向下转型
  8.         Student s = (Student)p;
  9.         s.play();
  10.         s.eat();
  12.         /*Teacher t = (Teacher)p;
  13.         t.eat();
  14.         t.teach();*/
  15.     }
  16. }
  18. class Person {
  19.     public void eat() {
  20.         System.out. println("吃饭");
  21.     }
  22. }
  24. class Student extends Person {
  25.     public void eat() {
  26.         System.out.println("吃肉");
  27.     }
  28.     public void play() {
  29.         System.out.println("玩游戏");
  30.     }
  31. }
  32. class Teacher extends Person {
  33.     public void eat() {
  34.         System.out.println("吃肉");
  35.     }
  36.     public void teach() {
  37.         System.out.println("教书");
  38.     }
  39. }

注意：向下转型转不好，容易出现异常，ClassCastException类型转换异常，是在运行的时候报错

  1. 动物 a = new 狗();
  3. 狗 d = (狗)a; //正确的向下转型
  4. 猫 m = (猫)a; //错误的，狗的堆空间怎么给猫用

image.png