java多態

⑴ java中多態具體是什麼

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

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

Parent p = new Son();

p.speak();

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

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

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

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

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

⑵ java裡面多態怎麼寫的

不夠完整 比如說 a里有方法 public void c(){syso("vv")} f里重寫的方法 public void c(){syso("bb")}

然後 F f=new F（） f.c()
F f =new A（） f.c()
同一引用 有多種不同的表現形式 同樣都是引用f 表現的形式不同

⑶ java多態

看的是孫鑫的視頻教程吧。

這個當然是可以的羅。我回答你的兩個問題：

1.多態。

關於java的多態，有的書上是這樣講的，它講java的多態分成靜態的多態，和動態的多態，而所謂靜態的多態就是只函數的重載，動態的多態就是方法的覆寫。
如下面：
class Test
{
void print()
{
System.out.println("hello world");
}
void print(int x)
{
System.out.println("hello world"+i);
}
public static void main(String []args)
{
Test ts=new Test();
ts.print();
ts.print(10);
}
}
/*
上面的程序就是在一個類中成員方法的重載例子。也就是一個靜態的多態性。系統會在你編譯的時候根據你調用的方法的參數列表來動態的決定調用那一個函數。
*/

動態的多態：

class Test
{
void print()
{
System.out.println("hello Test");
}
public static void main(String []args)
{
A a=new A();
a.print();
}
}

class A extends Test
{
void print()
{
System.out.println("hello A");
}
}

/*
這時由於子類覆寫了父類的方法，所以調用的是子類覆寫後的方法。
這是動態的多態。
*/

你上面的問題，是把一個子類的實例賦值給一個父類。這是可以的，其實我個人覺得這好像不是什麼多態的問題。請看下面的程序：
class A
{
public static void main(String []args)
{
A [] a=new A[3];
a[0]=new B();
a[1]=new C();
a[2]=new D();
for(int i=0;i<a.length;i++)
{
a[i].print();
}
}
}

class B extends A
{
void print()
{
System.out.println("hello B");
}
}

class C extends A
{
void print()
{
System.out.println("hello C");
}
}

class D extends A
{
void print()
{
System.out.println("hello D");
}
}

/*
上面的程序執行的結果：
hello B
hello C
hello D

可以看出，程序不會調用父類的print()方法,再說父類根本就沒有print()方法，但是它不會報錯。這就是JVM (java虛擬機),能在程序運行時，動態的識別變數的類型。就像上面一樣。這主要是考java的運行時的類型識別機制實現的，當然我認為這其實也可以看成是java多態的一種表現。
*/

在java中子類是父類的實例，這就像是說 魚是動物。但不能說動物就一定是魚，這也是符合了人們對現實世界的認識規律。另外java為我們提供了一個關鍵字，在孫鑫的教程裡面也講到了吧。它是instanceof
你可以用這來判斷一個對象是否是一個類的實例。還是上面的A ,B,C ,D類的例子：
在mian函數中寫上下面的代碼：(把原來的代碼刪掉)
B b=new B();
if(b instanceof A)
System.out.println("b instanceof A");
//輸出：b instanceof A

說明b是A類的實例。

再看下面的例子。
A a=new B();
if(a instanceof B)
System.out.println("a instanceof B");

//輸出：a instanceof B
但此時不能這樣，B b=a;
雖然a是B的實例但是這里不能這樣賦值，要像下面：
B b=(B)a;
//進行類型的強制轉換

關於這部分你還是自己體會吧。

2.關於你所說的函數的參數是對象的問題：

函數的參數當然可以是一個對象，類是我們自定義的類型，他可以像基本的數據類型(int ,float等)一樣用來定義變數，在java中類用的是相當多的，類屬於引用類型，而基本類型的變數屬於值類型。在函數傳遞參數的過程中，實際上是傳的是對象的地址。

⑷ 什麼是多態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(){}
}

⑸ java中多態性什麼意思

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

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

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

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

擴展資料:

多態的好處：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(7)java多態擴展閱讀：

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

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

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

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

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

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

⑻ 什麼是JAVA多態

給段代碼：

Inteface 形狀{
public void 畫圖();
}

class 圓形 implements 形狀{
public void 畫圖(){System.out.prinltn("這是個圓形");}
}

class 三角形implements 形狀{
public void 畫圖(){System.out.prinltn("這是個三角形");}
}

class Test {
public static void 畫圖(形狀 graphic){
graphic.畫圖();
}

public static void main(String []args){
形狀 a = new 圓形();
形狀 b = new 三角形();
Test.畫圖(a); //列印出 這是個圓形
Test.畫圖(b); //列印出 這是個三角形
}
}

以上代碼就是多態的體現。。其中 介面 形狀的畫圖方法 在test的畫圖方法中 展現出了 不同的行為 。

⑼ java的多態怎麼實現

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

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