java的多態

⑴ java中多態的定義是什麼

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

⑵ java中多態性什麼意思

多態性：顧名思義就是擁有「多種形態」的含義，是指屬性或方法在子類中表現為多種形態。

在JAVA中有兩種多態是指：運行時多態和編譯時多態。多態性是面向對象的核心特徵之一,類的多態性提供類中成員設計的靈活性和方法執行的多樣性。

多態指允許不同類的對象對同一消息做出響應。即同一消息可以根據發送對象的不同而採用多種不同的行為方式。（發送消息就是函數調用）

實現多態的技術稱為：動態綁定（dynamic binding），是指在執行期間判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。

擴展資料:

多態的好處：

1、可替換性（substitutability）多態對已存在代碼具有可替換性。例如，多態對圓Circle類工作，對其他任何圓形幾何體，如圓環，也同樣工作。

2、可擴充性（extensibility）多態對代碼具有可擴充性。增加新的子類不影響已存在類的多態性、繼承性，以及其他特性的運行和操作。實際上新加子類更容易獲得多態功能。

3、介面性（interface-ability）多態是超類通過方法簽名，向子類提供了一個共同介面，由子類來完善或者覆蓋它而實現的。

4、靈活性（flexibility）它在應用中體現了靈活多樣的操作，提高了使用效率。

5、簡化性（simplicity）多態簡化對應用軟體的代碼編寫和修改過程，尤其在處理大量對象的運算和操作時，這個特點尤為突出和重要。

⑶ 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中多態是什麼意思

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

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

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

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

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

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

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

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

(4)java的多態擴展閱讀：

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

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

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

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

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

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

⑸ java中多態是怎麼實現的

聲明一個類作為父類，創建多個子類用父類NEW子類這個就是多態了
例如：
//創建一個父類
public class Person（）｛
private int age ;
private String name;
public void say(){
System.out.println("我是人類");
}
｝
//創建子類繼承父類
public class Man extends Person(){
...
}
public class Woman extends Person(){
...
}
//使用父類NEW子類(多態)
Person P1=new Man();
Person p2=new Woman();

⑹ Java多態

比如A a = new B();是創建了一個子類對象並把它當成父類對象A用

也就是父類引用指向子類對象

此時,引用變數a有2個類型,編譯時的類型為A,運行時的類型為B.在代碼編譯過程中,a 只能調用屬於A的方法. 不能調用B類裡面的方法.注意,由於繼承關系,如果B重寫了A的某個方法,比如說eat(),而在代碼編譯過程中,a.eat()調用的是A的eat(),但在程序運行時,卻運行的是B的eat(). 這就是多態

首先,你要對比一下Animal a = new Tiger(); Tiger繼承並重寫了Animal的eat()方法.這也是父類引用指向子類對象.首先, a 是 一隻老虎.但不幸的是,Animal a= new Tiger(); 也就是說a雖然有了老虎的實質, 就是說有了老虎的爪子,身材..... , 但卻沒有老虎的名分.它雖然身體是老虎, 但名字或者說它的類別卻是動物,而不是老虎.而作為動物的定義,你當然不能使用屬於老虎的定義的方法.比如說,雖然二者都有吃的行為, 但老虎吃肉,動物都吃肉么? 所以雖然a實質上是老虎,但在書面描述a的行為時,你只能使用動物的定義. 這個階段就相當於代碼的編譯的階段.而此時a的類型為編譯時的類型-動物.而如果具體實施吃的行為時, 比如說給a喂吃的, 雖然書面定義了a只能有動物的籠統的吃的方法,比如說用嘴,沒有規定要吃肉.但是現在是具體操作了,由於a實質上是老虎,所以a實質上履行的還是老虎的吃的方法. 具體的吃的過程,就相當於程序的運行的階段. 而此時a的類型為運行時的類型-老虎

⑺ 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）。多態簡化對應用軟體的代碼編寫和修改過程，尤其在處理大量對象的運算和操作時，這個特點尤為突出和重要。

⑻ java的多態怎麼實現

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

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

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

⑽ java中的多態 到底怎麼使用

Java中的多態允許父類指針指向子類實例。如：Father obj=new Child();（其中Child是Father的子類）。這樣就產生了一個問題——

使用這個父類型的指針訪問類的屬性或方法時，如果父類和子類都有這個名稱的屬性或方法，哪一個屬性或方法會被調用呢？

最好的辦法是實驗：

class Father
{
int r;
Father()
{
r=4;
}
void printname()
{
System.out.println("I』m father");
}
}
class Child extends Father
{
int r;
Child()
{
r=5;
}
void printname()
{
System.out.println("I』m Child");
}
}
public class Test
{
public static void main(String[] args)
{
Father obj=new Child();
System.out.println(obj.r);
obj.printname();
}
}

結果輸出：

4
I』m Child

實驗證明。屬性會訪問父類的。方法分訪問子類的。

這就是多態了。

不要以為Father obj=new Child();這條語句一定會讓obj.printname()指向Chlid定義的printname()。實際上，如果你把Father類中的printname()方法刪除，這個程序將編譯失敗。因為Father中的並沒有定義printname()這個函數。多態是晚綁定*(見本文最後的資料)的，在Father obj=new Child();這個語句中，如果Father中沒有printname()這個函數，就不會為obj建立一個用於調用printname()函數的指針。所以調用obj.printname()會出錯。如果Father中有這個函數。指向printname()函數的指針會被創建。在調用obj.printname()時，不會出錯，而且，因為obj指向的是new Child()，是個Chld類的實例。所以調用obj.printname()時調用了Child類中定義的printname()。這就是方法的動態綁定。

那麼，剛才說到把Father類中的printname()方法刪掉後，obj將無法調用Child類中的printname()，因為obj.printname()會編譯失敗。那麼如果我就是需要調用要怎麼辦呢？其實雖然obj是Father類型的，但是它指向的是一個Child類的實例。那麼可以將obj強制類型轉換為Child。再調用printname()方法就可以了。

在上面程序中，把Father類中的printname()方法整個刪掉，再將obj.printname() 改成 ((Child)obj).printname()後，編譯成功，結果輸出：

4
I』m Child

兩次輸出的結果都是I』m Child。

那麼如何可以運行Child類中的printname()來輸出「I』m Father」呢？

其實只需要將Father obj=new Child();改成Father obj=new Father();就可以了，呵呵。另一個辦法就是將Child類中定義的printname()整個刪掉。為什麼這樣可以成功呢？自己想想，嘿嘿。最後會有個這樣的思考題。

看到這兒你可能早就想問了：

為什麼obj.r是4？為什麼不是5？

呵呵。其實很簡單。Java中的多態僅為方法而言，成員變數還是使用的父類的成員變數。也就是說，因為「Father obj =……」，所以obj是Father類型的，所以obj裡面的r是Father裡面的r，所以輸出obj.r就是4了。

你又想問：

那麼5去哪了？new Child()的時候，不是會把5放到Child的r中嗎？

實際上5還是有的。只是obj.r是4而已。想訪問Child中的r，把5讀出來，可以這樣寫：

((Child)obj).r

就是把obj由Father型強制轉換成了Child型。

OK，方法和屬性在多態中是什麼樣的你都清楚了。現在做個題測試一下吧：

這是[email protected]的一道題：

class Base {
int i = 99;
public void amethod() {
System.out.println("Base.amethod()");
}
Base() {
amethod();
}
}
public class Derived extends Base {
int i = -1;
public static void main(String argv[]) {
Base b = new Derived();
System.out.println(b.i);
b.amethod();
}
public void amethod() {
System.out.println("Derived.amethod()");
}
}

會輸出什麼？

先想想，再看答案：

答案：
========================
Derived.amethod()
99
Derived.amethod()
========================
講解：

這個程序的執行過程是這樣的：

第一行：Base b=new Derived();

執行這一行語句的過程中，要構造Derived這個類，而它有父類Base，所以先構造Base類。構造Base類的默認構造函數有定義。內容是執行amethod()方法。

實際上，Base類構造方法中的執行amethod()，相當於執行this.amethod()，在這個程序中，就相當於執行b.amethod()。而b是Base類型的，指向了Derived類的實例的指針。所以跟據上面我們的總結，實際上執行的是Derived類的amethod()函數。所以，第一行「Base b=new Derived();」執行完，輸出"Derived.amethod()"。

第二行：System.out.println(b.i);

這個很簡單，成員變數，不考慮多不多態，只看它定義時前面的類型。這個程序中是Base b，所以b.i就是Base類中的i。輸出99

第三行：b.amethod();

調用Derived類中的amethod()方法。

其實這行就是迷惑你的，如果沒有這一行。你可能會警覺起來——咦？為什麼這兒定義一個amethod()呢？沒有地方調用它啊？

有了這行代碼，就會使你放鬆警惕。覺得，啊。定義了這個是用來讓b.amethod();調用的。