好像直接奔總結了,經常偷懶只能總結全點............

封裝,繼承,多型面向物件的三大特徵

封裝思想

• 就是把欄位和方法單獨存放在一個獨立的模組內
• 資訊隱藏,儘可能隱藏物件的資料和功能實現細節

好處:

• 保證資料的安全性,防止呼叫者隨意修改資料
• 提高元件的重用性

這就不得不提到JavaBean規範

public class Preson{//必須以public修飾類
    private string  name;//成員變數必須以private(私有化),提供getter和setter方法
    private int age;

        public Preson(){}//
 
提供無參構造
        public Preson(String name,int age){//提供有參構造
          this.name=name;
          this.age=age;
     }
         public String getName() {
        return name;
    }
    public void setName(String n) {
        name = n;
    }
    public int getAge() {
        return age;
    }
    public void
 
 setAge(int a) {
        if(a < 0) {
            System.out.println("非法的年齡");
            return;
        }
        age = a;
    }
}    

繼承

當有多個類使用重複程式碼時,抽取為一個父類.

public class Person{//子類繼承並不會繼承父類的構造器,以及成員變數private String name;

private int age;

   public Person(){}
   public Person(String name,int
 
 age){
         this.name=name;
         this.age=age;  
   }

        public void rest() {
        System.out.println("休息");
    }
    public String getName() {
        return name;
    }
        public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
/*
如果父類中的成員使用public和protected修飾，子類都能繼承.
*/

public Student extends Person{}//is a的思想學生是人
public Teacher extends Person{}

但注意繼承支援單繼承,多重繼承

**當父類方法不滿足子類需求時,可以重寫父類方法!!!!

多型

就是編譯型別與執行型別不一致時,就產生了多型

編譯型別:宣告物件變數的型別,編譯型別必須是父類或介面

執行型別:物件真實型別

Dog     d     =     new Dog();      //建立一隻狗物件,賦給子類型別變數,執行型別
Animal  a      =    new Cat();        //建立一隻貓物件,賦給父類型別變數,編譯型別

多型的執行流程

編譯時,它會先到父類找方法是否存在,存在則到子類尋找,有就執行子類的方法,沒有就執行父類的方法

那假設碰到子類獨有的方法呢?

就有了(型別的轉換)

//自動型別轉換：把子類物件賦給父類變數（多型）
     Animal a = new Dog();
     Object  obj = new Dog();    //Object是所有類的根類
//強制型別轉換：把父類型別物件賦給子類型別變數（前提：該物件的真實型別應該是子類型別）
     Animal a = new Dog();
     Dog    d = (Dog) a;    //正確
     Cat      c = (Cat) a;    //錯誤

那多型到底好處在哪呢?

public class MotherBoard {//每次實現,都需要在主類上寫一個方法是否很麻煩?
    //在主機板上安裝滑鼠物件
    public void plugin(Mouse m) {
        m.work1();    //呼叫滑鼠工作的方法
    }
    //在主機板上安裝鍵盤物件
    public void plugin(Keyboard k) {
        k.work2();    //呼叫鍵盤工作的方法
    }
}

看例項,

當在主類上直接實現了介面的方法後,就不需要重複的在父類寫這個方法了

public class Mouse implements IUSB{
    
    public void swapData() {
        System.out.println("滑鼠在移動");
    }
}

public class Keyboard implements IUSB{
    
    public void swapData() {
        System.out.println("用鍵盤打字");
    }
}


public class MotherBoard {
   //IUSB型別可以接受實現類物件
    public void plugin(IUSB usb) {
        usb.swapData();
    }
}


public class USBDemo {
    public static void main(String[] args) {
        // 建立主機板物件
        MotherBoard board = new MotherBoard();
        // 建立滑鼠物件
        Mouse m = new Mouse();
        // 建立鍵盤物件
        Keyboard k = new Keyboard();
        //在主機板上安裝滑鼠
        board.plugin(m);
        //在主機板上安裝鍵盤
        board.plugin(k);
    }
}

介面

制定規範和分離的思想,也是體現元件之間的低耦合思想

public interface I介面名{//介面的命名必須以'I'開頭
  //抽象方法1  (抽象方法可以省略,public abstract,而在Java8介面中也可以有實現方法)
  //抽象方法1 
  //抽象方法1 
 default void defaultMethod(){
        System.out.println("有預設實現的方法, 屬於物件");
    }
    static void defaultMethod(){
        System.out.println("有預設實現的方法, 屬於類");
    }

}

介面時支援多繼承的,可以有多個介面

public class A implements 介面名稱1,介面名稱2...{}

但是當你呼叫介面成為實現類時,就必須覆蓋所有方法,否則就要變為抽象方法

歡迎大家吐槽,雖然應該沒人看