Java 多型

---

多型是同一個行為具有多個不同表現形式或形態的能力。

多型就是同一個介面，使用不同的例項而執行不同操作

多型的優點

• 1. 消除型別之間的耦合關係
• 2. 可替換性
• 3. 可擴充性
• 4. 介面性
• 5. 靈活性
• 6. 簡化性

多型存在的三個必要條件

• 繼承
• 重寫
• 父類引用指向子類物件

比如：

Parent p = new Child();

當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去呼叫子類的同名方法。

多型的好處：可以使程式有良好的擴充套件，並可以對所有類的物件進行通用處理。

以下是一個多型例項的演示，詳細說明請看註釋：

Test1.java 檔案程式碼：

public class Test1 {
/*
* 多型:
* 過載:當方法名相同時,根據方法的引數列表不一樣,具有不同的方法實現
* 重寫:當具有相同父類(介面)時,根據子類所具有的不同方法執行不同的操作
*/
public static void main(String[] args) {
// //重寫的多型性
// Animals c=new Cat();
// c.act();
// Animals d=new Dog();
// d.act();
// double e=3.4;
// int f=(int) e;
// //向下造型(強制轉型)
// Animals c=new Cat();
// c.act();
// Cat d=(Cat) c;
// d.work();
//
// Animals e=new Dog();
// e.act();
// Dog f=(Dog)e;//向下造型 增肥
// f.work();
//
// Animals g=f;//向上造型 瘦身   Animals g=new Dog();
// g.work();//編譯錯誤,引用c前面的型別沒有work方法
show(new Cat());
show(new Dog());
}


private static void show(Animals a) {//Animals a =new Cat(); 向上造型  Animals a=new Dog(); 向上造型
//instanceof
//instanceof前面的引用所指向的物件型別,是否是instanceof後面型別的子類或同類型
if(a instanceof Cat){//判斷a所指向的物件型別是否為Cat;
Cat c=(Cat) a;//如果是Cat向下造型為Cat
c.work();
}else if(a instanceof Dog){//判斷a所指向的物件型別是否為Dog
Dog d=(Dog) a;//如果是Dog向下造型為Dog
d.work();
}

}


}
abstract class Animals{
abstract void act();
}
class Cat extends Animals{
@Override
void act() {
System.out.println("吃魚");

}
public void work(){
System.out.println("抓老鼠");
}

}
class Dog extends Animals{
@Override
void act() {
System.out.println("啃骨頭");

}
public void work(){
System.out.println("看家");
}

}

---

instanceof關鍵字

Test2.java 檔案程式碼：

public class Test2 {
public static void main(String[] args) {
Person e=new Emp();
//instanceof前面的引用所指向的物件型別,是否是instanceof後面型別的子類或同類型
System.out.println(e instanceof Person);//true
System.out.println(e instanceof Emp);//true
System.out.println(e instanceof Boss);//false

Person p=new Person();
System.out.println(p instanceof Emp);//false

}


}
 class Person{

}
class Emp extends Person{

}
class Boss extends Person{

}

內部類

Test3.java 檔案程式碼：

public class Test3 {
//內部類  一個類可以定義另一個類的內部，定義在類內部的類稱為內部類,定義在外面的稱為外部類
public static void main(String[] args) {
Outer o=new Outer(100);
o.print();
//除了在外部類的構造方法裡建立內部類的物件，還可以通過下面方式建立物件
Outer.Inner i=new Outer(100).new Inner();
i.timeInfo();

}


}
class Outer{
private int time;
private Inner inner;
Outer(int time){//int time=100;
this.time=time;
inner=new Inner();//一般在外部類的構造方法裡建立內部類的物件
inner.timeInfo();//通過內部類物件呼叫內部類的方法
}
private void go(){
System.out.println("跑步");
}
public void print(){
System.out.println(time);
}
class Inner{
public void timeInfo(){
go();//內部類可以呼叫外部類的方法(包括私有的)
time++;//內部類可以呼叫外部類的屬性(包括私有的)   time=time+1;
}
}

}

匿名內部類

Test4.java 檔案程式碼：

public class Test4 {
//匿名內部類 匿名內部類也就是沒有名字的內部類
/*
* 正因為沒有名字，所以匿名內部類只能使用一次，它通常用來簡化程式碼編寫
但使用匿名內部類還有個前提條件：必須繼承一個父類或實現一個介面
*/
public static void main(String[] args) {
Persons c=new Child();
c.eat();
System.out.println("c="+c);
//匿名內部類
//抽象類不能例項化,如果硬要例項化，只能建立抽象類的匿名內部類
Persons p=new Persons(){
@Override
public void eat() {
System.out.println("不知道名字的類,應該要去吃飯");
}

};
p.eat();
System.out.println("p="+p);
//介面不能例項化,如果硬要例項化，只能建立介面的匿名內部類
A a=new A() {
public void a() {
System.out.println("a");
}
};
a.a();
}


}
abstract class Persons{
public abstract void eat();
}
class Child extends Persons{
@Override
public void eat() {
System.out.println("孩子!吃飯了");
}

}
interface A{
public void a();
}