java多態實例

1. 幫我解釋一個java多態的例子

首先應該明白 A a2 = new B()是創建一個B對象並把它轉換成A對象。
對於a1它是A類的對象有函數show(D)，show(A),a2是B對象，然後轉換成A那麼它擁有的函數是show(d),show(A)此時A已覆蓋，即返回值為（「B and A」）。b是一個B的對象，有函數show(D)(繼承A)，show(A)覆蓋A，show(B)子類自有函數。C和D是B的子類。
a1.show(b)是在A中找到滿足條件的方法，調用show(A)函數。result:A and A
a1.show(c)在A中找到show(A).result: A and A
a1.show(d)在A中找到show(D).result: A and D
a2.show(b)在它擁有的函數中找到被B覆蓋過的show(A).result: B and A
a2.show(c)找到被B覆蓋過的show(A).result: B and A
a2.show(d)show(D)result A and D
b.show(b) show(B) result:B and B
b.show(c) show(B) result: B and B
b.show(d) 上找到A中的show(D) result: A and D

a2.show(d)

2. JAVA中，為什麼要用多態，，怎麼用請給個通俗易懂的例子解釋下……

舉個例子，顯示鳥的飛行動作
對於八哥鳥，你可以這樣new Myna().fly();
對於鸚鵡，你可以這樣new Parrot().fly();
對於孔雀，你可以這樣 new Peacock().fly();
。。。
對於每一個具體的鳥，你都必須調用具體的鳥類對象。
現在使用多態再來看看。
我們先寫一個Bird類，用來抽取出鳥類的飛行動作。
public abstract class Bird {
public void fly() {
System.out.println("default bird fly!");
}
}

再寫具體的鳥類，繼承Bird類
class Parrot extends Bird {
@Override
public void fly() {
System.out.println("Parrot fly");
}
}

class Myna extends Bird {
@Override
public void fly() {
System.out.println("Myna fly");
}
}

現在再來看一下八哥和鸚鵡的飛行動作。
public static void main(String args[]) {
Bird bird = new Parrot();
bird.fly();
bird = new Myna();
bird.fly();
}
這樣，同一個Bird的實例對象實際對調用的是八哥和鸚鵡的飛行動作。

假如這樣還不清楚。那麼現在有一個flyPerform()方法，顯示具體的鳥的飛行行為。
flyPerform(Bird bird){
bird.fly();
}

那麼你就可以這樣
flyPerform(new Parrot());
flyPerform(new Myna());

假如現在又有了一種新的鳥，NewBird那麼我們只需要將new NewBird作為參數傳入flyPerform方法即可，而不需要去修改這個方法的代碼。

這是一個比較粗糙的例子，要不你仔細琢磨看看？

對於這個推薦答案，我不是很認同，
在java裡面多態一般指的是運行時多態，重載多態是通過方法簽名實現的，同一個方法名，但是要求參數必須不一樣，這個在編譯期間就可以確定調用的是哪個方法。
重載多態在C++上說的比較多些吧。

3. 關於Java多態以及可變形參的問題

首先，運行結果的確是sub。但不是因為「編譯器認為 int[] arr 和 int...arr 是一樣的」。而是因為：①可變參數最終會被編譯器以數組的方式存下來；然後調用的時候會優先匹配定長參數的方法，只有當定長參數的方法一個都匹配不上了，才去找非定長參數的方法；②你這個上轉型之後其實讓base這個實例擁有了兩個方法，一個是父類的不定長參數，一個是子類的定長參數方法；

傳參不報錯是因為判斷參數是否合法時匹配到了不定長參數那個方法；然後執行時優先匹配到了定長參數方法（可變參和數組存儲方式一致）。編譯器並不知道什麼可變不可變，就單純的按照規則去校驗調用；

對編譯器來說，方法名稱和參數列表組成了一個唯一鍵，稱為方法簽名，JVM 通過方法簽名決定調用哪種重載方法。

JVM 在重載方法中選擇合適方法的順序：

① 精確匹配。

② 基本數據類型自動轉換成更大表示範圍。

③ 自動拆箱與裝箱。

④ 子類向上轉型。

⑤ 可變參數。

你這個上轉型實現後，即實現了重寫，又實現了一種特殊的重載；而編譯器編譯時檢查參數合法性的時候檢查到了可變參的方法（你滑鼠挪到調用的地方你會看到，編譯器提示的你的方法是父類的可變參方法的，因為此時這個參數不是數組，是匹配不到定長參數的子類方法的）；

然後編譯好具體執行的時候，編譯器哪還知道什麼定長不定長，就按照優先順序去調用方法，自然就把優先順序高的子類定長方法調用到了，不存在什麼動態綁定。

這里如果你把子類和父類的參數交換（子類是可變參數，父類是數組）那你的調用就報錯了，因為可變參兼容數組，但是數組卻不兼容可變參，這樣就只形成重寫而沒有重載，然後上轉型後就只能調用父類的方法了。就會報錯咯

4. 昆明電腦培訓學校告訴你java多態的總結

父類引用指向子類對象是Java比較基礎的概念。Java作為一門面向對象編程的語言，調用對象是在編程中經常用到的。北大青鳥http://www.kmbdqn.cn/為大家詳細說明這一概念。

例如父類Animal，子類Cat,Dog。其中Animal可以是類也可以是介面，Cat和Dog是繼承或實現Animal的子類。

Animalanimal=newCat();

即聲明的是父類，實際指向的是子類的一個對象。

那這么使用的優點是什麼，為什麼要這么用？可以用這幾個關鍵詞來概括：多態、動態鏈接，向上轉型。也有人說這是面向介面編程，可以降低程序

的耦合性，即調用者不必關心調用的是哪個對象，只需要針對介面編程就可以了，被調用者對於調用者是完全透明的。讓你更關注父類能做什麼,而

不去關心子類是具體怎麼做的,你可以隨時替換一個子類,也就是隨時替換一個具體實現,而不用修改其他。

以後結合設計模式（如工廠模式，代理模式）和反射機制可能有更深理解。

下面介紹Java的多態性和其中的動態鏈接，向上轉型：

面向對象的三個特徵：封裝、繼承和多態；

封裝隱藏了類的內部實現機制，可以在不影響使用者的前提下修改類的內部結構，同時保護了數據；

繼承是為了重用父類代碼，子類繼承父類就擁有了父類的成員。

方法的重寫、重載與動態連接構成多態性。Java之所以引入多態的概念，原因之一是它在類的繼承問題上和C++不同，後者允許多繼承，這確實給其

帶來的非常強大的功能，但是復雜的繼承關系也給C++開發者帶來了更大的麻煩，為了規避風險，Java只允許單繼承，派生類與基類間有IS-A的關系

（即「貓」isa「動物」）。這樣做雖然保證了繼承關系的簡單明了，但是勢必在功能上有很大的限制，所以，Java引入了多態性的概念以彌補這

點的不足，此外，抽象類和介面也是解決單繼承規定限制的重要手段。同時，多態也是面向對象編程的精髓所在。

理解多態，首先要知道「向上轉型」。

我定義了一個子類Cat，它繼承了Animal類，那麼後者就是前者是父類。我可以通過

Catc=newCat();

實例化一個Cat的對象，這個不難理解。但當我這樣定義時：

Animala=newCat();

這代表什麼意思呢？

很簡單，它表示我定義了一個Animal類型的引用，指向新建的Cat類型的對象。由於Cat是繼承自它的父類Animal，所以Animal類型的引用是可以指向

Cat類型的對象的。這就是「向上轉型」。

5. 求java中幾個繼承與多態實例，並要有相應的題目！給我參考和練習下，本人新手，不宜難的

JAVA中一個抽象類抽象方法繼承與對象多態性的例子
面向對象的三大特點：封裝，繼承，多態。

在JAVA中我們總是盡可能地讓一個類繼承一個抽象類，這樣大大的節省代碼方便開發。

一個繼承與對象多態性的例子：聲明一個Person 類。Student 類，Worker類分別繼承Person。

人有姓別，年齡，學生有特有的成績屬性，工人有特有的工資。

所有屬性都用private封裝

abstract class Person{
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public void say(){
System.out.println(this.getContent());
}
public abstract String getContent();
}
class Worker extends Person{
private float salary;
public Worker(String name,int age,float salary){
super(name,age);
this.setSalary(salary);
}
public void setSalary(float salary){
this.salary=salary;
}
public float getSalary(){
return this.salary;
}
public String getContent(){
return "工人信息------>姓名："+super.getName()+",年齡："+super.getAge()+"，工資："+this.getSalary();
}
}
class Student extends Person{
private float score;
public Student(String name,int age,float score){
super(name,age);
this.setScore(score);
}
public void setScore(float score){
this.score=score;
}
public float getScore(){
return this.score;
}
public String getContent(){
return "學生信息------>姓名："+super.getName()+", 年齡："+super.getAge()+",成績："+this.getScore();
}
}
public class OODemo11{
public static void main(String []args){
Person p=null;
p=new Student("張三",23,90);
p.say();
p=new Worker("李師傅",26,3000);
p.say();

}
}

運行結果：

學生信息------>姓名：張三, 年齡：23,成績：90.0
工人信息------>姓名：李師傅,年齡：26，工資：3000.0

6. java實現多態有幾種方式分別是什麼

首先，多態存在的三個必要條件
一、要有繼承；
二、要有重寫；
三、父類引用指向子類對象。
多態引用類型有兩種方式：
a. 編譯時多態：方法的重載；
b. 運行時多態：JAVA運行時系統根據調用該方法的實例的類型來決定選擇調用哪個方法則被稱為運行時多態。（我們平時說得多的事運行時多態，所以多態主要也是指運行時多態）；

7. java 利用對象多態性給介面實例化，用子類對象去實例化父類介面

首先 A 為父類並且是介面，那麼如果B類繼承A類的話，B類必須為interface（也為介面），
如果B非要 繼承A類的話，就是所說的介面的實現用implements，介面中如果有私有的函數聲明，那你在寫這個函數還有什麼意義嗎？所有new對象的時候 A a = new B(); 這是多態的體現

8. java的多態怎麼實現

實現多態的三個條件（前提條件，向上轉型、向下轉型）
1、繼承的存在；（繼承是多態的基礎，沒有繼承就沒有多態）
2、子類重寫父類的方法。（多態下會調用子類重寫後的方法）
3、父類引用變數指向子類對象。（涉及子類到父類的類型轉換）
向上轉型 Student person = new Student()
將一個父類的引用指向一個子類對象，成為向上轉型，自動進行類型轉換。此時通過父類引用變數調用的方法是子類覆蓋或繼承父類的方法，而不是父類的方法此時通過父類引用變數無法調用子類特有的方法。
向下轉型 Student stu = (Student)person;
將一個指向子類對象的引用賦給一個子類的引用，成為向下轉型，此時必須進行強制類型轉換。向下轉型必須轉換為父類引用指向的真實子類類型，，否則將出現ClassCastException，不是任意的強制轉換
向下轉型時可以結合使用instanceof運算符進行強制類型轉換，比如出現轉換異常---ClassCastException

9. 北大青鳥分享java多態的總結

父類引用指向子類對象是Java比較基礎的概念。Java作為一門面向對象編程的語言，調用對象是在編程中經常用到的。北大青鳥http://www.kmbdqn.com/為大家詳細說明這一概念。

例如父類Animal，子類Cat,Dog。其中Animal可以是類也可以是介面，Cat和Dog是繼承或實現Animal的子類。

Animal animal = new Cat();

即聲明的是父類，實際指向的是子類的一個對象。

那這么使用的優點是什麼，為什麼要這么用？可以用這幾個關鍵詞來概括：多態、動態鏈接，向上轉型。也有人說這是面向介面編程，可以降低程序

的耦合性，即調用者不必關心調用的是哪個對象，只需要針對介面編程就可以了，被調用者對於調用者是完全透明的。讓你更關注父類能做什麼,而

不去關心子類是具體怎麼做的,你可以隨時替換一個子類,也就是隨時替換一個具體實現,而不用修改其他。

以後結合設計模式（如工廠模式，代理模式）和反射機制可能有更深理解。

下面介紹Java的多態性和其中的動態鏈接，向上轉型：

面向對象的三個特徵：封裝、繼承和多態；

封裝隱藏了類的內部實現機制，可以在不影響使用者的前提下修改類的內部結構，同時保護了數據；

繼承是為了重用父類代碼，子類繼承父類就擁有了父類的成員。

方法的重寫、重載與動態連接構成多態性。Java之所以引入多態的概念，原因之一是它在類的繼承問題上和C++不同，後者允許多繼承，這確實給其

帶來的非常強大的功能，但是復雜的繼承關系也給C++開發者帶來了更大的麻煩，為了規避風險，Java只允許單繼承，派生類與基類間有IS-A的關系

（即「貓」is a 「動物」）。這樣做雖然保證了繼承關系的簡單明了，但是勢必在功能上有很大的限制，所以，Java引入了多態性的概念以彌補這

點的不足，此外，抽象類和介面也是解決單繼承規定限制的重要手段。同時，多態也是面向對象編程的精髓所在。

理解多態，首先要知道「向上轉型」。

我定義了一個子類Cat，它繼承了Animal類，那麼後者就是前者是父類。我可以通過

Cat c = new Cat();

實例化一個Cat的對象，這個不難理解。但當我這樣定義時：

Animal a = new Cat();

這代表什麼意思呢？

很簡單，它表示我定義了一個Animal類型的引用，指向新建的Cat類型的對象。由於Cat是繼承自它的父類Animal，所以Animal類型的引用是可以指向

Cat類型的對象的。這就是「向上轉型」。

10. java中多態的特點

Java中多態性的實現
面向對象的三大特性：封裝、繼承、多態。從一定角度來看，封裝和繼承幾乎都是為多態而准備的。這是我們最後一個概念，也是最重要的知識點。
多態的定義：指允許不同類的對象對同一消息做出響應。即同一消息可以根據發送對象的不同而採用多種不同的行為方式。（發送消息就是函數調用）
實現多態的技術稱為：動態綁定（dynamic binding），是指在執行期間判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。
多態的作用：消除類型之間的耦合關系。
現實中，關於多態的例子不勝枚舉。比方說按下 F1 鍵這個動作，如果當前在 Flash 界面下彈出的就是 AS 3 的幫助文檔；如果當前在 Word 下彈出的就是 Word 幫助；在 Windows 下彈出的就是 Windows 幫助和支持。同一個事件發生在不同的對象上會產生不同的結果。
下面是多態存在的三個必要條件，要求大家做夢時都能背出來！
多態存在的三個必要條件
一、要有繼承；
二、要有重寫；
三、父類引用指向子類對象。
多態的好處：
1.可替換性（substitutability）。多態對已存在代碼具有可替換性。例如，多態對圓Circle類工作，對其他任何圓形幾何體，如圓環，也同樣工作。
2.可擴充性（extensibility）。多態對代碼具有可擴充性。增加新的子類不影響已存在類的多態性、繼承性，以及其他特性的運行和操作。實際上新加子類更容易獲得多態功能。例如，在實現了圓錐、半圓錐以及半球體的多態基礎上，很容易增添球體類的多態性。
3.介面性（interface-ability）。多態是超類通過方法簽名，向子類提供了一個共同介面，由子類來完善或者覆蓋它而實現的。如圖8.3 所示。圖中超類Shape規定了兩個實現多態的介面方法，computeArea()以及computeVolume()。子類，如Circle和Sphere為了實現多態，完善或者覆蓋這兩個介面方法。
4.靈活性（flexibility）。它在應用中體現了靈活多樣的操作，提高了使用效率。
5.簡化性（simplicity）。多態簡化對應用軟體的代碼編寫和修改過程，尤其在處理大量對象的運算和操作時，這個特點尤為突出和重要。