Java - 繼承

---

---

Java 繼承

在 Java 程式設計中，繼承是 Java OOPs 的一個重要概念。繼承是一個類獲取另一個類屬性（方法 和 屬性）的過程。透過使用繼承，資訊以分層的方式進行管理。

繼承其他類屬性的類稱為子類（派生類、子類），而其屬性被繼承的類稱為超類（基類、父類）。

Java 繼承的必要性

• 程式碼重用：繼承的基本需求是重用功能。如果您已經定義了一些功能，透過使用繼承，您可以在其他類和包中輕鬆地使用它們。
• 可擴充套件性：繼承有助於擴充套件類的功能。如果您有一個具有某些功能的基類，您可以透過在派生類中使用繼承來擴充套件它們。
• 方法覆蓋的實現：實現多型性的一個概念，即方法覆蓋，需要繼承。
• 實現抽象：OOPs 的另一個概念，即抽象，也需要繼承。

Java 繼承的實現

要在 Java 中實現（使用）繼承，使用 extends 關鍵字。它將基類的屬性（屬性或/和方法）繼承到派生類。單詞“extends”表示擴充套件功能，即功能的可擴充套件性。

實現繼承的語法

請考慮以下語法在 Java 中實現（使用）繼承

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

Java 繼承示例

以下是一個演示 Java 繼承的示例。在此示例中，您可以觀察到兩個類，即 Calculation 和 My_Calculation。

使用 extends 關鍵字，My_Calculation 繼承了 Calculation 類的 addition() 和 Subtraction() 方法。

複製並貼上以下程式到名為 My_Calculation.java 的檔案中

實現繼承的 Java 程式

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

編譯並執行上述程式碼，如下所示。

javac My_Calculation.java
java My_Calculation

執行程式後，將產生以下結果：

輸出

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

在給定的程式中，當建立 My_Calculation 類的物件時，其內部會建立超類內容的副本。因此，使用子類物件可以訪問超類的成員。

超類引用變數可以儲存子類物件，但使用該變數只能訪問超類的成員，因此要訪問兩個類的成員，建議始終建立子類的引用變數。

如果您考慮上述程式，您可以如下所示例項化類。但是，使用超類引用變數（在本例中為 cal）無法呼叫屬於子類 My_Calculation 的方法 multiplication()。

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

注意 - 子類繼承其超類中的所有成員（欄位、方法和巢狀類）。建構函式不是成員，因此不會被子類繼承，但可以從子類呼叫超類的建構函式。

Java 繼承：super 關鍵字

super 關鍵字類似於 this 關鍵字。以下是使用 super 關鍵字的場景。

• 它用於區分超類的成員與子類的成員，如果它們具有相同的名稱。

• 它用於從子類呼叫超類的建構函式。

區分成員

如果一個類繼承了另一個類的屬性。並且如果超類的成員與子類具有相同的名稱，為了區分這些變數，我們使用 super 關鍵字，如下所示。

super.variable
super.method();

示例程式碼

本節為您提供了一個演示 super 關鍵字用法的程式。

在給定的程式中，您有兩個類，即 Sub_class 和 Super_class，它們都具有名為 display() 的方法，但實現不同，並且變數 num 的值也不同。我們呼叫兩個類的 display() 方法並列印兩個類的變數 num 的值。在這裡您可以觀察到我們使用了 super 關鍵字來區分超類的成員與子類的成員。

複製並貼上程式到名為 Sub_class.java 的檔案中。

示例

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

使用以下語法編譯並執行上述程式碼。

javac Super_Demo
java Super

執行程式後，您將獲得以下結果：

輸出

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

呼叫父類建構函式

如果一個類繼承了另一個類的屬性，子類會自動獲取父類的預設建構函式。但是，如果你想呼叫父類的帶引數建構函式，你需要使用 super 關鍵字，如下所示。

super(values);

示例程式碼

本節提供的程式演示瞭如何使用 super 關鍵字呼叫父類的帶引數建構函式。該程式包含一個父類和一個子類，其中父類包含一個接受整數值的帶引數建構函式，我們使用 super 關鍵字呼叫了父類的帶引數建構函式。

複製並貼上以下程式到一個名為 Subclass.java 的檔案中。

示例

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

使用以下語法編譯並執行上述程式碼。

javac Subclass
java Subclass

輸出

The value of the variable named age in super class is: 24

IS-A 關係

IS-A 是一種說法：這個物件是那個物件的一種型別。讓我們看看如何使用extends關鍵字來實現繼承。

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

現在，根據上面的例子，在面向物件的術語中，以下為真 -

• Animal 是 Mammal 類的父類。
• Animal 是 Reptile 類的父類。
• Mammal 和 Reptile 是 Animal 類的子類。
• Dog 是 Mammal 和 Animal 類的子類。

現在，如果我們考慮 IS-A 關係，我們可以說 -

• Mammal IS-A Animal
• Reptile IS-A Animal
• Dog IS-A Mammal
• 因此：Dog IS-A Animal 也是如此

透過使用 extends 關鍵字，子類將能夠繼承父類所有屬性，除了父類的私有屬性。

我們可以透過使用 instanceof 運算子來確保 Mammal 實際上是一個 Animal。

示例

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

輸出

true
true
true

既然我們已經很好地理解了extends關鍵字，讓我們看看如何使用implements關鍵字來獲得 IS-A 關係。

通常，implements關鍵字用於類繼承介面的屬性。介面不能被類擴充套件。

示例

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

Java 繼承：instanceof 關鍵字

讓我們使用instanceof運算子來檢查確定 Mammal 是否實際上是 Animal，以及 dog 是否實際上是 Animal。

示例

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

輸出

true
true
true

HAS-A 關係

這些關係主要基於用法。這決定了某個類是否HAS-A某個東西。這種關係有助於減少程式碼重複和錯誤。

讓我們來看一個例子 -

示例

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
} 

這表明 Van 類 HAS-A Speed。透過為 Speed 建立一個單獨的類，我們不必將屬於 speed 的所有程式碼都放在 Van 類中，這使得可以在多個應用程式中重用 Speed 類。

在面向物件特性中，使用者不需要關心哪個物件在執行實際工作。為了實現這一點，Van 類向 Van 類的使用者隱藏了實現細節。因此，基本上發生的是使用者會要求 Van 類執行某個操作，而 Van 類會自行執行該操作或要求另一個類執行該操作。

Java 繼承的型別

在 Java 中，主要有三種類型的繼承：單一、多層和層次。Java 不支援多重和混合繼承。

需要記住的一個非常重要的點是，Java 不支援多重和混合繼承。這意味著一個類不能擴充套件多個類。因此，以下是非法的 -

1. Java 單一繼承

只有一個基類和一個派生類的繼承稱為單一繼承。單一（或單層）繼承僅從一個基類繼承資料到一個派生類。

Java 單一繼承的示例

class One {
  public void printOne() {
    System.out.println("printOne() method of One class.");
  }
}

public class Main extends One {
  public static void main(String args[]) {
    // Creating object of the derived class (Main)
    Main obj = new Main();

    // Calling method
    obj.printOne();
  }
}

輸出

printOne() method of One class.

2. Java 多層繼承

基類被繼承到派生類，並且該派生類進一步被繼承到另一個派生類的繼承稱為多層繼承。多層繼承涉及多個基類。

Java 多層繼承的示例

class One {
  public void printOne() {
    System.out.println("printOne() method of One class.");
  }
}

class Two extends One {
  public void printTwo() {
    System.out.println("printTwo() method of Two class.");
  }
}

public class Main extends Two {
  public static void main(String args[]) {
    // Creating object of the derived class (Main)
    Main obj = new Main();

    // Calling methods
    obj.printOne();
    obj.printTwo();
  }
}

輸出

printOne() method of One class.
printTwo() method of Two class.

3. Java 層次繼承

只有一個基類和多個派生類的繼承稱為層次繼承。

Java 層次繼承的示例

// Base class
class One {
  public void printOne() {
    System.out.println("printOne() Method of Class One");
  }
}

// Derived class 1
class Two extends One {
  public void printTwo() {
    System.out.println("Two() Method of Class Two");
  }
}

// Derived class 2
class Three extends One {
  public void printThree() {
    System.out.println("printThree() Method of Class Three");
  }
}

// Testing CLass
public class Main {
  public static void main(String args[]) {
    Two obj1 = new Two();
    Three obj2 = new Three();

    //All classes can access the method of class One
    obj1.printOne();
    obj2.printOne();
  }
}

輸出

printOne() Method of Class One
printOne() Method of Class One

示例

public class extends Animal, Mammal{} 

但是，一個類可以實現一個或多個介面，這幫助 Java 擺脫了多重繼承的不可能。