• 面向对象的三大特征—继承

• ​ 抽象类

继承

继承后的特点—成员方法

成员方法不重名

​ 如果子类父类中出现不重名的成员方法，这时的调用是没有【任何影响的】，对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在该方法那么就执行子类中的方法，若子类当中不存在该方法那么会执行父类当中的成员方法。

public class Fu {
     int num = 10; 
    // 展示
     public void show() {
         System.out.println("Fu类中show方法在执行！");
         System.out.println("Fu类中的成员变量num：" + num)
     }
}
public class Zi extends Fu {
    int num = 20;
    // 展示
    public void show2() {
        System.out.println("Zi类中的show方法在执行！");
        System.out.println("Zi类中的成员变量num：" +num);
    } 
}
public class TestExtends {
    
    public static void main(String[] args) {
        // 构建子类对象
        Zi zi = new Zi();
        zi.show();// 调用父类当中的show方法   Fu类中show方法在执行！  10 
        zi.show2();// 调用子类当中的show2方法 Zi类中的show方法在执行！20 
    }  
}

成员方法重名-----重写(Override)

​ 如果父子类中出现了重名的成员方法，这时的访问是一种特殊情况。叫做方法重写(Override)。

• 方法重写：子类中出现与父类一模一样的方法时(返回值类型，方法名和参数列表)，会出现覆盖效果，也称为重写或者复写，简称“【声明不变，重新实现】”。

  示例代码：

  public class Fu {
      int num = 10;
      public void show() {
          System.out.println("Fu show()方法在执行！");
          System.out.println("Fu 成员变量num：" + num);
      }
  }
  public class Zi extends Fu {
      int num = 20;
      public void show() {
          System.out.println("Zi show()方法在执行！");
          System.out.println("Zi 成员变量num：" + num);
      }
  }
  public class TestExtendsDemo02 {
      public static void main(String[] args) {
          // 先构建一个子类的对象
          Zi zi = new Zi();
          // 调用show方法
          // 子类中有show()方法，执行的是重写后的show()
          zi.show();//  Zi show()方法在执行！  20    
      }
  }
  
  

  重写的应用

  ​ 子类可以根据需要，定义特定于自己的行为，既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行功能扩展。

  public class Phone {
      // 打电话
      public void call(){
          System.out.println("打电话！");
      }
      // 发短信
      public void sendMessage(){
          System.out.println("发短信！");
      }
      // 来电显示
      public void show() {
          System.out.println("来电显示电话号码！");
      }
  }
  public class IPhone12 extends Phone {
      // 重写父类当中的来电显示功能，并增加自己的显示姓名和显示头像功能
      public void show() {
          // 父类当中的功能保持不变
          super.show();
          // 新增新功能
          System.out.println("显示姓名！");
          System.out.println("显示头像！");
      }    
  }
  public class TestExtendsDemo03 {
      public static void main(String[] args) {
          // 创建一个子类对象
          IPhone12 iphone = new IPhone12();
          //调用父类当中的打电话
          iphone.call();
          // 调用重写之后的来电显示功能
          iphone.show(); //显示电话号码  显示姓名  显示头像
      }
  }
  
  

  重写：方法的名称一样，参数列表【一样】，返回值类型【也一样】，重写前提有继承关系

  重载：方法的名称一样，参数列表【不一样】，返回值类型无要求，在本类中。

​ 注意事项：

• ​ 子类方法重写父类方法，必须要保证权限要大于等于父类权限
• ​ 子类方法覆盖父类方法，返回值类型、方法名称和参数列表必须要一模一样。

继承后的特点-----构造方法

​ 先回忆下构造方法的定义和作用：

1. ​ 构造方法的名字和类名要保持一致，所以子类是无法继承父类当中的构造方法

2. ​ 构造方法的作用一般是用来初始化成员变量，所以子类在初始化的过程中，必须先执行父类中的初始化动作。子类的构造方法当中默认有一个super()方法，表示调用的父类的构造方法，父类的成员变量初始化之后，才可以给子类使用。

   public class Fu {
       private int n;
       public Fu(){
           System.out.println("Fu()");
       }  
   }
   public class Zi extends Fu {
       public Zi() {
           // super() 调用父类中的构造方法  隐式调用
           System.out.println("Zi()");
       }  
   }
   public class TestExtendsDemo04 {
       
       public static void main(String[] args) {
           Zi zi = new Zi();      
       }  
   }
   // 输出结果
   // Fu()
   // Zi()
   

   super 和 this

   ​ 父类空间优先于子类对象产生

   ​ 在每次创建子类对象的时候，先初始化父类空间，再创建子类对象。目的在于子类对象中包含了其对应的父类空间，便可以包含父类的成员，如果父类成员非私有，则子类可以随意使用父类成员，代码体现在子类的构造方法调用时，会先调用父类的构造方法。