Day08

封裝：

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

//類   private: 私有
public class Student {
    private String name; //名字
    private int id;      //學號
    private char sex;    //性別
    private int age;
    //get 獲得這個資料
    public String getName(){
        return this.name;
    }

    //set 給這個資料設定值
    public void setName(String name){
        this.name = name;
    }

    //alt + insert


    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>0 && age<120) {
            this.age = age;
        }else{
            this.age = 3;
        }
    }
}
 

/*
    1. 提高程式的安全性，保護資料
    2. 隱藏程式碼的實現細節
    3. 統一介面
    4. 系統可維護增加了
 */
public class Application {
    public static void main(String[] args){
        Student s1 = new Student();
        s1.setName("請將");
        System.out.println(s1.getName());
        s1.setAge(-1);
        System.out.println(s1.getAge());
    }
}
 

繼承：

• 繼承的本質是對某一批類的抽象，從而實現對顯示世界更好的建模。
• extends的意思是“擴充套件”。子類是父類的擴充套件。
• JAVA中類只有單繼承，沒有多繼承。
• 繼承是類與類之間的一種關係。除此之外，類和類之間的關係還有依賴。組合，聚合等。
• 繼承關係的兩個類，一個為子類（派生類），一個為父類（基類）。子類繼承父類，使用關鍵字extends來表示。
• 子類和父類之間，從意義上講應該有“is a ”的關係。

//老師 is 人
public class Teacher extends Person{
}

//學生 is 人: 派生類，子類
//子類繼承了父類，就會擁有父類的全部方法！
public class Student extends Person{

    //CtrL + H
}
 

• object類

public class Application {
    public static void main(String[] args){
        Student student = new Student();
        student.say();
        student.setMoney(10_0000);
        System.out.println(student.getMoney());
    }
}

//在Java中，所有的類，都預設直接或者間接繼承object類。
//Person 人
public class Person {

    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("說了一句話");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

• super
  • super呼叫父類的構造器，必須在構造方法的第一個
  • super必須只能出現在子類的方法或者構造方法中
  • super和this不能同時呼叫構造方法
• vs this：
  • 代表的物件不同：
    • this：本身呼叫這個物件
    • super：代表父類物件的引用
  • 前提
    • this：沒有繼承也可以使用
    • super：只能在繼承條件下在可以使用
  • 構造方法
    • this(); 本類的構造
    • super()；父類的構造

public class Person {

    public Person(){
        System.out.println("Person無參執行了");
    }

    //public
    //protected
    //default
    //private
    protected String name = "kuangshen";

    //私有的東西無法被繼承
    public void print(){
        System.out.println("Person");
    }
}

• 方法重寫 ：需要有繼承關係，子類重寫父類的方法
  • 方法名必須相同
  • 引數列表必須相同
  • 修飾符：範圍可以擴大但不能縮小： public>protected>default>private
  • 丟擲的異常：範圍可以被縮小，但不能擴大；ClassNotFoundException --> Exception(大)
• 為什麼需要重寫：
  • 父類的功能，子類不一定需要，或者不一定滿足
  • Alt + Insert: override;

//繼承
public class A extends B {

    //Override 重寫
    @Override //註解：有功能的註釋！
    public void test() {
        System.out.println("A==>test()");
    }
}

//重寫都是方法的重寫，和屬性無關
public class B {

    public void test(){
        System.out.println("B==>test()");
    }
}

public class Application {

    //靜態的方法和非靜態的方法區別很大
    //靜態方法：//方法的呼叫只和左邊，定義的資料型別有關

    //非靜態：重寫 public

    public static void main(String[] args){
        //Student student = new Student();
        //student.test("秦疆");
        //student.test1();

        A a = new A();
        a.test();//A

        //父類的引用指向了子類
        B b = new A();//子類重寫了父類的方法
        b.test();//B
    }
}

多型：

• 注意事項：
  • 多型的hi方法的多型，屬性沒有多型
  • 父類和子類，有聯絡 型別轉換異常！ClassCastException!
  • 存在條件：繼承關係，方法需要重寫，父類引用子類物件！ Father f1 = new Son();
    • static 方法，屬於類，它不屬於實列
    • final 常量
    • private 方法

public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {
    public void run(){
        System.out.println("son");
    }

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

public class Application {
    public static void main(String[] args){

        //一個物件的實際型別是確定的
        //new student();
        //new Person();

        //可以指向的引用型別就不確定了：父類的引用指向子類

        //Student 能呼叫的方法都是自己或者繼承父類的！
        Student s1 = new Student();
        //Person 父型別，可以指向子類，但是不能呼叫子類獨有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //物件能執行哪些方法，主要看物件左邊的型別，和右邊關係不大！
        ((Student) s2).eat();//子類重寫了父類的方法，執行子類的
        s1.eat();
    }
}

• instanceof (型別轉換) 引用型別，判斷一個物件是什麼型別

of Object);//true
        System.out.println(person instanceof Teacher);//False
        //System.out.println(person instanceof String);//編譯報錯
        System.out.println("=======================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//編譯報錯
        //System.out.println(person instanceof String);//編譯報錯
    }
}

• 類的強制轉換

public class Application {
    public static void main(String[] args){
        //型別之間的轉化：父   子

        //高                       低
        Person obj = new Student();

        //student將這個物件轉換為Student型別、我們就可以使用Student型別的方法

        Student student = (Student) obj;
        student.go();
    }
}





/*
1. 父類引用指向子類的物件
2. 把子類轉換為父類，向上轉型
3. 把父類轉換為子類，向下轉型：強制轉換
4. 方便方法的呼叫，建士重複的程式碼
 */