java多態教程

A. 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();調用的。

B. 請問java中怎麼實現多態

首先多態是多種形式或形態，它在計算機程序設計語言中代表一種能力，即用一個特定類型的變數來引用不同類型的對象，並且根據引用對象的不同而自動的調用相應的方法。比如說我們想像一個農民種蔬菜的列子，Vagetable包括Potato和Cabbage兩種蔬菜。農民中類中只需種蔬菜，並不用知道它具體是哪種蔬菜，只需要把實現了蔬菜類的土豆和大白菜放進方法里就可以了，然後java會根據多態的特性來自動為我們調用土豆類的方法和大白菜類的方法。創建了一個抽象類Vagetable（蔬菜）類，這個類中有個抽象的方法public abstract void grow();再在Potato和Cabbage中實現這個抽象方法：土豆類中寫一個方法public void grow(){System.out.println("我是土豆")};大白菜類寫一個方法：public void grow(){System.out.println("我是大白菜")};我們再建個農民類，農民有個plant()方法，我們寫一個農民種蔬菜的抽象方法：public void plant(Vagetable v){v.grow()};最後我們可以讓農民種蔬菜了，創建對象Farm f=new Farm();f.plant(new Potato);f.plant(new Cabbage);就可以列印出各自的方法了，即」我是土豆「和」我是大白菜」兩句話！

C. 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();

D. Java多態代碼

多態的前提 ： 必須是類與類之間只有關系，要麼繼承或實現 ，存在覆蓋 ；

示例代碼如下：

E. Java實現多態的步驟是什麼

方法重寫 方法覆蓋

F. java多態

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

G. java) 實現多態性需要的基本步驟

第一步：創建一個父類，如Animal（動物） 類，這個方法中只有方法的定義，沒有實現。第二步：創建一個子類，如cat(貓)類，這個方法中實現父類中的所有方法，並進行重寫。
第三步：創建一個子類，如dog(狗)類，這個方法中實現父類中的所有方法，並進行重寫。
備註：多態實際上是一個父類有特定的屬性，如動物有名稱、年齡、所屬科目，之後由子類去實現具體的，如貓，名稱是貓，年齡是5歲，所屬科目為貓科，然後狗同樣有這些屬性，只不過是值不同，這個就是一個多態的形式。子類可以有無限多，在步驟三後面添加即可。

H. Java中多態的實現

java
中有介面implements
抽象類
abstract
抽相類，裡面方法都是抽象的，只有方法，沒有方法體，主要就是為了讓子類繼承，實現不同的功能。一個類只能有一個直接父類，但是他可以實現很多介面，實現不同的功能。

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

J. java的多態怎麼實現

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