技術標籤：java

繼承
有的時候客觀事物之間就存在一些關聯關係，那麼在表示成類和物件的時候也會存在一定的關聯。
例如 貓它是動物，就具有動物的基本屬性，當我們定義貓這個類時，有些動物屬性我們沒必要重複定義，只需要讓貓這個類繼承動物這個類就可以了。
表現形式： A extends B

• A： 子類 、 派生類
• B： 父類 、 基類 、 超類

子類繼承了父類的什麼？
除 構造方法 外的所有東西 ！！！
this 和 super 關鍵字的區別？（面試）
this 代表的是當前物件的引用 super 代表的是父類的引用
構造方法完成後，一個物件才被創建出來，但是我們又看到 this 出現在了構造方法裡 ，

• （1）private: 類內部能訪問, 類外部不能訪問 （私有的）
• （2）預設(也叫包訪問許可權 default): 類內部能訪問, 同一個包中的類可以訪問, 其他類不能訪問
• （3）protected: 類內部能訪問, 子類和同一個包中的類可以訪問, 其他類不能訪問.（受保護的）
• （4）public: 類內部和類的呼叫者都能訪問（公共的）

重寫 與 過載的區別 ？
過載 ：（overload）
1.引數的個數不同 2.引數的型別不同 3.引數的順序不同
重寫 ： （override）
（1）方法名相同；
（2）引數列表相同（引數的個數，引數的型別）
（3）返回值也要相同
final 的用法：
（1）final 可以修飾變數 （變為常量），只能初始化一次
（2）final 可以修飾類 ，表示當前類不能被繼承（final class Animal）
（3）final 可以修飾方法 ， 當前修飾的方法不能被重寫
繼承程式碼實現案例
動物類

package com.example.
 
demo.oop;

/**
 * 動物類
 */
public class Animal {

    //名稱
    private String name;
    //年齡
    private String age;
    //體重
    private String weight;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getWeight() {
        return weight;
    }

    public void setWeight(String weight) {
        this.weight = weight;
    }
}

小貓類

package com.example.demo.oop;

public class Cat extends Animal {

    //移動速度
    private String speed;

    public Cat(String speed) {
        this.speed = speed;
    }

    public Cat() {
        super();
    }


    public String getSpeed() {
        return speed;
    }

    public void setSpeed(String speed) {
        this.speed = speed;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "speed='" + speed + '\'' +
                '}';
    }
}

測試方法

public class Test {

    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.setSpeed("10米/秒");
        cat.setName("小喵");
        cat.setAge("2");
        cat.setWeight("500g");
        System.out.println(JSONObject.toJSONString(cat));

    }

}

結果如下：

多型
多型： 其實就是一種思想，從程式碼層次來說 ： 父類引用引用子類物件，且父類和子類有同名的覆蓋方法（重寫），通過父類的引用來呼叫同名的覆蓋方法的時候，他有可能會表現出不同的行為，把表現出這種不同行為的過程，這種思想我們叫做多型。

向上轉型：父類的引用，引用子類物件
① 直接賦值 ② 方法的傳參 ③ 返回值
動態繫結：

• 1、父類的引用，引用子類的物件（向上轉型）
• 2、通過父類的引用，呼叫子類和父類重寫的那個方法

使用多型的好處：
1、類呼叫者對類的使用成本進一步降低.封裝是讓類的呼叫者不需要知道類的實現細節，多型能讓類的呼叫者連這個類的型別是什麼都不必知道, 只需要知道這個物件具有某個方法即可.因此, 多型可以理解成是封裝的更進一步, 讓類呼叫者對類的使用成本降低
2、能夠降低程式碼的 “圈複雜度”, 避免使用大量的 if - else（圈複雜度：一段程式碼中條件語句和迴圈語句出現的次數）
3、可擴充套件能力更強
多型實現的程式碼案例

public class Test2 {

    //構造器
    public static void drawMap(Shape shape) {
        shape.draw(); //多型的核心
    }

    public static void main(String[] args) {
        Shape shape1 = new Cycle();
        Shape shape2 = new Rect();
        drawMap(shape1);
        drawMap(shape2);
    }

}

class Shape {
    public void draw() {
    }
}

class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("畫一個⚪圈!");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("畫一個♦");
    }
}

執行結果：