封裝，繼承，多態的一個基本概述

封裝，繼承，多態

封裝，繼承，多態是java面向對象的三大特徵。

1.封裝性

    封裝就是儘可能把對象內部的東西隱藏起來，只通過一些接口或是方法和外部進行
    交互。封裝的原則就是外部對象不能隨意訪問和操作內部的屬性，以免造成內部屬性破壞。我們通過對外部提供可以訪問的函數，間接的訪問屬性。

//通過一段小代碼來演示封裝的特性
Class demo01
{
    Public static void main(String[] args);
    {
    //通過建立Person對象，調用共有方法訪問了Person內的私有屬性
    System out println(“New Person().getName();”);
    }
} 
class Person
{
    private String name=”xiaoming”;//把姓名封裝起來
    private int age =10;//把年齡封裝起來
    //提供方法給外部訪問姓名
public String getName()
    {
        return name;
    }
//提供方法給外部訪問年齡
    public int getAge()
    {
        return age;
    }
}

關於封裝，其實並不是一定要加上private修飾符修飾纔算是封裝，封裝都是相對的，
對於protected來說，不同的包中只要不是不是它的子類就不可以訪問；private則是隻能同類中訪問，它的封裝性最強。

2.繼承

1：提高了代碼的複用性。
2：讓類與類之間產生了關係，提供了另一個特徵多態的前提。

父類的由來：其實是由多個類不斷向上抽取共性內容而來的。
java中對於繼承，java只支持單繼承。java雖然不直接支持多繼承，但是保留了這種多繼承機制，進行改良。

單繼承概述：
因爲當一個類同時繼承兩個父類時，兩個父類中有相同的功能，那麼子類對象調用該功能時，運行哪一個呢？因爲父類中的方法中存在方法體。
但是java支持多重繼承。A繼承B B繼承C C繼承D。
多重繼承的出現，就有了繼承體系。體系中的頂層父類是通過不斷向上抽取而來的。它裏面定義的該體系最基本最共性內容的功能。
所以，一個體系要想被使用，直接查閱該系統中的父類的功能即可知道該體系的基本用法。那麼想要使用一個體系時，需要建立對象。建議建立最子類對象，因爲最子類不僅可以使用父類中的功能。還可以使用子類特有的一些功能。

簡單說：對於一個繼承體系的使用，查閱頂層父類中的內容，創建最底層子類的對象。

子父類出現後，類中的成員都有了哪些特點：
1：成員變量。
當子父類中出現一樣的屬性時，子類類型的對象，調用該屬性，值是子類的屬性值。
如果想要調用父類中的屬性值，需要使用一個關鍵字：super
This：代表是本類類型的對象引用。
Super：代表是子類所屬的父類中的內存空間引用。
注意：子父類中通常是不會出現同名成員變量的，因爲父類中只要定義了，子類就不用在定義了，直接繼承過來用就可以了。
2：成員函數。
當子父類中出現了一模一樣的方法時，建立子類對象會運行子類中的方法。好像父類中的方法被覆蓋掉一樣。所以這種情況，是函數的另一個特性：覆蓋(複寫，重寫)
什麼時候使用覆蓋呢？當一個類的功能內容需要修改時，可以通過覆蓋來實現。
3：構造函數。
發現子類構造函數運行時，先運行了父類的構造函數。爲什麼呢?
原因：子類的所有構造函數中的第一行，其實都有一條隱身的語句super();
super(): 表示父類的構造函數，並會調用於參數相對應的父類中的構造函數。而super():是在調用父類中空參數的構造函數。
爲什麼子類對象初始化時，都需要調用父類中的函數？(爲什麼要在子類構造函數的第一行加入這個super()?)
因爲子類繼承父類，會繼承到父類中的數據，所以必須要看父類是如何對自己的數據進行初始化的。所以子類在進行對象初始化時，先調用父類的構造函數，這就是子類的實例化過程。

注意：子類中所有的構造函數都會默認訪問父類中的空參數的構造函數，因爲每一個子類構造內第一行都有默認的語句super();
如果父類中沒有空參數的構造函數，那麼子類的構造函數內，必須通過super語句指定要訪問的父類中的構造函數。
如果子類構造函數中用this來指定調用子類自己的構造函數，那麼被調用的構造函數也一樣會訪問父類中的構造函數。

特別注意：super()和this()是否可以同時出現的構造函數中。
兩個語句只能有一個定義在第一行，所以只能出現其中一個。

super()或者this():爲什麼一定要定義在第一行？
因爲super()或者this()都是調用構造函數，構造函數用於初始化，所以初始化的動作要先完成。

繼承的細節：
什麼時候使用繼承呢？
當類與類之間存在着所屬關係時，才具備了繼承的前提。a是b中的一種。a繼承b。狼是犬科中的一種。
英文書中，所屬關係：” is a ”
注意：不要僅僅爲了獲取其他類中的已有成員進行繼承。

所以判斷所屬關係，可以簡單看，如果繼承後，被繼承的類中的功能，都可以被該子類所具備，那麼繼承成立。如果不是，不可以繼承。

細節二：
在方法覆蓋時，注意兩點：
1：子類覆蓋父類時，必須要保證，子類方法的權限必須大於等於父類方法權限可以實現繼承。否則，編譯失敗。
2：覆蓋時，要麼都靜態，要麼都不靜態。 (靜態只能覆蓋靜態，或者被靜態覆蓋)

繼承的一個弊端：打破了封裝性。對於一些類，或者類中功能，是需要被繼承，或者複寫的。
這時如何解決問題呢？介紹一個關鍵字，final:最終

//通過一段來說一下繼承的一些基本特點
class demo02 
{
    public static void main(String[] args) 
    {
        students stu = new students(“xiaoming”,20);//創建了一個學生對象
        stu.getName();//子類調用了父類中的方法
    }
}
//父類
class Person
{
    private String name;
    private int age;
    //構造方法
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
//學生類就繼承了Person類
class students extends Person
{
    students(String name,int age)
    {
        super(name,age);//用了父類中的構造方法
    }
}

繼承有很多好處，可以提高代碼的複用性，可以讓類和類之間產生關係，擁有多態的特性。

3.多態

對象的多態性是指在父類中定義的屬性或方法被子類繼承之後，可以具有不同的數據類型或表現出不同的行爲。這使得同一個屬性或方法在父類及其各個子類中具有不同的語義。多態的具體體現就是，父類方法創建子類對象。
函數本身就具備多態性，某一種事物有不同的具體的體現。

多態的好處：提高了程序的擴展性。
多態的弊端：當父類引用指向子類對象時，雖然提高了擴展性，但是隻能訪問父類中具備的方法，不可以訪問子類中特有的方法。(前期不能使用後期產生的功能，即訪問的侷限性)
多態的前提：
1：必須要有關係，比如繼承、或者實現。
2：通常會有覆蓋操作。

多態的出現思想上也做着變化：以前是創建對象並指揮對象做事情。有了多態以後，我們可以找到對象的共性類型，直接操作共性類型做事情即可，這樣可以指揮一批對象做事情，即通過操作父類或接口實現。

多態在子父類中的成員上的體現的特點：
1，成員變量：在多態中，子父類成員變量同名。
在編譯時期：參考的是引用型變量所屬的類中是否有調用的成員。（編譯時不產生對象，只檢查語法錯誤）
運行時期：也是參考引用型變量所屬的類中是否有調用的成員。
簡單一句話：無論編譯和運行，成員變量參考的都是引用變量所屬的類中的成員變量。

2，成員函數。
編譯時期：參考引用型變量所屬的類中是否有調用的方法。
運行事情：參考的是對象所屬的類中是否有調用的方法。
爲什麼是這樣的呢？因爲在子父類中，對於一模一樣的成員函數，有一個特性：覆蓋。
簡單一句：成員函數，編譯看引用型變量所屬的類，運行看對象所屬的類。
更簡單：成員函數 — 編譯看 = 左邊，運行看 = 右邊。

3，靜態函數。
編譯時期：參考的是引用型變量所屬的類中是否有調用的成員。
運行時期：也是參考引用型變量所屬的類中是否有調用的成員。
爲什麼是這樣的呢？因爲靜態方法，其實不所屬於對象，而是所屬於該方法所在的類。
調用靜態的方法引用是哪個類的引用調用的就是哪個類中的靜態方法。
簡單說：靜態函數 — 編譯運行都看 = 左邊。

//具體看下面這段代碼
class demo03 
{
    public static void main(String[] args) 
    {
        Person stu = new students(“xiaoming”,20);//父類方法創建了一個學生對象
        Person wor =new Worker(“daming”,30);//父類方法創建了一個工人對象
        stu.show();//調用了一個共同擁有的show方法
        wor.show();
    }
}
//父類
class Person
{
    private String name;
    private int age;
    //父類構造函數
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    //父類show方法
    public void show()
    {
        System.out.println(”I am Person”);
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
//繼承了Person類
class students extends Person
{
    //構造方法
    students(String name,int age)
    {
        super(name,age);
    }
//子類中的show方法
public void show()
    {
        System.out.println(”I am students”);
    }

}
//繼承了Person類
class worker extends Person
{
    //構造方法
    worker(String name,int age)
    {
        super(name,age);
    }
    //子類中的show方法
    public void show()
    {
        System.out.println(”I am Worker”);
    }
}

***用多態時需要注意的一些問題：

父類方法創建子類對象，調用成員函數是參考父類的初始值；調用靜態方法時也要參考父類方法。
所有的類都繼承了Object類，所以所有的類都和它有多態。***