java對多態的理解

❶ java中多態是什麼意思

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

❷ 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個形態代表多個形態）

❸ 怎麼理解JAVA中的多態性

一、基本概念

多態性：發送消息給某個對象，讓該對象自行決定響應何種行為。
通過將子類對象引用賦值給超類對象引用變數來實現動態方法調用。

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

1. 如果a是類A的一個引用，那麼，a可以指向類A的一個實例,或者說指向類A的一個子類。
2. 如果a是介面A的一個引用，那麼,a必須指向實現了介面A的一個類的實例。

二、Java多態性實現機制

SUN目前的JVM實現機制，類實例的引用就是指向一個句柄（handle）的指針，這個句柄是一對指針：
一個指針指向一張表格，實際上這個表格也有兩個指針（一個指針指向一個包含了對象的方法表，另外一個指向類對象，表明該對象所屬的類型）；
另一個指針指向一塊從java堆中為分配出來內存空間。

The Java Virtual Machine does not require any particular internal structure for objects. In Sun 's current implementation of the Java Virtual Machine, a reference to a class instance is a pointer to a handle that is itself a pair of pointers: one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object, and the other to the memory allocated from the Java heap for the object data. （jvm規范中關於對象內存布局的說明）

三、總結

1、通過將子類對象引用賦值給超類對象引用變數來實現動態方法調用。

DerivedC c2=new DerivedC();
BaseClass a1= c2; //BaseClass 基類，DerivedC是繼承自BaseClass的子類
a1.play(); //play()在BaseClass，DerivedC中均有定義，即子類覆寫了該方法

分析：
* 為什麼子類的類型的對象實例可以覆給超類引用？
自動實現向上轉型。通過該語句，編譯器自動將子類實例向上移動，成為通用類型BaseClass；
* a.play()將執行子類還是父類定義的方法？
子類的。在運行時期，將根據a這個對象引用實際的類型來獲取對應的方法。所以才有多態性。一個基類的對象引用，被賦予不同的子類對象引用，執行該方法時，將表現出不同的行為。

在a1=c2的時候，仍然是存在兩個句柄，a1和c2，但是a1和c2擁有同一塊數據內存塊和不同的函數表。

2、不能把父類對象引用賦給子類對象引用變數

BaseClass a2=new BaseClass();
DerivedC c1=a2;//出錯

在java裡面，向上轉型是自動進行的,但是向下轉型卻不是，需要我們自己定義強制進行。
c1=(DerivedC)a2; 進行強制轉化,也就是向下轉型.

3、記住一個很簡單又很復雜的規則，一個類型引用只能引用引用類型自身含有的方法和變數。
你可能說這個規則不對的，因為父類引用指向子類對象的時候，最後執行的是子類的方法的。
其實這並不矛盾，那是因為採用了後期綁定，動態運行的時候又根據型別去調用了子類的方法。而假若子類的這個方法在父類中並沒有定義，則會出錯。
例如，DerivedC類在繼承BaseClass中定義的函數外，還增加了幾個函數（例如 myFun()）

分析：
當你使用父類引用指向子類的時候，其實jvm已經使用了編譯器產生的類型信息調整轉換了。
這里你可以這樣理解，相當於把不是父類中含有的函數從虛擬函數表中設置為不可見的。注意有可能虛擬函數表中有些函數地址由於在子類中已經被改寫了，所以對象虛擬函數表中虛擬函數項目地址已經被設置為子類中完成的方法體的地址了。

❹ 如何理解JAVA的多態性

在面向對象編程中，多態是指一個介面有多種實現方式，即一個介面使用不同實例執行不同的操作。在java中多態有兩種表現形式：方法的重載和方法的重寫。方法的重載是指同一個類中可以可以存在多個同名的方法，但這些方法的參數必須不同（個數，順序，類型），程序運行時根據其參數的數量與類型調用對應的方法實現不同的功能。（與返回值類型沒有關系）public
void
plant(int
i){方法體；}public
void
plant(String
s){方法體；}方法的重寫是指子類提供與父類相同的方法，包括方法的名稱，參數列表，返回值類型。 還有可以
父類
變數名=new
子類（）；

❺ 北大青鳥分享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類型的對象的。這就是「向上轉型」。

❻ 如何理解和應用Java的多態

多態的定義：指允許不同類的對象對同一消息做出響應。即同一消息可以根據發送對象的不同而採用多種不同的行為方式。
JAVA引用變數有兩個類型：一個是編譯時的類型，一個是運行時的類型，編譯時的類型由聲明該變數時使用的類型決定，運行時的類型由實際賦給該變數的對象決定。如果編譯時類型和運行時類型不一致，就會出現所謂的多態（Polymorphism）。

❼ java中多態的定義是什麼

多態性是指允許不同類的對象對同一消息作出響應，多態性包括參數化多態性和包含多態性，多態性語言具有靈活、抽象、行為共享、代碼共享的優勢，很好的解決了應用程序函數同名問題。
多態有兩種表現形式：重載和覆蓋
1、首先說重載（overload），是發生在同一類中，與什麼父類子類、繼承毫無關系。
標識一個函數除了函數名外，還有函數的參數（個數和類型），也就是說，一個類中可以有兩個或更多的函數，叫同一個名字而他們的參數不同。
他們之間毫無關系，是不同的函數，只是可能他們的功能類似，所以才命名一樣，增加可讀性，僅此而已！
2、再說覆蓋(override),是發生在子類中，也就是說必須有繼承的情況下才有覆蓋發生。
繼承一個類，也就有了父類了全部方法，如果你感到哪個方法不爽，功能要變，那就把那個函數在子類中重新實現一遍。
這樣再調用這個方法的時候，就是執行子類中的過程了，父類中的函數就被覆蓋了。

❽ java描述一下什麼是多態

/*1.要有繼承關系2.子類要重寫父類的方法3.父類的引用指向子類的對象或者借口的引用指向遵從借口的類對象*/
//父類
classAnimal{
intnum=5;
staticintage=2;
publicvoideat(){
System.out.println("動物在吃東西");
}
publicstaticvoidsleep(){
System.out.println("動物在睡大覺");
}
publicvoidrun(){
System.out.println("動物在亂躥");
}
}
//子類sloth樹獺
classslothextendsanimal{
intnum=10;
staticintage=8;
Stringname="sloth";
publicvoideat(){
system.out.println("樹獺進餐");
}
publicstaticvoidsleep(){
system.out.println("有事沒事就睡一覺");
}
publicvoidjump(){
system.out.println("跳躍不存在的");
}
}
//列印結果
classdemo1{
publicstaticvoidmain(String[]args){
Animalani=newsloth();
ani.eat();
ani.sleep();
ani.run();
System.out.println(ani.num);
System.out.println(sni.age);
}
}
//純手打多敲幾遍就明白了看著結果琢磨琢磨或者上CSDN狠全面的都是大佬

❾ 對Java中多態的理解

多態用於繼承和介面情況下。。。比方說你是person的子類，那麼你本身就是person
在java中，多態大致可以分為以下幾種情況：

1.person為父類，student為子類。那麼：person p=new student（）；

2.fliable為介面，bird為實現介面的類，那麼：fliable f=new bird（）；

3.fliable為抽象類，bird為繼承fliable的類，那麼：fliable f=new bird（）；

具體可以看我的博客http://greenyouyou.blog.163.com/blog/static/138388147201010861035709/