?Java繼承：

繼承的概念：

在Java中，繼承（inheritance）是面向?qū)ο缶幊痰囊粋€重要概念，它允許一個類（子類）繼承另一個類（父類）的屬性和方法。通過繼承，子類可以擁有父類的屬性和方法，并且可以擴展或修改這些屬性和方法，實現(xiàn)代碼的重用和擴展。

父類怎么形成的？

當(dāng)我們定義了多個類，發(fā)現(xiàn)每個類中的屬性重復(fù)，我們就可以把這些重復(fù)屬性抽取出來，形成父類，其它的類直接繼承這個父類即可。

繼承其實更貼合于設(shè)計這方面的感覺，因為我們寫代碼的時候，不可能寫了好多類之后，然后發(fā)現(xiàn)好多類的屬性重復(fù)，再去抽取，這樣就很慢，而是在設(shè)計的時候就提前想好。

在Java中，使用關(guān)鍵字extends來實現(xiàn)繼承，語法如下：?

class 子類名 extends 父類名 {// 子類的屬性和方法
}

繼承的基本使用：

1：首先定義一個父類（people）

package Testextends;public class People {String name;int age;public void work(){System.out.println("工作");}private void eat(){System.out.println("吃飯");}
}

2：定義若干子類（teacher，manager）

package Testextends;public class Manager extends People{
}

package Testextends;public class Teacher extends People{}

同時繼承父類people，不過在子類中不寫任何代碼

3：在main方法中創(chuàng)建對象

package Testextends;public class Test01 {public static void main(String[] args) {Teacher teacher = new Teacher();}
}

如圖，通過java的反射機制，我們就可以看出teacher繼承了people的方法，

不過我們仔細看，私有方法eat并沒有顯示出來。

說明子類使用不了父類的私有方法和變量，只能使用非私有方法和變量

繼承中成員變量的使用：

?1：繼承中成員變量不重名：

首先我們需要明白一個規(guī)則，我創(chuàng)建了一個對象，如果我想調(diào)用這個對象里面的屬性，我先是在這個對象的范圍里面查找，找不到，再去查父類

明白了這個規(guī)則

我們看下面的代碼：

在子類中創(chuàng)建一個變量zi = 10

package Testextends;public class Teacher extends People{int zi = 10;
}

在父類中創(chuàng)建一個變量fu = 100?

package Testextends;public class People {String name;int age;private int gender;int fu = 100;public void work(){System.out.println("工作");}private void eat(){System.out.println("吃飯");}
}

在主函數(shù)中創(chuàng)建父類對象?

?仔細看上面的代碼：

父類調(diào)用子類的特有變量（zi）報錯，這也印證了上面的規(guī)則。

2：繼承中成員變量重名：

重名的話，很好理解，就是直接覆蓋

?繼承中成員方法的使用：

其實和上面的差不多，如果不重名，則這個方法就算子類的特有方法

如果重名，那這個就算子類重寫了父類的方法，直接覆蓋掉了

注意點：

如果這個時候來一行代碼：

使用父類來創(chuàng)建一個子類的對象

People people1 = new Teacher();

這個時候的成員變量和成員方法的結(jié)果就需要特別注意了：

package Testextends;public class Teacher extends People{int age = 18;public void work(){System.out.println("教師工作");}
}

package Testextends;public class People {String name;int age = 100;private int gender;public void work(){System.out.println("工作");}private void eat(){System.out.println("吃飯");}
}

        People people1 = new Teacher();System.out.println(people1.age);people.work();teacher.work();people1.work();

輸出結(jié)果：

100
工作
教師工作
教師工作

我們可以發(fā)現(xiàn)，對于成員變量來說，age的值還是父類的值，對于成員方法來說，work方法的內(nèi)容卻變成了子類重寫過的內(nèi)容

所以我們可以總結(jié)：

?繼承中：

成員變量訪問特點：看等號左邊是誰，先調(diào)用誰中的成員變量

如上面People people1 = new Teacher();等號左邊是父類（people），那成員變量的值就是左邊

成員方法訪問特點：看new的是誰，先調(diào)用誰中的方法

還是上面這個例子，調(diào)用的方法就是Teacher重寫過的方法。

方法重寫：?

方法重寫（Method Overriding）是指子類重寫（覆蓋）其父類中具有相同名稱、相同參數(shù)列表和返回類型的方法。

檢測是否為重寫方法:在該方法上寫

? @Override

方法重寫和方法重載的區(qū)別：

方法重載（Method Overloading）指的是在同一個類中可以有多個同名的方法，但這些方法的參數(shù)列表必須不同（包括參數(shù)的類型、順序或個數(shù)）。在調(diào)用這些同名方法時，編譯器會根據(jù)傳入的參數(shù)類型來確定調(diào)用哪個重載的方法。

這是方法的重載

public class OverloadExample {public void printInfo(int num) {System.out.println("Number: " + num);}public void printInfo(String str) {System.out.println("String: " + str);}public void printInfo(int num1, int num2) {System.out.println("Numbers: " + num1 + " and " + num2);}public static void main(String[] args) {OverloadExample example = new OverloadExample();example.printInfo(10); // 調(diào)用第一個printInfo方法example.printInfo("Hello"); // 調(diào)用第二個printInfo方法example.printInfo(5, 8); // 調(diào)用第三個printInfo方法}
}

這是方法的重寫：

class Animal {void sound() {System.out.println("Animal makes a sound");}
}class Dog extends Animal {@Overridevoid sound() {System.out.println("Dog barks");}
}public class Main {public static void main(String[] args) {Animal animal = new Animal();animal.sound(); // 輸出：Animal makes a soundDog dog = new Dog();dog.sound(); // 輸出：Dog barks}
}

@Override判斷此方法是否是重寫方法，如果不是就會報錯

重寫的注意事項：

?1：子類重寫父類方法，權(quán)限必須要保證大于等于父類權(quán)限，這里的權(quán)限指的是訪問權(quán)限

（子類中重寫的方法不能使用比父類中被重寫的方法更嚴(yán)格的訪問修飾符）

權(quán)限排序：public > protected > 默認（什么都不加）> private?

2：父類私有方法，構(gòu)造方法，靜態(tài)方法

私有方法不能繼承，也不能重寫

構(gòu)造方法不可以繼承，不能重寫

靜態(tài)方法可以繼承，不能重寫

3：子類重寫父類方法之后，返回值得是父類方法返回值得子類類型

重寫的使用場景:

1. 實現(xiàn)多態(tài)性：方法重寫是實現(xiàn)運行時多態(tài)性的一種重要手段。通過子類重寫父類方法，可以在運行時根據(jù)對象的實際類型來調(diào)用相應(yīng)的方法，實現(xiàn)動態(tài)綁定。

2. 修改父類方法的行為：有時候子類可能需要修改父類方法的行為或者提供更具體的實現(xiàn)。通過重寫父類方法，子類可以根據(jù)自己的需求來實現(xiàn)特定的邏輯。

3. 擴展父類方法的功能：在某些情況下，子類可能需要在父類方法的基礎(chǔ)上添加額外的邏輯或功能。通過重寫父類方法并在其中調(diào)用父類的原方法，可以實現(xiàn)邏輯的擴展。

4. 更好地適應(yīng)子類的需求：通過重寫父類方法，子類可以更好地適應(yīng)自身的特性和需求，從而提高代碼的靈活性和可維護性。

(from GPT)

super和this：

先來看一個案例：

我在這里只初始化了一個子類對象，只調(diào)用了子類的構(gòu)造方法。

可是連通父類的構(gòu)造方法一起調(diào)用了。

所以，我們可以得出：

1：new子類對象時，會先初始化父類（父類的無參構(gòu)造方法）

2：原因：

? ? ? ? 每個構(gòu)造方法的第一行，默認會有一個super（），jvm自動提供

? ? ? ? super代表父類的無參構(gòu)造

?了解了這個案例之后：

super的使用：

1：概述：代表的是父類的引用

2：使用：

????????a.調(diào)用父類的構(gòu)造方法：在子類的構(gòu)造方法中使用super關(guān)鍵字可以調(diào)用父類的構(gòu)造方法。這樣可以確保在子類對象被實例化時，父類的構(gòu)造方法也會被執(zhí)行。如果不顯式使用super關(guān)鍵字調(diào)用父類構(gòu)造方法，Java編譯器會默認插入調(diào)用父類的無參構(gòu)造方法。

????????super() -> 調(diào)用父類無參構(gòu)造

????????super(實參)->調(diào)用父類有參構(gòu)造

? ? ? ? ?b.調(diào)用父類的成員變量和方法：在子類中使用super關(guān)鍵字可以訪問調(diào)用父類的成員變量和方法

? ? ? ? super.成員變量名

? ? ? ? super.成員方法名（實參）

public class Fu {int num = 10;public Fu(){System.out.println("我是父類中的無參構(gòu)造");}public Fu(int data){System.out.println("我是父類中的有參構(gòu)造");}public void method(){System.out.println("我是父類中的method方法");}
}``````java
public class Zi extends Fu{int num = 100;public Zi(){super();//調(diào)用父類中的無參構(gòu)造System.out.println("我是子類中的無參構(gòu)造");}public Zi(int num){super(10);//調(diào)用父類的有參構(gòu)造System.out.println("我是子類中的有參構(gòu)造");}public void method(){super.method();//調(diào)用父類的method方法System.out.println("我是子類中的method方法");System.out.println(num);//子類自己的System.out.println(super.num);//調(diào)用父類的num}
}``````java
public class Test01 {public static void main(String[] args) {Zi zi = new Zi();System.out.println("============");Zi zi1 = new Zi(10);System.out.println("============");Zi zi2 = new Zi();zi2.method();}
}

this的使用：

1.this概述:代表的是當(dāng)前對象(哪個對象調(diào)用的this所在的方法,this就代表哪個對象)

當(dāng)前對象：指的是指定上下文中的實例化對象

public class MyClass {private int num;public void setNum(int num) {this.num = num; // 在這里，this表示當(dāng)前對象的引用，指正在調(diào)用setNum方法的對象}
}MyClass obj = new MyClass();
obj.setNum(10);
// 當(dāng)調(diào)用setNum方法時，this表示obj這個實例化的對象

這里面的obj就是當(dāng)前對象

2.作用:

? a.區(qū)分重名的成員變量和局部變量

? b.調(diào)用當(dāng)前對象中的成員

3.使用:

? a.調(diào)用當(dāng)前對象的構(gòu)造:在構(gòu)造中寫

? ? this():調(diào)用當(dāng)前對象的無參構(gòu)造

? ? this(實參):調(diào)用當(dāng)前對象的有參構(gòu)造

public class MyClass {private int num;public MyClass() {this(0); // 在這里，this表示當(dāng)前對象的引用，指構(gòu)造當(dāng)前對象的實例}public MyClass(int num) {this.num = num;}
}MyClass obj = new MyClass();
// 當(dāng)創(chuàng)建MyClass對象時，this表示的是正在實例化的MyClass對象

當(dāng)在主函數(shù)中實例化一個對象后，就算你調(diào)用的是一個無參構(gòu)造方法，?在無參構(gòu)造中調(diào)用了this(0)

還是會用那個有參的構(gòu)造方法實例化。

? b.調(diào)用當(dāng)前對象的成員變量:

? ? this.成員變量名

public class MyClass {int m;public void setNum(int num){this.num = num;System.out.println(this.num);}private int num;public void method(){int num = 100;System.out.println(num);System.out.println(this.num);}
}

?當(dāng)全局變量有一個和方法中的變量重名的時候（這段代碼中的num），我們就可以用this來區(qū)分全局變量和局部變量

? c.將當(dāng)前對象作為參數(shù)傳遞給其他方法：

public class MyClass {private int num;public void method() {newMethod(this); // 在這里，this表示當(dāng)前對象的引用，指調(diào)用method方法的對象}public void newMethod(MyClass obj) {// 在這里，obj參數(shù)接收到的是this所指向的對象}
}MyClass obj = new MyClass();
obj.method();
// 當(dāng)調(diào)用method方法時，this表示的是obj這個實例化的對象

4：注意點：

不管是super還是this,只要在構(gòu)造中使用,都必須在第一行,所以二者不能同時手寫出來

繼承的特點：

1.繼承只支持單繼承,不能多繼承

? public class A extends B,C{} ?-> 錯誤

2.繼承支持多層繼承

? public class A extends B{}

? public class B extends C{}

3.一個父類可以有多個子類

? public class A extends C{}

? public class B extends C{}

?繼承(為父類私有屬性賦值）

首先我們知道，父類的私有屬性，子類是沒有辦法訪問的，那這個時候如果我們還是要去修改值怎么辦呢？

兩種方法：

1：利用set賦值

其實這個就是去構(gòu)造一個javabean對象，然后通過get和set方法對這個變量進行賦值

public class Employee {private String name;private int age;public Employee() {}public Employee(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void work(){System.out.println("工作");}
}

Teacher teacher = new Teacher();teacher.setName("張三");teacher.setAge(18);System.out.println(teacher.getName()+"..."+teacher.getAge());

2：利用構(gòu)造方法賦值

在子類的構(gòu)造方法中利用super（參數(shù)）來構(gòu)造

其實利用構(gòu)造方法賦值本質(zhì)上也是利用了set方法。

public class Manager extends Employee{public Manager() {}public Manager(String name, int age) {super(name, age);}
}

Manager manager = new Manager("金蓮", 24);System.out.println(manager.getName()+"..."+manager.getAge());

繼承中的抽象類：?

首先我們設(shè)想一個場景：三角形類，正方形類，圓形類，他們中都有一個方法是求面積

根據(jù)我們之前學(xué)習(xí)的繼承，我們很容易想到將這個求面積的方法抽象出來成一個形狀類

不過我們再看，三個形狀求面積的公式不同，我們不能想之前那樣抽象成一個方法。

所以就需要我們的抽象類。

抽象類的定義：

Java中的抽象類是指不能被實例化的類，通常用于定義一些共同的方法和屬性，讓子類來實現(xiàn)具體的邏輯。抽象類通常包含抽象方法（沒有具體實現(xiàn)的方法）和非抽象方法（有具體實現(xiàn)的方法）。

?抽象類案例：

public abstract class Animal {protected String name;public Animal(String name) {this.name = name;}// 抽象方法public abstract void sound();// 非抽象方法public void sleep() {System.out.println(name + " is sleeping");}
}

在上面的例子中，Animal類是一個抽象類，包含一個抽象方法sound()和一個非抽象方法sleep()。任何繼承Animal類的子類都必須實現(xiàn)sound()方法，否則會被標(biāo)記為抽象類。

要實現(xiàn)一個繼承自抽象類的子類，需要在子類中實現(xiàn)所有的抽象方法，如下所示：

public class Dog extends Animal {public Dog(String name) {super(name);}@Overridepublic void sound() {System.out.println(name + " is barking");}
}

在這個例子中，Dog類繼承自Animal類，并且實現(xiàn)了抽象方法sound()。這樣，Dog類就可以被實例化并調(diào)用其方法了。

特點：

1. 繼承了抽象類，就必須重寫所有的抽象方法，由此我們也可以得出，抽象方法不能用private，final 或者static關(guān)鍵字來修飾，這是因為定義抽象方法的目的就是想將方法的具體實現(xiàn)延遲到子類，最終是要被子類重寫的，而private，final，static這幾個關(guān)鍵字都和“方法重寫”的目的背道而馳。
2. 擁有抽象方法的類一定是抽象類；但是抽象類不一定有抽象方法。這個如何理解，如果一個類你一開始定義為普通類，后面想用抽象方法，就會報錯，必須加上abstract，但是一開始，如果你定義了一個抽象類，你可以不寫抽象方法，后面再補也許

3. 抽象類不能被實例化，只能創(chuàng)建其非抽象子類對象 。既然抽象類不能實例化，那抽象類的構(gòu)造方法用處是什么呢？我們之前講過繼承可以為父類私有屬性賦值，同時我們也可以利用這一點

package Testextends;public class Manager extends Person{public Manager(String name, int age) {super(name, age);}
}package Testextends;public abstract class Person {String name;int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Person(String name, int age) {this.name = name;this.age = age;}
}package Testextends;public class Test01 {public static void main(String[] args) {Manager manager = new Manager("張三",18);System.out.println(manager.getName()+manager.getAge());}
}

在這個案例中，Manager繼承了抽象類Person，并且super(name, age);

就和上面那張圖一樣，將抽象類中的name和age屬性賦上了值。

Java接口：

接口的定義：

在Java中，接口（Interface）是一種抽象數(shù)據(jù)類型，它定義了一組方法的簽名，但并沒有提供方法的具體實現(xiàn)。接口可以看作是一種約定或契約，讓類來實現(xiàn)這些方法以確保特定的行為或功能。

來舉一個生活中例子把：

當(dāng)我們訂購?fù)赓u時，我們可以將食品平臺比作接口，而餐廳則是實現(xiàn)了這個接口的具體類。在這個例子中，食品平臺定義了一組規(guī)范，比如訂單方法、支付方法等，餐廳則按照這些規(guī)范實現(xiàn)了具體的行為。

接口代表食品平臺提供的服務(wù)，而餐廳作為實現(xiàn)類，提供了具體的食品和服務(wù)。我們可以通過食品平臺下單、支付等方法與不同的餐廳交互，而不需要關(guān)心具體餐廳是如何處理訂單和支付的。

這樣的設(shè)計使得我們可以更加靈活地選擇不同的餐廳進行訂餐，并且不需要知曉每個餐廳的具體細節(jié)，只需按照規(guī)范進行操作就可以了。

接口的理解（特點）：

1. 接口可以理解為一個抽象類，實現(xiàn)這個接口的類必須重寫這個接口里面的所有方法，但是接口和抽象類不同的是：接口可以實現(xiàn)多實現(xiàn)，這就和之前的繼承不同了，也算彌補了java不能多繼承的缺點，子類可以繼承一個父類的同時實現(xiàn)一個或者多個接口
2. 接口里面的方法默認都是abstract的，在JDK8中添加了default和static，在JDK9中添加了private，如果在接口中不去特意定義default，private和static這三個關(guān)鍵字的話，那是不是接口中的方法默認都是abstract
3. 接口中的變量默認都是靜態(tài)常量，即使用?public static final?修飾的常量。
4. 同時接口也不能被實例化，都只能通過子類來new

接口的使用：

關(guān)鍵字:
? ?a.interface 接口
? ? ? public interface 接口名{}
? ?
? b.implements 實現(xiàn)
? ? ? 實現(xiàn)類 implements 接口名{}

第一個案例：最簡單的一個接口的使用

public interface USB {public abstract void open();public abstract void close();
}public class Mouse implements USB{@Overridepublic void open() {System.out.println("鼠標(biāo)打開");}@Overridepublic void close() {System.out.println("鼠標(biāo)關(guān)閉");}
}public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();mouse.close();}
}

第二個案例：定義了默認方法：

public interface Greetable {// 默認方法default void greet() {System.out.println("Hello, nice to meet you!");}
}public class Person implements Greetable {public static void main(String[] args) {Person p = new Person();p.greet(); // 調(diào)用接口中的默認方法}
}

對于默認方法，需要通過接口的實例來調(diào)用

第三個案例：定義了靜態(tài)方法：

public interface Calculator {// 靜態(tài)方法static int add(int a, int b) {return a + b;}
}public class TestCalculator {public static void main(String[] args) {int sum = Calculator.add(10, 20); // 調(diào)用接口中的靜態(tài)方法System.out.println("Sum: " + sum);}
}

靜態(tài)方法直接用接口名就可以調(diào)用

第四個案例：定義了私有方法

public interface Calculation {default int add(int a, int b) {return performAddition(a, b); // 調(diào)用私有方法}private int performAddition(int a, int b) {return a + b;}
}public class TestCalculation implements Calculation {public static void main(String[] args) {TestCalculation calc = new TestCalculation();int sum = calc.add(10, 20); // 調(diào)用接口中的默認方法System.out.println("Sum: " + sum);}
}

在這個例子中，接口?Calculation?中定義了一個默認方法?add，并在該默認方法中調(diào)用了一個私有方法?performAddition。私有方法被用來實現(xiàn)具體的邏輯，但只能在接口內(nèi)部使用，外部無法訪問。

Java多態(tài)：

多態(tài)是指同一個方法調(diào)用，在不同對象上有不同的表現(xiàn)形式。

這樣講其實蠻難理解：

舉一個例子：

class Animal {void makeSound() {System.out.println("Animal makes a sound");}
}class Dog extends Animal {void makeSound() {System.out.println("Dog barks");}void lookDoor(){System.out.println("Dog lookDoor");}
}class Cat extends Animal {void makeSound() {System.out.println("Cat meows");}
}public class Main {public static void main(String[] args) {Animal animal = new Dog(); // 編譯時類型為Animal，運行時類型為Doganimal.makeSound(); // 運行時調(diào)用Dog類的makeSound方法Animal animal = new Cat(); // 運行時類型為Catanimal.makeSound(); // 運行時調(diào)用Cat類的makeSound方法}
}

首先創(chuàng)建一個動物類Animal類，狗dog類，貓cat類

dog和cat同時繼承Animal，并且重寫了父類的makeSound，父類引用指向子類對象

這是我們就會發(fā)現(xiàn)控制臺輸出了:

Dog barks

Cat meows

這就是多態(tài)，相同的引用到不同的對象上，有不同的表現(xiàn)形式。

注意點：由父類引用指向子類對象創(chuàng)建出來的對象不能調(diào)用自己的特有方法

比如用Animal animal = new Dog();創(chuàng)建了一個對象animal，這個animal就不能調(diào)用Dog類中特有的方法lookDoor

?多態(tài)的前提：

1. ? 必須有子父類繼承或者接口實現(xiàn)關(guān)系
2. ? 必須有方法的重寫(沒有重寫,多態(tài)沒有意義),多態(tài)主要玩兒的是重寫方法
3. ? new對象:父類引用指向子類對象，Fu fu = new Zi() -> 理解為大類型接收了一個小類型的數(shù)據(jù) ->比如 ?double b = 10
4. ? 多態(tài)下不能直接調(diào)用子類特有功能（這一點和繼承一樣）

多態(tài)的條件下成員的訪問特點

?看new的是誰,先調(diào)用誰中的成員方法,子類沒有,找父類

這一句話和繼承的時候?qū)W的是一樣的

比如：

成員變量的使用：

public class Fu {int num = 1000;
}
public class Zi extends Fu{int num = 100;
}
public class Test01 {public static void main(String[] args) {Fu fu = new Zi();System.out.println(fu.num);}
}

new的是子類，所以輸出的就是子類的成員變量

成員方法的使用：

public class Fu {int num = 1000;public void method(){System.out.println("我是父類中的method方法");}
}public class Zi extends Fu{int num = 100;public void method(){System.out.println("我是子類中的method方法");}
}public class Test01 {public static void main(String[] args) {Fu fu = new Zi();System.out.println(fu.num);//父類中的numfu.method();//子類中重寫的method方法}
}

這里也是同理。

多態(tài)的優(yōu)點：

要講多態(tài)的優(yōu)點，我們先來舉個例子吧，這個例子的目的其實也不是說能說明多態(tài)的優(yōu)點，就是做一個對比，已多態(tài)的方式創(chuàng)建對象和普通的方式創(chuàng)建對象

問題描述:

? 如果使用原始方式new對象(等號左右兩邊一樣),既能調(diào)用重寫的,還能調(diào)用繼承的,還能調(diào)用自己特有的成員
? 但是多態(tài)方式new對象,只能調(diào)用重寫的,不能直接調(diào)用子類特有的成員,那為啥還要用多態(tài)呢?

既然我們學(xué)了，那肯定就有學(xué)的用處：

先來看一下優(yōu)缺點吧：

多態(tài)方式和原始方式new對象的優(yōu)缺點:

? 原始方式:
? ? a.優(yōu)點:既能調(diào)用重寫的,還能調(diào)用父類非私有的,還能調(diào)用自己特有的
? ? b.缺點:擴展性差
? ? ? ??
? 多態(tài)方式:
? ? a.優(yōu)點:擴展性強
? ? b.缺點:不能直接調(diào)用子類特有功能? ? ? ?

這樣講肯定太寬泛了：

具體的代碼案例：

package Testduotai;class Animal {void makeSound() {System.out.println("Animal makes a sound");}
}class Dog extends Animal {void makeSound() {System.out.println("Dog barks");}
}class Cat extends Animal {void makeSound() {System.out.println("Cat meows");}
}
public class Test01 {public static void main(String[] args) {//不用多態(tài)，用普通的方法Dog dog = new Dog();method01(dog);Cat cat = new Cat();method02(cat);}public static void method01(Dog dog){dog.makeSound();}public static void method02(Cat cat){cat.makeSound();}
}

這段代碼是用普通的創(chuàng)建對象的方式：

這段代碼中：method01 和method02這兩個方法的參數(shù)分別是dog和cat，

因為Dog和Cat兩個對象之間沒有什么關(guān)系，所以，我們需要建兩個方法，方法的參數(shù)分別是dog和cat

但是如果我們用了多態(tài)的創(chuàng)建對象的方式：

public static void main(String[] args) {//不用多態(tài)，用普通的方法Dog dog = new Dog();method01(dog);Cat cat = new Cat();method02(cat);//用多態(tài)的方式Animal animal = new Dog();method(animal);Animal animal1 = new Cat();method(animal1);}public static void method(Animal animal){animal.makeSound();}

我們用一個方法就可以實現(xiàn)上面的功能，并且如果動物的種類多了，用這種方式可以更好的實現(xiàn)代碼的復(fù)用性

總結(jié)起來就是：

形參傳遞父類類型,調(diào)用此方法父類類型可以接收任意它的子類對象
傳遞哪個子類對象,就指向哪個子類對象,就調(diào)用哪個子類對象重寫的方法

?

多態(tài)中的轉(zhuǎn)型

一：向上轉(zhuǎn)型：

????????1.父類引用指向子類對象
? ????????好比是: double b = 1;

二：向下轉(zhuǎn)型：

????????1.向下轉(zhuǎn)型:好比強轉(zhuǎn),將大類型強制轉(zhuǎn)成小類型
????????2.表現(xiàn)方式:
? ????????父類類型 對象名1 = new 子類對象() -> 向上轉(zhuǎn)型 -> double b = 1
? ????????子類類型 對象名2 = (子類類型)對象名1 -> 向下轉(zhuǎn)型 -> int i = (int)b
????????3.想要調(diào)用子類特有功能,我們就需要向下轉(zhuǎn)型?

具體講一下第三點調(diào)用子類特有功能：

看代碼：

public abstract class Animal {public abstract void eat();
}
public class Cat extends Animal {@Overridepublic void eat() {System.out.println("貓吃魚");}//特有方法public void catchMouse(){System.out.println("貓會捉老鼠");}
}
public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗啃骨頭");}//特有方法public void lookDoor(){System.out.println("狗會看門");}
}
public class Test01 {public static void main(String[] args) {//多態(tài)new對象  向上轉(zhuǎn)型Animal animal = new Dog();animal.eat();//dog重寫的//animal.lookDoor();//多態(tài)不能調(diào)用子類特有功能//向下轉(zhuǎn)型Dog dog = (Dog) animal;dog.eat();dog.lookDoor();}
}

這段代碼中，貓和狗都有一個自己特定的方法捉老鼠和看門，

父類對象animal如果想要調(diào)用這兩個方法，就需要向下轉(zhuǎn)型

轉(zhuǎn)型時會遇到的問題：

如果等號左右兩邊類型不一致,會出現(xiàn)類型轉(zhuǎn)換異常(ClassCastException)

在我們進行類型轉(zhuǎn)換的時候難免會發(fā)生這個異常

比如我們?nèi)フ{(diào)用一個別人寫好的方法，我們不知道類型，我們直接進行強轉(zhuǎn)，就很容易錯

解決辦法：

? 在向下轉(zhuǎn)型之前,先判斷類型 關(guān)鍵字：instanceof
? 判斷結(jié)果是boolean型
? 對象名 instanceof 類型 -> 判斷的是關(guān)鍵字前面的對象是否符合關(guān)鍵字后面的類型

具體看代碼：

public static void method(Animal animal){if(animal instanceof Dog){Dog dog = (Dog) animal;dog.lookDoor();}if(animal instanceof Cat){Cat cat = (Cat) animal;cat.catchMouse();}}

判斷傳進來的類型再進行輸出。