class Animal
{
public int id;
public String name;
public int age;
public int weight;
public Animal(int id, String name, int age, int weight) {
this.id = id;
this.name = name;
this.age = age;
this.weight = weight;
}
//這裡省略get set方法
public void sayHello()
{
System.out.println("hello");
}
public void eat()
{
System.out.println("I'm eating");
}
public void sing()
{
System.out.println("sing");
}
}class Dog extends Animal//繼承animal
{
public Dog(int id, String name, int age, int weight) {
super(id, name, age, weight);//調用父類構造方法
}
}
class Cat extends Animal{
public Cat(int id, String name, int age, int weight) {
super(id, name, age, weight);//調用父類構造方法
}
}
class Chicken extends Animal{
public Chicken(int id, String name, int age, int weight) {
super(id, name, age, weight);//調用父類構造方法
}
//雞下蛋
public void layEggs()
{
System.out.println("我是老母雞下蛋啦，咯噠咯！咯噠咯！");
}
}
各自的類繼承Animal後可以直接使用Animal類的屬性和方法而不需要重複編寫，各個類如果有自己的方法也可很容易地拓展。上述代碼中你需要注意extends就是用來實現繼承的。繼承的分類繼承分為單繼承和多繼承，Java語言只支持類的單繼承，但可以通過實現接口的方式達到多繼承的目的。我們先用一張表概述一下兩者的區別，然後再展開講解。定義
優缺點
優點：在類層次結構上比較清晰
缺點：結構的豐富度有時不能滿足使用需求多繼承（Java不支持，但可以用其它方式滿足多繼承使用需求）
單繼承，是一個子類只擁有一個父類，如我們上面講過的Animal類和它的子類。單繼承在類層次結構上比較清晰，但缺點是結構的豐富度有時不能滿足使用需求。多繼承，是一個子類擁有多個直接的父類。這樣做的好處是子類擁有所有父類的特徵，子類的豐富度很高，但是缺點就是容易造成混亂。下圖為一個混亂的例子。Java雖然不支持多繼承，但是Java有三種實現多繼承效果的方式，分別是內部類、多層繼承和實現接口。內部類可以繼承一個與外部類無關的類，保證了內部類的獨立性，正是基於這一點，可以達到多繼承的效果。多層繼承：子類繼承父類，父類如果還繼承其他的類，那麼這就叫多層繼承。這樣子類就會擁有所有被繼承類的屬性和方法。實現接口無疑是滿足多繼承使用需求的最好方式，一個類可以實現多個接口滿足自己在豐富性和複雜環境的使用需求。類和接口相比，類就是一個實體，有屬性和方法，而接口更傾向於一組方法。舉個例子，就拿鬥羅大陸的唐三來看，他存在的繼承關係可能是這樣的：如何實現繼承實現繼承除了上面用到的extends外，還可以用implements這個關鍵字實現。下面，讓我給你逐一講解一下。在Java中，類的繼承是單一繼承，也就是說一個子類只能擁有一個父類，所以extends只能繼承一個類。其使用語法為：class Animal{} //定義Animal類
class Dog extends Animal{} //Dog類繼承Animal類
子類繼承父類後，就擁有父類的非私有的屬性和方法。如果不明白，請看這個案例，在IDEA下創建一個項目，創建一個test類做測試，分別創建Animal類和Dog類，Animal作為父類寫一個sayHello()方法，Dog類繼承Animal類之後就可以調用sayHello()方法。具體代碼為：class Animal {
public void sayHello()//父類的方法
{
System.out.println("hello,everybody");
}
}
class Dog extends Animal//繼承animal
{ }
public class test {
public static void main(String[] args) {
Dog dog=new Dog();
dog.sayHello();
}
}
點擊運行的時候Dog子類可以直接使用Animal父類的方法。使用implements 關鍵字可以變相使Java擁有多繼承的特性，使用範圍為類實現接口的情況，一個類可以實現多個接口(接口與接口之間用逗號分開)。Java接口是一系列方法的聲明，一個接口中沒有方法的具體實現 。子類實現接口的時候必須重寫接口中的方法。我們來看一個案例，創建一個test2類做測試，分別創建doA接口和doB接口，doA接口聲明sayHello()方法，doB接口聲明eat()方法，創建Cat2類實現doA和doB接口，並且在類中需要重寫sayHello()方法和eat()方法。具體代碼為：interface doA{
void sayHello();
}
interface doB{
void eat();
//以下會報錯 接口中的方法不能具體定義只能聲明
//public void eat(){System.out.println("eating");}
}
class Cat2 implements doA,doB{
@Override//必須重寫接口內的方法
public void sayHello() {
System.out.println("hello!");
}
@Override
public void eat() {
System.out.println("I'm eating");
}
}
public class test2 {
public static void main(String[] args) {
Cat2 cat=new Cat2();
cat.sayHello();
cat.eat();
}
}
Cat類實現doA和doB接口的時候，需要實現其聲明的方法，點擊運行結果如下，這就是一個類實現接口的簡單案例：繼承的特點繼承的主要內容就是子類繼承父類，並重寫父類的方法。使用子類的屬性或方法時候，首先要創建一個對象，而對象通過構造方法去創建，在構造方法中我們可能會調用子父類的一些屬性和方法，所以就需要提前掌握this和super關鍵字。創建完這個對象之後，在調用重寫父類的方法，並區別重寫和重載的區別。所以本節根據this、super關鍵字—>構造函數—>方法重寫—>方法重載的順序進行講解。this和super關鍵字this和super關鍵字是繼承中非常重要的知識點，分別表示當前對象的引用和父類對象的引用，兩者有很大相似又有一些區別。this.屬性 // 調用成員變量，要區別成員變量和局部變量
this.() // 調用本類的某個方法
this() // 表示調用本類構造方法super.屬性 // 表示父類對象中的成員變量
super.方法() // 表示父類對象中定義的方法
super() // 表示調用父類構造方法
此外，this和super關鍵字只能出現在非static修飾的代碼中。this()和super()都只能在構造方法的第一行出現，如果使用this()表示調用當前類的其他構造方法，使用super()表示調用父類的某個構造方法，所以兩者只能根據自己使用需求選擇其一。class D1{
public D1() {}//無參構造
public void sayHello() {
System.out.println("hello");
}
}
class D2 extends D1{
public String name;
public D2(){
super();//調用父類構造方法
this.name="BigSai";//給當前類成員變量賦值
}
@Override
public void sayHello() {
System.out.println("hello，我是"+this.name);
}
public void test()
{
super.sayHello();//調用父類方法
this.sayHello();//調用當前類其他方法
}
}
public class test8 {
public static void main(String[] args) {
D2 d2=new D2();
d2.test();
}
}
構造方法構造方法是一種特殊的方法，它是一個與類同名的方法。對象的創建就通過構造方法來完成，其主要的功能是完成對象的初始化。但在繼承中構造方法是一種比較特殊的方法（比如不能繼承），所以要了解和學習在繼承中構造方法的規則和要求。構造方法可分為有參構造和無參構造，這個可以根據自己的使用需求合理設置構造方法。但繼承中的構造方法有以下幾點需要注意：因為構造方法語法是與類同名，而繼承則不更改方法名，如果子類繼承父類的構造方法，那明顯與構造方法的語法衝突了。比如Father類的構造方法名為Father()，Son類如果繼承Father類的構造方法Father()，那就和構造方法定義：構造方法與類同名衝突了，所以在子類中不能繼承父類的構造方法，但子類會調用父類的構造方法。Java虛擬機構造子類對象前會先構造父類對象，父類對象構造完成之後再來構造子類特有的屬性，這被稱為內存疊加。而Java虛擬機構造父類對象會執行父類的構造方法，所以子類構造方法必須調用super()即父類的構造方法。就比如一個簡單的繼承案例應該這麼寫：class A{
public String name;
public A() {//無參構造
}
public A (String name){//有參構造
}
}
class B extends A{
public B() {//無參構造
super();
}
public B(String name) {//有參構造
//super();
super(name);
}
}
如果子類的構造方法中沒有顯示地調用父類構造方法，則系統默認調用父類無參數的構造方法。你可能有時候在寫繼承的時候子類並沒有使用super()調用，程序依然沒問題，其實這樣是為了節省代碼，系統執行時會自動添加父類的無參構造方式，如果不信的話我們對上面的類稍作修改執行：image-20201026201029796方法重寫(Override)方法重寫也就是子類中出現和父類中一模一樣的方法(包括返回值類型，方法名，參數列表)，它建立在繼承的基礎上。你可以理解為方法的外殼不變，但是核心內容重寫。class E1{
public void doA(int a){
System.out.println("這是父類的方法");
}
}
class E2 extends E1{
@Override
public void doA(int a) {
System.out.println("我重寫父類方法，這是子類的方法");
}
}
其中@Override註解顯示聲明該方法為註解方法，可以幫你檢查重寫方法的語法正確性，當然如果不加也是可以的，但建議加上。重寫的方法和父類的要一致(包括返回值類型、方法名、參數列表)方法重寫只存在於子類和父類之間，同一個類中只能重載子類可以定義於父類的靜態方法同名的靜態方法，以便在子類中隱藏父類的靜態方法（滿足重寫約束）父類的抽象方法可以被子類通過兩種途徑重寫（即實現和重寫）當然，這些規則可能涉及一些修飾符，在第三關中會詳細介紹。方法重載(Overload)如果有兩個方法的方法名相同，但參數不一致，那麼可以說一個方法是另一個方法的重載。方法重載規則如下：被重載的方法必須改變參數列表(參數個數或類型或順序不一樣)重載可以通常理解為完成同一個事情的方法名相同，但是參數列表不同其他條件也可能不同。一個簡單的方法重載的例子，類E3中的add()方法就是一個重載方法。class E3{
public int add(int a,int b){
return a+b;
}
public double add(double a,double b) {
return a+b;
}
public int add(int a,int b,int c) {
return a+b+c;
}
}
方法重寫和方法重載名稱上容易混淆，但內容上有很大區別，下面用一個表格列出其中區別：區別點方法重寫方法重載子類的訪問修飾符範圍必須大於等於父類訪問修飾符範圍子類方法異常必須是父類方法異常或父類方法異常子異常繼承與修飾符Java修飾符的作用就是對類或類成員進行修飾或限制，每個修飾符都有自己的作用，而在繼承中可能有些特殊修飾符使得被修飾的屬性或方法不能被繼承，或者繼承需要一些其他的條件，下面就詳細介紹在繼承中一些修飾符的作用和特性。Java語言提供了很多修飾符，修飾符用來定義類、方法或者變量，通常放在語句的最前端。主要分為以下兩類：這裡訪問修飾符主要講解public，protected，default，private四種訪問控制修飾符。非訪問修飾符這裡就介紹static修飾符，final修飾符和abstract修飾符。訪問修飾符public，protected，default(無修飾詞)，private修飾符是面向對象中非常重要的知識點，而在繼承中也需要懂得各種修飾符使用規則。首先我們都知道不同的關鍵字作用域不同，四種關鍵字的作用域如下：private：Java語言中對訪問權限限制的最窄的修飾符，一般稱之為「私有的」。被其修飾的屬性以及方法只能被該類的對象訪問，其子類不能訪問，更不能允許跨包訪問。
default：(也有稱friendly)即不加任何訪問修飾符，通常稱為「默認訪問權限「或者「包訪問權限」。該模式下，只允許在同一個包中進行訪問。
protected：介於public 和 private 之間的一種訪問修飾符，一般稱之為「保護訪問權限」。被其修飾的屬性以及方法只能被類本身的方法及子類訪問，即使子類在不同的包中也可以訪問。
public：Java語言中訪問限制最寬的修飾符，一般稱之為「公共的」。被其修飾的類、屬性以及方法不僅可以跨類訪問，而且允許跨包訪問。
Java 子類重寫繼承的方法時，不可以降低方法的訪問權限，子類繼承父類的訪問修飾符作用域不能比父類小，也就是更加開放，假如父類是protected修飾的，其子類只能是protected或者public，絕對不能是default(默認的訪問範圍)或者private。所以在繼承中需要重寫的方法不能使用private修飾詞修飾。如果還是不太清楚可以看幾個小案例就很容易搞懂，寫一個A1類中用四種修飾詞實現四個方法，用子類A2繼承A1，重寫A1方法時候你就會發現父類私有方法不能重寫，非私有方法重寫使用的修飾符作用域不能變小(大於等於)。class A1 {
private void doA(){ }
void doB(){}//default
protected void doC(){}
public void doD(){}
}
class A2 extends A1{
@Override
public void doB() { }//繼承子類重寫的方法訪問修飾符權限可擴大
@Override
protected void doC() { }//繼承子類重寫的方法訪問修飾符權限可和父類一致
@Override
public void doD() { }//不可用protected或者default修飾
}
還要注意的是，繼承當中子類拋出的異常必須是父類拋出的異常或父類拋出異常的子異常。下面的一個案例四種方法測試可以發現子類方法的異常不可大於父類對應方法拋出異常的範圍。class B1{
public void doA() throws Exception{}
public void doB() throws Exception{}
public void doC() throws IOException{}
public void doD() throws IOException{}
}
class B2 extends B1{
//異常範圍和父類可以一致
@Override
public void doA() throws Exception { }
//異常範圍可以比父類更小
@Override
public void doB() throws IOException { }
//異常範圍 不可以比父類範圍更大
@Override
public void doC() throws IOException { }//不可拋出Exception等比IOException更大的異常
@Override
public void doD() throws IOException { }
}
非訪問修飾符訪問修飾符用來控制訪問權限，而非訪問修飾符每個都有各自的作用，下面針對static、final、abstract修飾符進行介紹。static 翻譯為「靜態的」，能夠與變量，方法和類一起使用，稱為靜態變量，靜態方法(也稱為類變量、類方法)。如果在一個類中使用static修飾變量或者方法的話，它們可以直接通過類訪問，不需要創建一個類的對象來訪問成員。我們在設計類的時候可能會使用靜態方法，有很多工具類比如Math，Arrays等類裡面就寫了很多靜態方法。static修飾符的規則很多，這裡僅僅介紹和Java繼承相關用法的規則：靜態方法中不存在當前對象，因而不能使用 this，當然也不能使用 super。class C1{
public int a;
public C1(){}
// public static C1(){}// 構造方法不允許被聲明為static
public static void doA() {}
public static void doB() {}
}
class C2 extends C1{
public static void doC()//靜態方法中不存在當前對象，因而不能使用this和super。
{
//System.out.println(super.a);
}
public static void doA(){}//靜態方法能被靜態方法重寫
// public void doB(){}//靜態方法不能被非靜態方法重寫
}
final 表示"最後的、最終的"含義，變量一旦賦值後，不能被重新賦值。被 final 修飾的實例變量必須顯式指定初始值(即不能只聲明)。final 修飾符通常和 static 修飾符一起使用來創建類常量。父類中的 final 方法可以被子類繼承，但是不能被子類重寫。聲明 final 方法的主要目的是防止該方法的內容被修改。final 類不能被繼承，沒有類能夠繼承 final 類的任何特性。所以無論是變量、方法還是類被final修飾之後，都有代表最終、最後的意思。內容無法被修改。abstract 英文名為「抽象的」，主要用來修飾類和方法，稱為抽象類和抽象方法。抽象方法：有很多不同類的方法是相似的，但是具體內容又不太一樣，所以我們只能抽取他的聲明，沒有具體的方法體，即抽象方法可以表達概念但無法具體實現。抽象類：有抽象方法的類必須是抽象類，抽象類可以表達概念但是無法構造實體的類。抽象類和抽象方法內容和規則比較多。這裡只提及一些和繼承有關的用法和規則：抽象類也是類，如果一個類繼承於抽象類，就不能繼承於其他的（類或抽象類）子類可以繼承於抽象類，但是一定要實現父類們所有abstract的方法。如果不能完全實現，那么子類也必須被定義為抽象類比如我們可以這樣設計一個People抽象類以及一個抽象方法，在子類中具體完成：abstract class People{
public abstract void sayHello();//抽象方法
}
class Chinese extends People{
@Override
public void sayHello() {//實現抽象方法
System.out.println("你好");
}
}
class Japanese extends People{
@Override
public void sayHello() {//實現抽象方法
System.out.println("口你七哇");
}
}
class American extends People{
@Override
public void sayHello() {//實現抽象方法
System.out.println("hello");
}
}
Object類和轉型提到Java繼承，不得不提及所有類的根類：Object(java.lang.Object)類，如果一個類沒有顯式聲明它的父類（即沒有寫extends xx），那麼默認這個類的父類就是Object類，任何類都可以使用Object類的方法，創建的類也可和Object進行向上、向下轉型，所以Object類是掌握和理解繼承所必須的知識點。而Java向上和向下轉型在Java中運用很多，也是建立在繼承的基礎上，所以Java轉型也是掌握和理解繼承所必須的知識點。Object類概述Object是類層次結構的根類，所有的類都隱式的繼承自Object類。
Object是java所有類的父類，是整個類繼承結構的頂端，也是最抽象的一個類。像toString()、equals()、hashCode()、wait()、notify()、getClass()等都是Object的方法。你以後可能會經常碰到，但其中遇到更多的就是toString()方法和equals()方法，我們經常需要重寫這兩種方法滿足我們的使用需求。**toString()**方法表示返回該對象的字符串，由於各個對象構造不同所以需要重寫，如果不重寫的話默認返回類名@hashCode格式。如果重寫toString()方法後直接調用toString()方法就可以返回我們自定義的該類轉成字符串類型的內容輸出，而不需要每次都手動的拼湊成字符串內容輸出，大大簡化輸出操作。**equals()方法主要比較兩個對象是否相等，因為對象的相等不一定非要嚴格要求兩個對象地址上的相同，有時內容上的相同我們就會認為它相等，比如String 類就重寫了euqals()**方法，通過字符串的內容比較是否相等。向上轉型向上轉型 : 通過子類對象(小範圍)實例化父類對象(大範圍)，這種屬於自動轉換。用一張圖就能很好地表示向上轉型的邏輯：父類引用變量指向子類對象後，只能使用父類已聲明的方法，但方法如果被重寫會執行子類的方法，如果方法未被重寫那麼將執行父類的方法。向下轉型向下轉型 : 通過父類對象(大範圍)實例化子類對象(小範圍)，在書寫上父類對象需要加括號()強制轉換為子類類型。但父類引用變量實際引用必須是子類對象才能成功轉型，這裡也用一張圖就能很好表示向上轉型的邏輯：子類引用變量指向父類引用變量指向的對象後(一個Son()對象)，就完成向下轉型，就可以調用一些子類特有而父類沒有的方法 。Object object=new Integer(666);//向上轉型
Integer i=(Integer)object;//向下轉型Object->Integer，object的實質還是指向Integer
String str=(String)object;//錯誤的向下轉型，雖然編譯器不會報錯但是運行會報錯
子父類初始化順序總的來說，就是靜態>非靜態，父類>子類，非構造函數>構造函數。同一類別（例如普通變量和普通代碼塊）成員變量和代碼塊執行從前到後，需要注意邏輯。這個也不難理解，靜態變量也稱類變量，可以看成一個全局變量，靜態成員變量和靜態代碼塊在類加載的時候就初始化，而非靜態變量和代碼塊在對象創建的時候初始化。所以靜態快於非靜態初始化。而在創建子類對象的時候需要先創建父類對象，所以父類優先於子類。而在調用構造函數的時候，是對成員變量進行一些初始化操作，所以普通成員變量和代碼塊優於構造函數執行。至於更深層次為什麼這個順序，就要更深入了解JVM執行流程啦。下面一個測試代碼為：class Father{
public Father() {
System.out.println(++b1+"父類構造方法");
}//父類構造方法 第四
static int a1=0;//父類static 第一 注意順序
static {
System.out.println(++a1+"父類static");
}
int b1=a1;//父類成員變量和代碼塊 第三
{
System.out.println(++b1+"父類代碼塊");
}
}
class Son extends Father{
public Son() {
System.out.println(++b2+"子類構造方法");
}//子類構造方法 第六
static {//子類static第二步
System.out.println(++a1+"子類static");
}
int b2=b1;//子類成員變量和代碼塊 第五
{
System.out.println(++b2 + "子類代碼塊");
}
}
public class test9 {
public static void main(String[] args) {
Son son=new Son();
}
}
結語好啦，本次繼承就介紹到這裡啦，Java面向對象三大特徵之一繼承——優秀的你已經掌握。再看看Java面向對象三大特性：封裝、繼承、多態。最後問你能大致了解它們的特徵嘛？封裝：是對類的封裝，封裝是對類的屬性和方法進行封裝，只對外暴露方法而不暴露具體使用細節，所以我們一般設計類成員變量時候大多設為私有而通過一些get、set方法去讀寫。繼承：子類繼承父類，即「子承父業」，子類擁有父類除私有的所有屬性和方法，自己還能在此基礎上拓展自己新的屬性和方法。主要目的是復用代碼。多態：多態是同一個行為具有多個不同表現形式或形態的能力。即一個父類可能有若干子類，各子類實現父類方法有多種多樣，調用父類方法時，父類引用變量指向不同子類實例而執行不同方法，這就是所謂父類方法是多態的。