java多態的理解

1. 談談你對java中的多態的理解.(為什麼要使用多態，有什麼好處，一般用在什麼場合)

面向對象編程有三大特性：封裝、繼承、多態。

封裝隱藏了類的內部實現機制，可以在不影響使用的情況下改變類的內部結構，同時也保護了數據。對外界而已它的內部細節是隱藏的，暴露給外界的只是它的訪問方法。

繼承是為了重用父類代碼。兩個類若存在IS-A的關系就可以使用繼承。，同時繼承也為實現多態做了鋪墊。

那麼什麼是多態呢？多態的實現機制又是什麼？請看我一一為你揭開：

所謂多態

就是指程序中定義的引用變數所指向的具體類型和通過該引用變數發出的方法調用在編程時並不確定，而是在程序運行期間才確定，即一個引用變數倒底會指向哪個類的實例對象，該引用變數發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變數綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。

比如你是一個酒神，對酒情有獨鍾。某日回家發現桌上有幾個杯子裡面都裝了白酒，從外面看我們是不可能知道這是些什麼酒，只有喝了之後才能夠猜出來是何種酒。你一喝，這是劍南春、再喝這是五糧液、再喝這是酒鬼酒….在這里我們可以描述成如下：

酒 a = 劍南春

酒 b = 五糧液

酒 c = 酒鬼酒

…

這里所表現的的就是多態。劍南春、五糧液、酒鬼酒都是酒的子類，我們只是通過酒這一個父類就能夠引用不同的子類，這就是多態——我們只有在運行的時候才會知道引用變數所指向的具體實例對象。

誠然，要理解多態我們就必須要明白什麼是「向上轉型」。在繼承中我們簡單介紹了向上轉型，這里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父類，劍南春（JNC）、五糧液（WLY）、酒鬼酒（JGJ）是子類。我們定義如下代碼：

JNC a = new JNC();

對於這個代碼我們非常容易理解無非就是實例化了一個劍南春的對象嘛！但是這樣呢？

Wine a = new JNC();

在這里我們這樣理解，這里定義了一個Wine 類型的a，它指向JNC對象實例。由於JNC是繼承與Wine，所以JNC可以自動向上轉型為Wine，所以a是可以指向JNC實例對象的。這樣做存在一個非常大的好處，在繼承中我們知道子類是父類的擴展，它可以提供比父類更加強大的功能，如果我們定義了一個指向子類的父類引用類型，那麼它除了能夠引用父類的共性外，還可以使用子類強大的功能。

但是向上轉型存在一些缺憾，那就是它必定會導致一些方法和屬性的丟失，而導致我們不能夠獲取它們。所以父類類型的引用可以調用父類中定義的所有屬性和方法，對於只存在與子類中的方法和屬性它就望塵莫及了。

publicclassWine{
publicvoidfun1(){
System.out.println("Wine的Fun.....");
fun2();
}

publicvoidfun2(){
System.out.println("Wine的Fun2...");
}
}

publicclassJNCextendsWine{
/**
*@desc子類重載父類方法
*父類中不存在該方法，向上轉型後，父類是不能引用該方法的
*@parama
*@returnvoid
*/
publicvoidfun1(Stringa){
System.out.println("JNC的Fun1...");
fun2();
}

/**
*子類重寫父類方法
*指向子類的父類引用調用fun2時，必定是調用該方法
*/
publicvoidfun2(){
System.out.println("JNC的Fun2...");
}
}

publicclassTest{
publicstaticvoidmain(String[]args){
Winea=newJNC();
a.fun1();
}
}

-------------------------------------------------

Output:

Wine的Fun.....

JNC的Fun2...

從程序的運行結果中我們發現，a.fun1()首先是運行父類Wine中的fun1().然後再運行子類JNC中的fun2()。

分析：在這個程序中子類JNC重載了父類Wine的方法fun1()，重寫fun2()，而且重載後的fun1(String a)與 fun1()不是同一個方法，由於父類中沒有該方法，向上轉型後會丟失該方法，所以執行JNC的Wine類型引用是不能引用fun1(String a)方法。而子類JNC重寫了fun2() ，那麼指向JNC的Wine引用會調用JNC中fun2()方法。

所以對於多態我們可以總結如下：

指向子類的父類引用由於向上轉型了，它只能訪問父類中擁有的方法和屬性，而對於子類中存在而父類中不存在的方法，該引用是不能使用的，盡管是重載該方法。若子類重寫了父類中的某些方法，在調用該些方法的時候，必定是使用子類中定義的這些方法（動態連接、動態調用）。

對於面向對象而已，多態分為編譯時多態和運行時多態。其中編輯時多態是靜態的，主要是指方法的重載，它是根據參數列表的不同來區分不同的函數，通過編輯之後會變成兩個不同的函數，在運行時談不上多態。而運行時多態是動態的，它是通過動態綁定來實現的，也就是我們所說的多態性。

多態的實現

2.1實現條件

在剛剛開始就提到了繼承在為多態的實現做了准備。子類Child繼承父類Father，我們可以編寫一個指向子類的父類類型引用，該引用既可以處理父類Father對象，也可以處理子類Child對象，當相同的消息發送給子類或者父類對象時，該對象就會根據自己所屬的引用而執行不同的行為，這就是多態。即多態性就是相同的消息使得不同的類做出不同的響應。

Java實現多態有三個必要條件：繼承、重寫、向上轉型。

繼承：在多態中必須存在有繼承關系的子類和父類。

重寫：子類對父類中某些方法進行重新定義，在調用這些方法時就會調用子類的方法。

向上轉型：在多態中需要將子類的引用賦給父類對象，只有這樣該引用才能夠具備技能調用父類的方法和子類的方法。

只有滿足了上述三個條件，我們才能夠在同一個繼承結構中使用統一的邏輯實現代碼處理不同的對象，從而達到執行不同的行為。

對於Java而言，它多態的實現機制遵循一個原則：當超類對象引用變數引用子類對象時，被引用對象的類型而不是引用變數的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。

2.2實現形式

在Java中有兩種形式可以實現多態。繼承和介面。

2.2.1、基於繼承實現的多態

基於繼承的實現機制主要表現在父類和繼承該父類的一個或多個子類對某些方法的重寫，多個子類對同一方法的重寫可以表現出不同的行為。

publicclassWine{
privateStringname;

publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

publicWine(){
}

publicStringdrink(){
return"喝的是"+getName();
}

/**
*重寫toString()
*/
publicStringtoString(){
returnnull;
}
}

publicclassJNCextendsWine{
publicJNC(){
setName("JNC");
}

/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}

/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}

publicclassJGJextendsWine{
publicJGJ(){
setName("JGJ");
}

/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}

/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}

publicclassTest{
publicstaticvoidmain(String[]args){
//定義父類數組
Wine[]wines=newWine[2];
//定義兩個子類
JNCjnc=newJNC();
JGJjgj=newJGJ();

//父類引用子類對象
wines[0]=jnc;
wines[1]=jgj;

for(inti=0;i<2;i++){
System.out.println(wines[i].toString()+"--"+wines[i].drink());
}
System.out.println("-------------------------------");

}
}

OUTPUT:

Wine:JNC--喝的是JNC

Wine:JGJ--喝的是JGJ

在上面的代碼中JNC、JGJ繼承Wine，並且重寫了drink()、toString()方法，程序運行結果是調用子類中方法，輸出JNC、JGJ的名稱，這就是多態的表現。不同的對象可以執行相同的行為，但是他們都需要通過自己的實現方式來執行，這就要得益於向上轉型了。

我們都知道所有的類都繼承自超類Object，toString()方法也是Object中方法，當我們這樣寫時：

Objecto=newJGJ();

System.out.println(o.toString());

輸出的結果是Wine : JGJ。

Object、Wine、JGJ三者繼承鏈關系是：JGJ—>Wine—>Object。所以我們可以這樣說：當子類重寫父類的方法被調用時，只有對象繼承鏈中的最末端的方法才會被調用。但是注意如果這樣寫：

Objecto=newWine();

System.out.println(o.toString());

輸出的結果應該是Null，因為JGJ並不存在於該對象繼承鏈中。

所以基於繼承實現的多態可以總結如下：對於引用子類的父類類型，在處理該引用時，它適用於繼承該父類的所有子類，子類對象的不同，對方法的實現也就不同，執行相同動作產生的行為也就不同。

如果父類是抽象類，那麼子類必須要實現父類中所有的抽象方法，這樣該父類所有的子類一定存在統一的對外介面，但其內部的具體實現可以各異。這樣我們就可以使用頂層類提供的統一介面來處理該層次的方法。

2.2.2、基於介面實現的多態

繼承是通過重寫父類的同一方法的幾個不同子類來體現的，那麼就可就是通過實現介面並覆蓋介面中同一方法的幾不同的類體現的。

在介面的多態中，指向介面的引用必須是指定這實現了該介面的一個類的實常式序，在運行時，根據對象引用的實際類型來執行對應的方法。

繼承都是單繼承，只能為一組相關的類提供一致的服務介面。但是介面可以是多繼承多實現，它能夠利用一組相關或者不相關的介面進行組合與擴充，能夠對外提供一致的服務介面。所以它相對於繼承來說有更好的靈活性。

2. 如何理解java繼承與多態

繼承：子類繼承父類的特徵和行為，使得子類具有父類的各種屬性和方法。或子類從父類繼承方法，使得子類具有父類相同的行為。
多態：多態的特徵是表現出多種形態，具有多種實現方式。或者多態是具有表現多種形態的能力的特徵。或者同一個實現介面，使用不同的實例而執行不同的操作。實現多態有兩種方式：重寫和重載

3. java問答題什麼是多態性

多態性

多態性的概念

多態性是指用一個名字定義不同的函數，這函數執行不同但又類似的操作，從而實現「一個介面，多種方法」。

多態性的實現與靜態聯編、動態聯編有關。靜態聯編支持的多態性稱為編譯時的多態性，也稱靜態多態性，它是通過函數重載和運算符重載實現的。動態聯編支持的多態性稱為運行時的多態性，也稱動態多態性，它是通過繼承和虛函數實現的。

4. java中多態具體是什麼

首先表明觀點，重載不是java多態的一種體現。

java的多態是指在程序運行過程中由虛擬機確定到底該使用哪種形態完成指定行為的一個過程。如下:

Parent p = new Son();

p.speak();

如果在Son中對父類speak()方法進行了重寫，那麼當你代碼寫到這里時，編譯器是不知道要執行Parent中的speak()還是Son中的speak()方法的，編譯器只知道這樣寫不會發生語法錯誤；只有在運行過程中才會根據實際在內存中(堆)創建的對象去執行相應的方法

如果重載是多態，那我問你，當你在代碼中寫上某個重載的方法後，此時編譯器不是已經確定了到底是哪個方法在完成你的功能嗎？這僅僅是編譯期，程序還沒有運行呢。

我還看到一些關於多態的其他說法，比如:編譯時多態，運行時多態。而這種觀點普遍認為重載就是多態體現的一種，因為重載算是編譯時多態，而運行時多態中就是我上面寫的那個例子。

借用一句《Java編程思想》作者Bruce Eckel的話:"不要犯傻，如果它不是晚綁定，它就不是多態"。這里的晚綁定就是指動態綁定，早綁定就是指靜態綁定，也就是所謂的重載。

具體如何理解，網上關於這方面的討論一大堆，各位自行參考。

5. JAVA的多態有什麼特點什麼地方適合使用多態

多態性是指允許不同子類型的對象對同一消息作出不同的響應。簡單的說就是用同樣的對象引用調用同樣的方法但是做了不同的事情。多態性分為編譯時的多態性和運行時的多態性。
如果將對象的方法視為對象向外界提供的服務，那麼運行時的多態性可以解釋為：當A系統訪問B系統提供的服務時，B系統有多種提供服務的方式，但一切對A系統來說都是透明的（就像電動剃須刀是A系統，它的供電系統是B系統，B系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統只會通過B類對象調用供電的方法，但並不知道供電系統的底層實現是什麼，究竟通過何種方式獲得了動力）。
方法重載（overload）實現的是編譯時的多態性（也稱為前綁定），而方法重寫（override）實現的是運行時的多態性（也稱為後綁定）。

6. JAVA中的多態怎麼感覺這么難理解，看了好久了，還是沒辦法理解過來

多態又叫動態綁定是指「在運行期間」（而非編譯期間）來判斷所引用的對象的實際類型，根據其實際類型調用其相應的方法。就是new出來什麼對象就調用那個對象的方法
--------
多態的三個條件：1.要有繼承。2.要有重寫。3.父類引用指向子類對象
三個條件缺一不可, 只針對與方法，對成員變數無效的
-------
例子：
class Animals {
jiaosheng() {
System.out.print("動物叫聲");
}
}
class Cat extends Animals {
jiaosheng() {
System.out.print(" 貓叫聲");
}
}
public class Text { //定義一個測試類
public void f(Animals aa) {
aa.jiaosheng();
}
public static void main(String args[]) {
Animals c = new Cat();//父類引用指向子類對象
Animals a = new Animals()//實例化一個父類對象
Cat cc = new Cat();//實例化一個子類對象
c.jiaosheng();
a.jiaosheng();
cc.jiaosheng();
Text t = new Text();//實例化一個測試類
t.f(cc);
}
}
答案：貓叫聲 動物叫聲 貓叫聲 貓叫聲
希望能夠幫助到你，望採納！

7. java的多態怎麼理解啊，多態有什麼用途。

多態你可以從字面上去理解，一個類表現出多種形態。它是一種編碼的技巧而不是寫代碼的格式或者方式。 要想理解多態你需要從需求入手。偽代碼例子：void method（Father instance）: instance.callmethod();現在有兩個子類 girl 和 boy . 如果我傳入給method的對象是girl，那麼instance.callmethod()是否就等同於girl.callmethod(),如果傳入的是boy，就等同於boy.callmethod().但是對於程序而言，表達式一直都是 void method（Father instance）: instance.callmethod();沒有改變過只不過通過傳入不同的子類對象使這樣一個表達式表現出了多種「類的形態」。這樣的現象就叫做多態。 多態在軟體結構設計上是非常重要的一個抽象意識1：多態用於解決if,else 現代的編程技巧要求對於某一個函數專注於解決一類型的事情。這就要求一個函數中要盡量的避免出現>1個if，那麼如果程序出現了分支而又要避免使用if應該怎麼辦呢。那就是多態最經常出現的場景。看下面的一個2：多態用於隱藏函數的具體內容在面向對象高度結構化的開發中，軟體根據功能的不同需要分為各種模塊分別交給不同的人開發。那麼如果同一個介面描述一類情況顯然是非常高明的。最明顯的例子就是大家最常用的System,out.println(Object).初學者可能每天都在使用這樣一個多態，但是卻不知道這個是多態。System,out.println();無論你輸入的是一個string,object,int,array,float都可以正常輸出內容。為什麼，因為所有的你string,Intege,array,Float都是Object的子類，根據填入參數的類型，System,out,println()就表現出了各種輸出功能的形態。 說了這么多希望你能夠理解。 多態可以通過介面和繼承來實現。 一個介面可以對應多個實現 （1vN : 多態的數學描述，1個形態代表多個形態）繼承：一個父類可以有多個子類 （1vN : 多態的數學描述，1個形態代表多個形態）

8. java中多態是什麼意思

多態（Polymorphism）按字面的意思就是「多種狀態」。在面向對象語言中，介面的多種不同的實現方式即為多態。引用Charlie Calverts對多態的描述——多態性是允許你將父對象設置成為一個或更多的他的子對象相等的技術，賦值之後，

父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作（摘自「Delphi4編程技術內幕」）。簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。多態性在Object Pascal和C++中都是通過虛函數實現的。

多態指同一個實體同時具有多種形式。它是面向對象程序設計（OOP）的一個重要特徵。如果一個語言只支持類而不支持多態，只能說明它是基於對象的，而不是面向對象的。C++中的多態性具體體現在運行和編譯兩個方面。

運行時多態是動態多態，其具體引用的對象在運行時才能確定。編譯時多態是靜態多態，在編譯時就可以確定對象使用的形式。

多態：同一操作作用於不同的對象，可以有不同的解釋，產生不同的執行結果。在運行時，可以通過指向基類的指針，來調用實現派生類中的方法。

C++中，實現多態有以下方法：虛函數，抽象類，覆蓋，模板（重載和多態無關）。

OC中的多態：不同對象對同一消息的不同響應.子類可以重寫父類的方法

多態就是允許方法重名 參數或返回值可以是父類型傳入或返回。

(8)java多態的理解擴展閱讀：

把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，寫出通用的代碼，做出通用的編程，以適應需求的不斷變化。

賦值之後，父類型的引用就可以根據當前賦值給它的子對象的特性以不同的方式運作。也就是說，父親的行為像兒子，而不是兒子的行為像父親。

比如從某個基類派生出多個子類，其基類有一個虛方法Tdoit，然後其子類也有這個方法，但行為不同，然後這些子類對象中的任何一個可以賦給其基類對象的引用，或者說將子對象地址賦給基類指針，這樣其基類的對象就可以執行不同的操作了。

實際上你是在通過其基類的引用來訪問其子類對象的，你要做的就是一個賦值操作。

使用繼承性的結果就是當創建了一個類的家族，在認識這個類的家族時，就是把子類的對象當作基類的對象，這種認識又叫作upcasting（向上轉型）。這樣認識的重要性在於：我們可以只針對基類寫出一段程序，但它可以適應於這個類的家族，

因為編譯器會自動找出合適的對象來執行操作。這種現象又稱為多態性。而實現多態性的手段又叫稱動態綁定(dynamic binding)。

9. 什麼是多態java中如何實現多態

多態,就是重載和重寫.重載發生在一個類中.重寫發生在子類,意思就是子類重寫父類相同名稱的方法.剛學語言有的東西,不必搞得那麼清楚,只有知道怎麼用就行了,有的問題你要想真正把它搞得很懂,短時間是不可能的,比如說介面,沒有幾年工作經驗你根本不可能真正理解什麼是介面,甚至有的人工作四,五年也沒搞明白什麼是介面,不要花太多時間去搞這些不容易搞懂的問題.
重載的特性,方法名相同.返回類型,傳入方法的參數不同(包括個數和類型).
重寫的特性,方法名相同,返回類型,參數均相同,必須發生在子類.

1.Java語言允許某個類型的引用變數引用子類的實例，而且可以對這個引用變數進行類型轉換。
Animal animal=new Dog(); //引用變數animal引用一個Animal子類Dog的實例
Dog dog=(Dog)animal; //向下轉型，把Animal類型轉換為Dog類型
Creature creature=animal; //向上轉型，把Animal類型轉換為 Creature類型
animal=new Cat(); //引用變數animal引用另一個Animal子類Cat的實例
註：Creature這里指的是生物。

2.如果把引用變數轉換為子類類型，稱為向下轉型，如果把引用變數轉換為父類類型，稱為向上轉型。

3.在進行引用變數的類型轉換時，會受到各種限制。而且在通過引用變數訪問它所引用的實例的靜態屬性、靜態方法、實例屬性、實例方法，以及從父類中繼承的方法和屬性時，Java虛擬機會採用不同的綁定機制。

4.成員變數、靜態方法按照引用變數聲明的類型靜態綁定；實例方法按照引用變數引用的實例動態綁定。
例如，對於以下這段代碼：
Fathers f＝new Sons();
System.out.println(「f.var=」+f.var);
System.out.println(「f.staticVar=」+f.staticVar);
f.method();
f.staticMethod();
運行時將會輸出如下結果：
f.var=FatherVar
f.staticVar=StaticFaterVar
Son method
Static Father method

class Fathers{
String var="FatherVar";
static String staticVar="StaticFatherVar";
void method(){System.out.println("Father method");}
static void staticMethod(){System.out.println("Static Father method");}
}

class Sons extends Fathers{
String var="SonVar";
static String staticVar="StaticSonVar";

void method(){System.out.println("Son method");}
static void staticMethod(){System.out.println("Static Son method");}

String sonVar=null;
void sonMethod(){}
}

10. java中什麼是多態,多態有哪幾種實現

多態：一個名稱，多種形態。
用處：設計方法的參數和返回值。
封裝-------產生----->類
繼承------產生------>多態
知識點1（核心）：－－仔細理解
A.任何子類的構造方法都將調用父類的構造方法。
B.任何構造方法的第一行必須是this(...)或super(...)，如果沒有寫，系統會自動加一個默認的super()。
this(...)：調用本類的其他構造方法
－－必須要有其他構造方法並且至少有一個構造方法中有super()才行
super(...)：調用父類的構造方法
解析：
A說明創建子類對象時要先創建父類對象，再在父類對象的基礎上擴展子類的特性。
比如上帝想要創建科學家，必須要先創建人，再加入一些其他特質，才能成為科學家。
從存儲結構上看，創建子類對象時申請的內存空間中有一部分是父類的，但他們仍然是一個對象
知識點2（多態問題中最基本最核心的理論）（面向對象核心理論）：
A.如果我們把一個子類對象當作父類對象來看，那麼我們就只能訪問父類中有定義的屬性和方法。
B.如果子類覆蓋了父類的方法，我們把子類對象當作父類對象來看時，去調用該方法，調用的就是子類