繼承

　　在繼承的關系中，子類就是一個父類，也就是說，子類可以被當做父類看待，例如：父類是員工，子類是程序員，那麽程序員就是一個員工，代碼示例：

// 員工類
public class Employee{
    String name;
    int age;
}

// 程序員類(繼承員工類)
public class Programer extends Employee{
} 

// 主方法
public class Extends {
    public static void main(String[] args) {
        Programer coder 
 
= new Programer();
        coder.name = "johny";
        coder.age = 20;
        System.out.println(coder.name + " " + coder.age);  // johny 20
    }
}

　　在父子類的繼承關系當中，如果成員變量重名，則創建子類對象時，訪問有兩種方式：

1. 1. 直接通過子類對象訪問成員變量（優先使用自己的，沒有則向上找）
   2. 間接通過成員方法訪問成員變量（看方法屬於誰，就優先用誰的，沒有則往上找，找不到就報錯）

　　在父子類的繼承關系中，創建子類對象，訪問成員方法的規則：

1. 1. 創建的對象是誰，就優先用誰（優先使用自己的），如果沒有就向上找

　　無論是成員方法還是成員變量，如果沒有都是向上找父類，絕不會向下找

區別子類方法中重名的三種變量

　　局部變量： 直接寫成成員變量名

　　本類中的成員變量：this.成員變量名

　　父類中的成員變量：super.成員變量名

繼承中方法的覆蓋

　　覆蓋與方法的重載不同，同樣是方法名相同，但覆蓋指接收的參數也相同

// 父類
public class Phone {
    public void call(){
        System.out.println(
 
"call");
    }

    public void send(){
        System.out.println("send");
    }
}

// 子類
public class NewPhone extends Phone{
    // 方法權限必須大於等於父類
    public void call(){
        // 調用父類方法
        super.call();
        // 添加自己的邏輯
        System.out.println("show picture");
    }
}

public class DemoCover {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.call();  // call \n show picture
    }
}

　　註意事項：

1. 在子類方法前面寫上 @Override，用來檢測是不是有效的覆蓋重寫
2. 子類方法的返回值必須小於等於父類方法的返回值範圍（例如：子類返回String，父類返回Object）
3. 子類方法的權限必須大於等於父類方法的權限修飾符

　　　　　　　　權限修飾符：public > protected > (default) > private

繼承中構造方法的訪問特點

1. 子類構造方法中有一個默認隱含的 "super()" 調用，所以一定是先調用的父類構造，再調用的子類構造
2. 子類構造可以通過 "super" 關鍵字來調用父類的重載構造（當父類含有多個構造方法）
3. super 的父類構造方法調用，必須是子類構造方法的第一條語句，且只能調用一次 super 構造

　　子類必須調用父類的構造方法，不寫則是默認的 super()，寫了就調用指定的 super

super 關鍵字的三種用法

1. 在子類的成員方法中，使用 super 得到父類的成員變量
   
2. 在子類的成員方法中，使用 super 訪問父類的成員方法
3. 在子類的構造方法中，使用 super 訪問父類的構造方法

this 關鍵字的三種用法

　　super 關鍵字用來訪問父類內容，而 this 關鍵字用來訪問本類內容

1. 在本類的成員方法中，使用 this 得到本類中的成員變量
2. 在本類的成員方法中，使用 this 得到本類中的成員方法
3. 在本類的構造方法中，使用 this 調用本類的重載構造方法（另一個構造方法）

　　　　this(…) 調用也必須是構造方法中的第一條語句，且只能使用一次

　　　　super 和 this 兩種構造使用，不能同時使用

繼承的三個特點圖解

抽象方法和抽象類

　　抽象方法：就是在 void 前面加上 abstract 關鍵字，然後去掉大括號，直接分號結束

　　抽象類：抽象方法所在的類，必須是抽象類，在 class 前面加上 abstract 關鍵字

// 這是一個抽象類
public abstract class Animal{
    // 這是一個抽象方法，代表吃東西，具體吃什麽？不知道
    public abstract void eat();
}

　　如何使用抽象類和抽象方法？

1. 1. 不能直接 new 抽象類，必須使用子類繼承抽象父類
   2. 非抽象子類必須覆蓋重寫父類的所有的抽象方法
   3. 創建非抽象子類對象時進行使用

      // 抽象父類
      public abstract class Animal{
          public Animal(){
              System.out.println("抽象父類構造方法執行");
          }
          // 抽象方法
          public abstract void eat();
          public abstract void sleep();
      }
      
      // 抽象子類
      public abstract class Dog extends Animal{
          @Override
          public void eat(){
              System.out.println("dog eat meat");
          }
      }
      
      // 間接子類
      public class JinMao extends Dog {
          @Override
          public void sleep(){
              System.out.println("JinMao in his sleeping");
          }
      }
      public class HaShiQi extends Dog {
          @Override
          public void sleep(){
              System.out.println("HaShiQi in his sleeping");
          }
      }
      
      public class DemoAbstract{
          public static void main(String[] args){
              JinMao jinMao = new JinMao();
              jinMao.eat();
              jinMao.sleep();
      
              HaShiQi haShiQi = new HaShiQi();
              haShiQi.eat();
              haShiQi.sleep();
          }
      }
      
      // 執行結果
      抽象父類構造方法執行
      dog eat meat
      JinMao in his sleeping
      抽象父類構造方法執行
      dog eat meat
      HaShiQi in his sleeping

      View Code

發紅包的案例

Java 面向對象_繼承