封裝、繼承、重載、重寫、多態

　　有時候，代碼寫的很多，但有些術語卻老是記得不太清楚；有些原理，明明常常用到，但卻不太會描述。既然如此，那就記錄下來，印象不深的時候再來看看。

　　1.封裝：把對象的屬性、操做（或業務）結合爲一個總體（class），並儘量得隱藏內部實現細節，使得對數據的訪問只能經過已定義的接口。

public class Person {
    private String name = "張三";
    
    private int age = 18;

    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 void eat(){
        System.out.println("人要吃東西。");
    }
    
}

　　上述代碼中，把姓名、年齡屬性和吃飯行爲都封裝到person類中的作法，叫作是封裝。

 

　　2.繼承：從已有的類中派生出新的類，新的類能吸取已有類中的屬性與方法，並能拓展新的能力。被繼承的類稱之爲「父類」或「基類」，派生出的新類稱之爲該類的子類。

　　   重寫：子類對從父類繼承而來的方法進行修改，返回值和形參都不能改變（能夠用註解@override來校驗重寫是否成功），子類重寫的方法不屬於新增的方法，重寫又叫作覆蓋。特別注意，父類的成員變量和靜態變量不會被重寫，僅僅會被隱藏，被隱藏的變量沒法被訪問。

public class Son extends Person {
    //私有屬性沒法被繼承
    private int age = 1;
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    //重寫父類方法
    @Override
    public void eat() {
        System.out.println(this.getAge() + "歲的兒子" + this.getName() + "說:爸爸,我餓。");
    }
}

public class Test {
    
    //測試方法1
    @org.junit.Test
    public void test1() throws Exception {
        Son son = new Son();
        son.eat();
    }

}

執行結果：1歲的兒子張三說:爸爸,我餓。

　　上述代碼中，父類name屬性被子類繼承，因此執行結果中，兒子也叫作張三。而eat()方法被重寫，子類對象調用的是重寫後的eat()方法。

 

　　3.重載：在一個類中存在多個方法名稱相同，但參數簽名不一樣（參數的個數或者類型不一樣）。（修飾符、返回值類型能夠相同也能夠不一樣）

public class Reload {
    
    public static void reload(){
        System.out.println("無參重載方法。");
    }
    
    public void reload(String s){
        System.out.println("string參數重載方法。");
    }
    
    public void reload(String s, int i){
        System.out.println("string,int參數重載方法。");
    }
    
    protected String reload(int i){
        System.out.println("int參數重載方法。");
        return "";
    }
}

public class Test {
    
    @org.junit.Test
    public void test2() throws Exception {
        Reload reload = new Reload();
        reload.reload();
        reload.reload("");
        reload.reload("",1);
        reload.reload(1);
    }

}

執行結果：
    無參重載方法。
    string參數重載方法。
    string,int參數重載方法。
    int參數重載方法。

 

　　4.多態：容許不一樣類的對象對同一消息作出響應。即同一操做做用於不一樣的對象，能夠有不一樣的解釋，產生不一樣的執行結果。這也意味着一個對象有着多重特徵，能夠在特定的狀況下，表現不一樣的狀態，從而對應着不一樣的屬性和方法。

　　多態的實現方式：接口實現，繼承父類進行方法重寫，同一個類中進行方法重載。

public class Person {
    private String name = "張三";
    
    private int age = 18;
    
    public Person(){
        System.out.println("父類的無參構造器：" + this.getName() + "今年" + this.getAge() +"歲。");
        this.eat();
    }
    
    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 void eat(){
        System.out.println("人要吃東西。");
    }
    
}

public class Son extends Person {
    //私有屬性沒法被繼承，由於此變量名在父類中存在，故父類中此變量將被隱藏
    private int age = 1;
    
    public static String addr = "abc";
    
    public Son(){
        //在執行子類的構造方法以前，一定先調用父類的構造器,若無顯示，則默認調用super()
        //默認：super();
        System.out.println("子類的無參構造器：" + this.getName() + "今年" + this.getAge() +"歲。");
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    //重寫父類方法
    @Override
    public void eat() {
        System.out.println(this.getAge() + "歲的兒子" + this.getName() + "說:爸爸,我餓。");
    }
}

public class Test {
    @org.junit.Test
    public void test3() throws Exception {
        Person person = new Son();
        person.eat();
        
    }
}

執行結果：

　　父類的無參構造器：張三今年0歲。
　　0歲的兒子張三說:爸爸,我餓。
　　子類的無參構造器：張三今年1歲。
　　1歲的兒子張三說:爸爸,我餓。

　　定義父類引用指向子類對象，在建立子類對象時，步驟：

1首先會隱式調用父類無參構造器，因而先打印了「父類的無參構造器：張三今年0歲」。而爲什麼是0歲而不是18歲的緣由，是子類中存在age變量與父類同名，故父類的age變量被隱藏。2而在父類構造器中調用了this.eat()，實際調用的仍是子類重寫後的方法（畢竟調用對象都是子類對象，僅僅引用類型爲父類而已），3接着super()構造器執行完成（做用是初始化父類變量和方法等），開始執行子類構造器（先初始化子類變量），4調用子類eat()方法。