面向物件三大特性（Java）：封裝繼承多型——

阿新 • • 發佈：2022-04-10

封裝

該露的露，該藏的藏
- 我們程式設計要追求"高內聚，低耦合"。高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。
封裝（資料的隱藏）
- 通常，應禁止直接訪問一個物件中資料的實際表示，而應通過操作介面來訪問，這稱為資訊隱藏。
記住這句話就夠了：屬性私有，get/set

package com.oop.Test04;
//類 private:私有
public class Student {
    //屬性私有
    //姓名
    private String name;
    //學號
    private int id;
    //性別
    private char sex;
    //年齡
    private int age;
//提供一些可以操作這個屬性的方法！
//提供一些public的get、set方法
    //get獲得這個資料
    public String getName(){
        return this.name;
    }
    //set給這個資料設定值
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0){
            age = 3;
        }
        this.age = age;
    }
//IDEA快捷鍵Alt+Insert+Fn 快速生成set/get方法。
}
       /*
        封裝的意義：
        1.提高程式的安全性，保護資料
        2.隱藏程式碼的實現細節
        3.統一介面
        4.提高了系統的可維護性
         */

繼承

繼承的本質是對某一批類的抽象，從而實現對現實世界更好的建模。

extends的意思是"擴充套件"。子類是父類的擴充套件。

Java中類只有單繼承，沒有多繼承。

繼承是類和類之間的一種關係。除此之外，類和類之間的關係還有依賴、組合、聚合等。
繼承關係的兩個類，一個為子類（派生類），一個為父類（基類）。子類繼承父類，使用關鍵字extends來表示。
子類和父類之間，從意義上講應該具有"is a"的關係。

package com.oop.Test05;
//Person 人 ： 父類
public class Person /*extends Object*/ {
//    public
//    protected
//    default
//    private
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("說了一句話");
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
}
/*測試類
    public static void main(String[] args) {
        Person person = new Person();
        person.getClass();
        System.out.println(person.getMoney());
        }
 */
//在Java中，所有的類都預設直接或者間接繼承object

object類

super

方法重寫

關於方法重寫

package com.oop;
import com.oop.Test05.A;
import com.oop.Test05.B;
public class Application {
    public static void main(String[] args) {
        //靜態方法：方法的呼叫只和左邊定義的資料型別有關
        //非靜態：重寫
        A a = new A();
        a.test();//A類
        //父類的引用指向了子類
        B b = new A();//子類重寫了父類的方法
        b.test();//B類


    }

}
/*
重寫：
需要有繼承關係，子類重寫父類的方法！
1.方法名必須相同
2.引數列表必須相同
3.修飾符：範圍可以擴大，但不能縮小；
4.丟擲的異常：範圍，可以被縮小，但不能擴大；ClassNotFoundException -->Exception(大)
重寫：子類的方法和父類必須要一致；方法體不同！
為什麼需要重寫？
父類的功能，子類不一定需要，或者不一定滿足！
IDEA快捷鍵 Alt+Fn+Insert：選中Override可以自動幫我們重寫方法。
 */

多型

動態編譯
即同一方法可以根據傳送物件的不同而採用多種不同的行為方式
一個物件的實際型別是確定的，但可以指向物件的引用的型別有很多（父類，有關係的類）
多型存在的條件：
- 有繼承關係
- 子類重寫父類方法
- 父類引用指向子類物件
注意：多型是方法的多型，屬性沒有多型性。
instanceof （型別轉換）引用型別

/*
多型注意事項：
1.多型是方法的多型，屬性沒有多型
2.父類和子類，有聯絡 才能轉換  型別轉換異常! ClassCastException!
3.存在的條件：繼承關係，方法需要重寫，父類引用指向子類物件！father f1 = new Son();
     1.static 方法，屬於類，它不屬於例項
     2.final 無法重寫 常量；
     3.private方法：不能重寫；
 */

    public static void main(String[] args) {
        //一個物件的實際型別是確定的
        //new Student();
        //new Person();
        //可以指向的引用型別就不確定了:父類的引用指向子類
        //Student 能呼叫的方法都是自己的或者繼承父類的！
        //Person 父型別，雖然可以指向子類，但是不能呼叫子類獨有的方法
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run();//子類重寫了父類的方法，就是執行子類的方法
        s1.run();
        //物件能執行哪些方法，主要看物件左邊的型別，和右邊關係不大！
        s1.eat();
        ((Student) s2).eat();
    }