Java繼承使用實例分析

本篇內容介紹了“Java繼承使用實例分析”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

繼承

繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

繼承的作用：通過繼承可以快速創建新的類，實現代碼的重用，提高程序的可維護性，節省大量創建新類的時間，提高開發效率和開發質量。

在 Java 中通過 extends 關鍵字可以申明一個類是從另外一個類繼承而來的，一般形式如下：

class 父類{
    ...       //成員變量、成員方法
}
class 子類 extends 父類{
    ...       //類體
}

例如：

class teacher{             //聲明一個teacher類為父類
    String name;             //定義父類的成員變量name、age   
    int age;
    void show(){           //定義父類成員方法，將成員變量輸出
        System.out.println(name);       
        System.out.println(age); 
    }
}
class Student extends teacher {     //聲明一個Student類為子類并繼承父類
}
public class myfirst {
    public static void main(String[] args) {
    System.out.println("學生");
    Student student=new Student();     //聲明一個Student類的實例對象student
    student.name="Tom";                //子類調用父類的成員變量name并賦值
    student.age=19;                    //子類調用父類的成員變量age并賦值
    student.show();                    //子類調用父類的成員方法show
    }
}

運行結果為：

學生
Tom
19

注意：

• 子類不能選擇性繼承父類；

• Java不支持多重繼承，但一個類可以實現多個接口，從而克服單繼承的缺點；

• 構造方法不會被子類繼承，但可以從子類中調用父類的構造方法。

繼承的優點

• 繼承過來的字段和方法，可以像任何其他字段和方法一樣被直接使用；

• 在子類中可以聲明一個與父類中同名的新字段或靜態方法，從而“隱藏”父類中的字段或方法；

• 可以在子類中聲明一個在父類中沒有的新字段和方法；

• 可以在子類中編寫一個父類當中具有相同名的新實例方法，這稱為“方法重寫”或“方法覆蓋”；

• 可以在子類中編寫一個調用父類構造方法的子類構造方法，既可以隱式地實現，也可以通過使用關鍵字super來實現。

重寫和隱藏父類方法

子類繼承了父類中的所有成員及方法，但在某種情況下，子類中該方法所表示的行為與其父類中該方法所表示的行為不完全相同，例如，在父類語言中定義了說話這個方法，而在子類中說話的方法是不同的：外國人說英文，中國人說中文，這時我們就需要重寫或隱藏父類的該方法。

重寫父類中的方法

當一個子類中一個實例方法具有與其父類中的一個實例方法相同的簽名（指名稱、參數個數和類型）和返回值時，稱子類中的方法“重寫”了父類的方法。例如：

class A{
    public void sayHello() {                      //輸出英文歡迎
        System.out.println("Hello,Welcome to Java!!!");
    }
    public void sayBye() {
        System.out.println("GoodBye,everyone");
    }
}
class B extends A {           
    public void sayHello() {                      //輸出中文歡迎  
        System.out.println("大家好，歡迎學習Java！！！");
    }
}
public class myfirst {
    public static void main(String[] args) {
    B b=new B();                                //創建子類B的一個實例對象，使用默認構造方法
    b.sayHello();                               //調用子類中重寫的方法
    b.sayBye();                                 //調用父類中的方法
    }
}

運行結果為：

大家好，歡迎學習Java！！！
GoodBye,everyone

注意：重寫的方法具有與其所重寫的方法相同的名稱、參數數量、類型和返回值。

隱藏父類中的方法

如果一個子類定義了一個靜態類方法，而這個類方法與其父類的一個類方法具有相同的簽名（指名稱、參數格式和類型）和返回值，則稱在子類中的這個類方法“隱藏”了父類中的該類方法。

• 當調用被重寫的方法時，調用的版本是子類的方法；

• 當調用被隱藏的方法時，調用的版本取決于是從父類中調用還是從子類中調用。

class A{
    public static void sayHello() {             //靜態類方法
        System.out.println("大家好，這是A的靜態類方法");
    }
    public void sayHello2() {                   //實例方法
        System.out.println("大家好，這是A中的實例方法");
    }
}
class B extends A {    
    public static void sayHello() {             //靜態類方法
        System.out.println("大家好，這是B的靜態類方法");
    }
    public void sayHello2() {                   //實例方法
        System.out.println("大家好，這是B的實例方法");
    }
}
public class myfirst {
    public static void main(String[] args) {
        B b=new B();                           //創建B類的實例對象b
        A a=b;                                 //隱式對象類型轉換
        A.sayHello();                          //調用A類的靜態類方法
        a.sayHello();                          //調用a對象的靜態類方法
        B.sayHello();                          //調用B類的靜態方法
        a.sayHello2();                         //調用a對象的實例方法
        b.sayHello2();                         //調用b對象的的實例方法
        A a2=new A();                          //創建A類的實例對象a2
        a2.sayHello2();                        //調用a2對象的實現方法
    }
}

運行結果為：

大家好，這是A的靜態類方法
大家好，這是A的靜態類方法
大家好，這是B的靜態類方法
大家好，這是B的實例方法
大家好，這是B的實例方法
大家好，這是A中的實例方法

可以看出，得到調用的隱藏方法是父類中的方法，而得到調用的重寫方法是子類中的方法。

方法重寫和隱藏后的修飾符

在子類中被重寫的方法，其訪問權限允許大于但不允許小于被其重寫的方法，例如：父類中一個受保護的實例方法(protected)在子類中可以是公共的(public)的，但不可以是私有的(private)。如果一個方法在父類中是static方法，那么在子類也必須是static方法；如果一個方法在父類中是實例方法，那么在子類中也必須是實例方法。

子類訪問父類私有成員

子類繼承其父類的所有public和protected成員，但不能繼承其父類的private成員。那么如何在子類中訪問到父類中的字段呢，我們可以在父類中提供用來訪問其私有字段的public或protected方法，子類使用這些方法來訪問相應的字段。例如：

class A{                     //父類A
    private int value=10;    //聲明一個私有變量value并賦值為10
    public int getvalue() {  //聲明一個公有成員方法getvalue，返回value
        return value;
    }
}
class B extends A{           //A的子類B
}
public class myfirst {    
    public static void main(String[] args) {
      B b=new B();           //創建子類B的一個實例對象
      System.out.println("子類通過父類提供的公共接口訪問A中的私有字段value:"+b.getvalue());
    }
}

運行結果為：

子類通過父類提供的公共接口訪問A中的私有字段value:10

使用super關鍵字

使用super調用父類中重寫的方法、訪問父類中被隱藏的字段
子類重寫了父類中的某一個方法，隱藏父類中的字段，假如想在子類中訪問到父類中被重寫的方法和隱藏父類的字段，可以在子類中通過使用關鍵字super來調用父類中被重寫的方法和訪問父類中被隱藏的字段。例如：

package first;
class A{
    public String name="張飛";         //添加成員變量
    public void say() {                //添加成員方法say
        System.out.println("我是父類A成員方法say");
    }
}
class B extends A{
    public String name="關羽";         //與父類中同名的字段，隱藏父類
    public void say(){                 //重寫方法say
        super.say();                   //使用super關鍵字調用父類中的方法
        System.out.println("我是子類B成員方法say");
        System.out.println("父類的name名字："+super.name); //使用super關鍵字訪問父類中的變量
    }
}
public class myfirst {
    public static void main(String[] args) {
      B b=new B();                     //創建子類的一個實例對象
      b.say();                         //調用子類中重寫的方法
      System.out.println("子類的name名字："+b.name);   //調用子類中的name
    }
}

運行結果為：

我是父類A成員方法say
我是子類B成員方法say
父類的name名字：張飛
子類的name名字：關羽

使用super調用父類的無參數構造方法/有參數構造方法

子類不繼承其父類的構造方法。

• 當使用無參數的super()時，父類的無參數構造方法就會被調用；

• 當使用帶有參數的super()方法時，父類的有參數構造方法就會被調用。

例如：

class SuperClass {              //創建父類SuperClass
      private int n;            //聲明一個私有變量n
      SuperClass(){             //父類無參數構造方法
        System.out.println("這是父類SuperClass無參數構造方法");
      }
      SuperClass(int n) {       //父類有參數構造方法
        System.out.println("這是父類SuperClass有參數構造方法");
        this.n = n;
      }
    }
    class SubClass extends SuperClass{     // SubClass類繼承SuperClass類
      private int n;                       //聲明一個私有變量n
      SubClass(){                          // 自動調用父類的無參數構造器
        System.out.println("這是子類無參數構造方法");
      }  
      
      public SubClass(int n){              //子類有參數構造方法
        super(300);                        //調用父類中帶有參數的構造器
        System.out.println("這是子類有參數構造方法"+n);
        this.n = n;
      }
    }
public class myfirst {
    public static void main(String[] args) {
            SubClass sc1 = new SubClass();      //創建子類SubClass實例對象，調用其無參數構造方法
            SubClass sc2 = new SubClass(100);   //創建子類SubClass實例對象，調用其有參數構造方法
    }
}

運行結果為：

這是父類SuperClass無參數構造方法
這是子類無參數構造方法
這是父類SuperClass有參數構造方法
這是子類有參數構造方法100

注意

• 如果要初始化父類中的字段，可以在子類的構造方法中通過關鍵字super調用父類的構造方法；

• 對父類的構造放的調用必須放在子類構造方法的第一行；

• 如果父類構造器沒有參數，則在子類的構造器中不需要使用 super 關鍵字調用父類構造器，系統會自動調用父類的無參構造器；

• 如果父類的構造器帶有參數，則必須在子類的構造器中顯式地通過 super 關鍵字調用父類的構造器并配以適當的參數列表；

• 子類是不繼承父類的構造器（構造方法或者構造函數）的，它只是調用（隱式或顯式）。

附：繼承的使用和認識

1、繼承是怎么實現的？

使用extends 和 implements 關鍵字

extends 繼承的都是對象

implements 繼承實現并實現的是接口

2、在繼承的場景下，同一樣東西，怎么區分是你老爹的還是你自己的？

使用super 與 this 關鍵字

super關鍵字：我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。

this關鍵字：指向自己的引用。

3、父類的某些方法不想被子類繼承，怎么處理？

對方法或屬性進行 private 關鍵字或final關鍵字修飾

private 關鍵字修飾，子類無法使用和繼承

final關鍵字修飾，無法繼承，但是否可以被使用需要看權限屬性

“Java繼承使用實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！