創建類的物件 = 類的實體化 = 實體化類

類和物件的使用（面向物件思想落地的實作）：

1.創建類，設計類的成員 2.創建類的物件 3.通過“物件.屬性”或“物件.方法”呼叫物件的結構

如果創建了一個類的多個物件，則每個物件都獨立的擁有一套類的屬性，（非static的）

意味著，如果我們修改一個物件的屬性a，則不影響另外一個物件屬性a的值，

子類物件實體化的全程序

1.從結果上看：（繼承性）

子類繼承父類以后，就獲取了父類中宣告的屬性和方法，

創建子類的物件，在對空間中，就會加載所有父類中宣告的屬性，

2.從程序上來看：

當我們通過子類的構造器創建子類物件時，我們一定會直接或間接的呼叫其父類的構造器，進而呼叫父類的父類的構造器，直到呼叫了java.lang.Object類中空參的構造器為止，正因為加載過所有的父類的結構，所以才可以看到記憶體中有父類的結構，子類物件才可以考慮進行呼叫，

明確：雖然創建子類物件時，呼叫了父類的構造器，但是自始至終就創建過一個物件，即為new的子類物件，

匿名物件

1. 理解：我們創建的物件，沒有顯式的賦給一個變數名，即為匿名物件

class Phone{
    Phone p = new phone();//普通方式創建物件
    p.sendEmail();
    new Phone().sendEmail();//匿名物件只能直接呼叫方法
    new Phone().price = 1999;//匿名物件呼叫屬性
}

2.特征：匿名物件只能使用一次

3.匿名物件在開發中的使用

class Phone{
    public static void main(String[] args){
        PhoneMall mall = new PhoneMall();
        //匿名物件的使用
        mall.show(new Phone());
    }
}
class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
    }
}

1.封裝性

封裝性的體現：

我們將類的屬性xxx私有化(private),同時，提供公共的（public）方法來獲取（getXxx）和設定屬性

拓展：封裝性的體現：A. 如上 B.不對外暴露的私有的方法 C.單例模式.....

封裝性的體現，需要權限修飾符來配合，

1. Java規定的4中權限（從小到大排列）：private、預設、protected、public

2. 4種權限修飾符可以用來修飾類的內部結構：屬性、方法、構造器、內部類

3. 修飾類的話，只能使用：預設、public; public類可以在任意地方被訪問，

default類只可以被同一個包內部的類訪問，

2.繼承性

繼承性的格式：class A extends B{}

A:子類、派生類、subclass

B:父類、超類、基類、superclass

體現：一旦子類A繼承父類B以后，子類A中就獲取了父類B中宣告的所有的屬性和方法，

特別的，父類中宣告為private的屬性和方法，子類繼承父類以后，仍然認為獲取了父類中私有的結構，只是由于封裝性的影響，使得子類不能直接呼叫父類的結構而已，

子類繼承父類以后，還可以宣告自己特有的屬性或方法，實作功能的擴展，子類和父類的關系，不同于子集和集合的關系，

Java中關于繼承性的規定：

1.一個類可以被多個子類繼承，

2.Java中類的單繼承性，一個類只能有一個父類

3.子父類是相對的概念，

4.之類直接繼承的父類，稱為：直接父類；間接繼承的父類稱為:間接父類

5.子類繼承父類以后，就獲取了直接父類以及所有間接父類中生命的屬性和方法

----------

1.如果我們沒有顯示的宣告一個列的父類的話，則此類繼承于java.lang.Object類

2.所有的java類（除java.lang.Object類之外）都直接或間接的繼承于java.lang.Object類

3.意味著，所有的java類具有java.lang.Object類宣告的功能，

繼承性的好處：

減少了代碼的冗余，提高了代碼的復用性便于功能的擴展；為之后多型性的使用，提供了前提，

在使用子類實體時，如果我們想要使用某些父類的屬性或方法，可以借助構造器和封裝方法；如下：

public class Father{
    //父類中的私有的屬性
    private double ownMoney = 2000;//私房錢
    //父類中的受保護的屬性
    protected double money = 5000;
    //父類中的公開屬性
    public String name = "老張";
}

public class Son extends Father{
    //子類中的獨有屬性
    ...
    //使用構造器為屬性賦值
    public Son(String name,double money){
        super.name = name;
        super.money = money;
    }
    //使用封裝方法操作父類中的屬性
    public void setMoney(double money){
        super.money = money;
    }
    public double getMoney(){
    return super.money;
    }
}

public class Test{
    public static void main(String[] args){
        //在test包中的Test類中創建Son實體
        Son son = new Son("小張"，3000);//為父類繼承而來的屬性賦值
        //以下代碼編譯通過
        double money = son.getMoney();
        System.out.println(money);
        son.setMoney(money - 500);
    }
}

從以上的例子看到：測驗類對于字符類來說是一個處在不同包中的完全無關的類，在呼叫時會被權限修飾符所限制，所以這里明確一下：權限修飾符是根據類的搜在路徑 與列之間的結構關系驚醒限定的，不是說在任意一個地方使用子類實體都能呼叫出父類中的屬性和方法，

3.多型性

1.理解多型性：可以理解為一個事物的多種形態，

2.何為多型性：

物件的多型性：父類的參考指向子類的物件（或子類的物件賦給父類的參考）

3.多型的使用：虛擬方法呼叫

有了物件的多型性以后，我們在編譯期，只能呼叫父類中宣告的方法，但在運行期，我們實際執行的是子類重寫父類的方法，

總結：編譯，看左邊；運行，看右邊，

4.多型性的使用前提：A.存在子父類繼承關系 B.子類重寫父類的方法 C.父類參考指向子類物件

5.物件的多型性，只適用于方法，不適用于屬性（編譯和運行都看左邊）

5.1 若子類重寫了父類方法，就意味著子類里定義的方法徹底覆寫了父類里的同名方法，系統將不可能把父類里的方法轉移到子類中，編譯看左邊，運行看右邊，

5.2 對于實體變數則不存在這樣的現象，即使子類里定義了與父類完全相同的實體變數，這個實體變數依然不可能覆寫父類中定義的實體變數，編譯運行都看左邊，

6.多型的使用：當呼叫子父類同名同引數的方法時，實際執行的是子類重寫父類的方法----->虛擬方法呼叫

虛擬方法呼叫

正常的方法呼叫：

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虛擬方法呼叫（多型情況下）

子類中定義了與父類同名同引數的方法，在多型情況下，將此時父類的方法稱為虛擬方法，父類根據賦給它的不同子類物件，動態呼叫屬于子類的該方法，這樣的方法呼叫在編譯期是無法確定的，

Person e = new Student();
e.getInfo();//呼叫Student類的getInfo()方法

編譯時型別和運行時型別

編譯時e為Person型別，而方法的呼叫時在運行時確定的，所以呼叫的是Student類的getInfo()方法，------動態系結

public class PersonTest{
    public static void main(String[] args){
        Person p2 = new Man();
        Person p3 = new Woman();
        p2.name = "Tom";
        //不能呼叫子類所特有的方法、屬性；編譯時，p2是Person型別，
//      p2.earnMoney();//earnMoney()是子類Man()的方法
        
    }
}

有了物件的多型性以后，記憶體中實際上是加載了子類特有的屬性和方法的，但是由于變數宣告為父型別別,導致編譯時，只能呼叫父類中宣告的屬性和方法，子類特有的屬性和方法不能呼叫，

如何才能呼叫子類特有的屬性和方法？

答：向下轉型，使用強制型別轉換符，

Man m1 = (Man)p2;
m1.earnMoney();
//使用強轉時，可能出現ClassCastException的例外
Woman w1 = (Woman)p2;//p2是Man;兩者并列關系
w1.goShopping();

解決這個問題的辦法是先使用關鍵字（instanceof）判斷一下！！！！！ （會在下一篇博客關鍵字中介紹）

4.抽象性

背景：有兩個在邏輯上看似相關的類，我們想要把他們聯系起來，因為這樣做可以提高效率，例如：矩形、圓形，都可以具有周長和面積兩個方法，但是計算的方式完全不同，矩形和圓形之間肯定不能構成子父類的關系，那么只能是同時去繼承一個父類，這時，就引出了抽象的概念，

1.抽象類的特點：

抽象類的本質依然是一個類，所以具備著一個普通類的所有功能，包括構造方法等的定義，總結一下，抽象類具有以下的幾個特點：A. 抽象類由abstract修飾 B. 抽象類中允許出現抽象方法 C.抽象了不能通過構造器直接實體化 D.可以在抽象類中定義普通方法供子類繼承，

public abstract class Figure{
    //定義計算周長的抽象方法：getC()
    //抽象方法，不能有方法主體
    public abstract double getC();
}

2.天生的父類：抽象類

2.1 抽象類不能直接實體化（編譯無法通過），是天生的父類

2.2 如果一個類繼承了抽象類，那么必須重寫父類中的抽象方法

2.3 如果抽象類中定義了構造方法，可以被子類呼叫或在實體化子類物件時執行

2.4 如果抽象類的子類依然是抽象類（需要用abstract宣告），可以不重寫抽象方法，將重寫操作留給下一級子類

2.5 抽象類不能使用final關鍵字修飾，因為final 修飾的類是無法被繼承

3.抽象方法

3.1 抽象類中的抽象方法只是宣告，不包含方法體

3.2 抽象方法不能用private修飾，因為抽象方法必須被子類實作（重寫），而private 權限對于子類來說是不能訪問的

3.3 一個類繼承了一個抽象類，那么它必須全部重寫抽象類中的抽象方法，當然也可以不全部重寫，如果不重寫全部抽 象方法則這個子類也必須是抽象類

3.4 構造方法，類方法（static修飾的方法）不能宣告為抽象方法