面向?qū)ο螅ㄈ筇匦灾欢鄳B(tài)）
	3.多態(tài)（要點，難點）

一種事物的多種形態(tài)，就稱為多態(tài)；
編譯時跟運行時類型不一致就產(chǎn)生了多態(tài)
父類類型的變量，存放子類類型的對象，可能存放子類類型的對象有多種可能
多態(tài)存在的前提：必須有繼承關(guān)系
多態(tài)方法調(diào)用編譯運行過程：
a)編譯時，看的是父類類型，會在父類類型中找對應的方法
如果沒有找到，會繼續(xù)向上找[編譯時父類類型]
i.找到：編譯通過
ii.找不到：編譯報錯
iii.注意：是不會向下找的[aml編譯時子類類型]
2)運行時 :
a)先到運行時子類類型中找覆寫的方法,如果子類有自己的特性方法，就直接用子類的，找不到或者沒有的話就會去調(diào)用父類的。
2.有沒有可能編譯通過了,而運行找不到方法… 不可能!
編譯時與運行時的幾種情況分析：
父類中有一個方法,子類覆寫了
那么會先運行子類的
2.父類中有一個方法,子類沒有
那么會運行父類的
3.父類中沒有,子類有一個方法
那么直接報錯
4.父類子類都沒有
那么就會默認的引用Object里邊的方法
5.靜態(tài)方法
6.字段沒有覆寫一說
靜態(tài)方法也不是能被覆寫的，和繼承的，靜態(tài)方法是單獨存在的，全局共享的。
class Dog{//父類類型Dog
void eat(){
System.out.println(“吃食物”);
}
}
class DDog extends Dog{//子類類型DDog
void eat(){
System.out.println(“哈根達斯”);
}
}
class XDog extends Dog{//子類類型XDog
void eat(){
System.out.println(“吃牛排喝紅酒”);
}
}
class Person{//人類：定義喂狗方法
void feedDog(Dog dog){
dog.eat();
}
}
//------------------------------測試類-----------------------------------
class Test {
public static void main(String[] args) {
Dog ddog = new DDog();
XDog xdog = new XDog();

	Person pson = new Person();
	pson.feedDog(ddog);
	pson.feedDog(xdog);
}

}
這兒及體現(xiàn)了多態(tài)的好處，直接不用在去定義更多的喂狗的方法了
多態(tài)體現(xiàn)的幾種情況：
1.如上代碼多態(tài)的體現(xiàn)的本質(zhì)：都是父類類型的變量存放子類類型的對象
2.Dog dog = new XDog();//核心本質(zhì)
大的數(shù)據(jù)類型兼容小的數(shù)據(jù)類型；
方法參數(shù)傳遞：方法形參父類類型，允許傳子類類型對象
5.多態(tài)的好處：屏蔽了不同子類之間實現(xiàn)的差異
a)此處體現(xiàn)java語言設(shè)計是想，希望將現(xiàn)實生活中的對象與對象之間的關(guān)系在計算機系統(tǒng)得以體現(xiàn)
4.引用類型轉(zhuǎn)換：
class Cat{
void eat(){}
}
class TomCat extends Cat{
void say(){}
}
class CoffeeCat extends Cat{
void drink(){}
}
//測試類
class Test {
public static void main(String[] args) {
Cat cat = new Tomcat();
CoffeeCat cc = (CoffeeCat)cat;
cc.drink();
}
}
基本語法：
1.明確：數(shù)據(jù)類型轉(zhuǎn)換存在兩種，情況，大轉(zhuǎn)?。盒∞D(zhuǎn)大
1)子類類型轉(zhuǎn)父類類型：小轉(zhuǎn)大
Cat cat = new TomCat();
double d = 1;
2)父類類型轉(zhuǎn)子類類型：大轉(zhuǎn)小
TomCat tc =(TomCat)cat;
2.在引用數(shù)據(jù)類型中：父類是較大的數(shù)據(jù)類型，子類是較小的數(shù)據(jù)類型
a)cat可能是傳來的參數(shù)：在使用的時候不知道存放的是Tomcat,誤以為存的是CoffeeCat類型
b)紅色代碼使用多態(tài)：綠色代碼引用類型數(shù)據(jù)轉(zhuǎn)換：cc.drink();
c)編譯只看類型不看值，如上代碼編譯都不會有問題！
d)但是：運行時反應的是真實類型，綠色代碼等于要將TomCat 變成 CoffeCat 顯然不行！
2.因此引用數(shù)據(jù)類型轉(zhuǎn)換，最好在轉(zhuǎn)換之前先判斷類型在轉(zhuǎn)換
3.判斷類型的方式
a)獲得運行時類型 Object 中g(shù)etClass();方法
b)類型判斷運算符 instanceof
b)類型判斷運算符 instanceof
Systme.out.println(cat instanceof Cat);//true
Systme.out.println(cat instanceof TomCat);//true
Systme.out.println(cat instanceof Object);//true
Systme.out.println(cat instanceof CoffeeCat);//false
System.out.println(tom instanceof CoffeeCat);////編譯報錯，不存在繼承關(guān)系,不兼容,完全相關(guān)類型：編譯器只看類型不看值
Systme.out.println(cat instanceof String);//編譯報錯，不存在繼承關(guān)系,不兼容,完全相關(guān)類型：編譯器只看類型不看值
引用數(shù)據(jù)類型轉(zhuǎn)換小結(jié)：
1.為什么需要引用數(shù)據(jù)類型轉(zhuǎn)
(1)明知道多態(tài)父類類型裝的是子類對象,但是子類特性,父類對象訪問,編譯報錯,需要轉(zhuǎn)換成真實類型
2.數(shù)據(jù)類型轉(zhuǎn)換的兩種情況：
小轉(zhuǎn)大 自動轉(zhuǎn)換
大轉(zhuǎn)小 強制轉(zhuǎn)換
(3)父類大子類小 : 父類類型兼容子類類型
3.數(shù)據(jù)類型轉(zhuǎn)換的注意事項
(1)在轉(zhuǎn)換之前要進行類型判斷
(2)兩種判斷方式
4.instanceof運算符的運用
(1)只看類型不看值,不存在繼承關(guān)系的,編譯不通過
5.final
代表最終的，不可變得
final是什么：
final : Java中的一個關(guān)鍵字,修飾符：表示的意思：最終的,不可變的，不可拓展的
final可以修飾的東西：
1.外部類：可以
2.普通方法：可以
3.成員字段：可以
4.局部變量：可以
5.內(nèi)部類：可以 [ 暫時不學 ]
6.構(gòu)造方法：不可以
1.final修飾類：最終類，不可拓展的類，太監(jiān)類 ：
final修飾普通方法：最終的方法，不可拓展的方法：
1.final修飾變量：表示最終的變量 : 2.final 修飾變量一般使用 public static final double PI = 3.14159265; 構(gòu)成類中的全局常量僅供使用

2.目前不能被覆寫的方法 有哪些？
1)使用final修飾的方法
2)使用static修飾的方法
3)使用private修飾的方法
1 什么是單例模式
就是一種設(shè)計模式[為了解決某類問題，而提出的比較好的解決方案]
2.單利模式概念：需要設(shè)計一個類，達到的效果： 此類在整個應用中只存在一個對象
3)單利模式好處：節(jié)省了系統(tǒng)資源,節(jié)省了內(nèi)存空間
單利模式對象怎么用 : 如果系統(tǒng)很多位置都會用到該對象,通過該對象的引用地址對其引用
a.設(shè)計一個類 class A{}
b.對象怎么來的？new A(); new A(); new A(); … 調(diào)用一次構(gòu)造方法就得到一個對象
c.把構(gòu)造方法私有化，本類的外部就不能夠隨意的訪問創(chuàng)建對象了
d.思考 : 一個類的所有構(gòu)造方法都被私有化，就不能夠創(chuàng)建對象了，說法正確嗎？不正確
a)外部不能創(chuàng)建,自己內(nèi)部可以創(chuàng)建
e.可以在A類內(nèi)部創(chuàng)建好一個，并保存起來，別人需要對象給它一個地址
餓漢模式：
1)構(gòu)造方法私有化
2)在類的內(nèi)部創(chuàng)建一個對象
3)使用一個字段保存起來
4)提供一個方法允許外部使用該方法訪問該字段
5)提供的方法必須靜態(tài)修飾，因為外部不能創(chuàng)建對象
6)外部通過方法訪問instance 字段，方法靜態(tài)修飾，所以字段必須靜態(tài)修飾
7)字段不私有化，別人可以通過類名.instance修改子字段值，所以必須私有化
class A{
private A(){}
private A instance = new A();
public A getInstance(){
return instance;
}
}
單例模式的類也是一個普通的類，其中也可以有其他的字段 方法等
instance 對象是A類被加載[把類放到JVM的過程中]的時候創(chuàng)建的
懶漢模式;
1)明確：應用程序在第一次調(diào)用方法獲取單利模式對象的時候創(chuàng)建對象
2)構(gòu)造方法私有化
3)設(shè)置一個A類類型的字段私有化不初始化值
4)提供一個方法允許外部使用該方法訪問該字段
5)外部不能創(chuàng)建對象，所以方法必須static修飾
6)什么時候是第一次【instance == null】
7)當?shù)谝徽{(diào)用的時候判斷
a.如果instance == null ：初始化instance
b.如果instance != null : 直接返回instance
class A{
private A(){}
private static A instance;
public static A getInstance(){
if(instance == null){
instance = new A();
}
return instance;
}
}
懶漢模式和懶漢模式存在線程安全的問題；