Java類繼承完整解析

Java類的繼承是面向對象編程中最重要和最基本的概念之一。繼承的概念是指一個類從另外一個類獲取屬性和方法，而被獲取的類稱為父類或超類，使用該屬性和方法的類稱為子類或派生類。在本篇文章中，我們將全面介紹Java類的繼承，從基本概念開始到高級應用，提供豐富的代碼示例和詳細解析，讓讀者輕鬆掌握Java類繼承的所有知識。

一、基本概念

1.1 父類與子類

在Java中，一個類可以通過extends關鍵字繼承另一個類的屬性和方法。被繼承的類稱為父類或超類，繼承的類稱為子類或派生類。例如：

public class Animal {
    protected String name;
    protected int age;

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

在這個例子中，Animal是Dog的父類，Dog是Animal的子類。Dog繼承了Animal的name和age屬性，同時也繼承了eat()方法。

1.2 繼承層次結構

Java中支持多級繼承，即一個子類可以通過繼承多個父類來獲取更多的屬性和方法。這樣就形成了繼承層次結構。例如：

public class Animal {
    protected String name;
    protected int age;

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class GoldenRetriever extends Dog {
    public void fetch() {
        System.out.println("Golden Retriever is fetching.");
    }
}

在這個例子中，GoldenRetriever是Dog的子類，同時也是Animal的子類。GoldenRetriever繼承了Dog的bark()方法和Animal的name和age屬性以及eat()方法。

1.3 protected關鍵字

protected關鍵字用於控制屬性和方法的訪問範圍，被protected修飾的屬性和方法可以被子類繼承和訪問，但不能被其他包中的類訪問。例如：

public class Animal {
    protected String name;
    protected int age;

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Labrador extends Dog {
    public void swim() {
        System.out.println("Labrador is swimming.");
    }
}

public class Main {
    public static void main(String[] args) {
        Labrador labrador = new Labrador();
        labrador.name = "Max";     // 可以訪問父類的protected屬性
        labrador.age = 3;
        System.out.println(labrador.name + " is " + labrador.age + " years old.");
    }
}

在這個例子中，Labrador繼承了Animal和Dog的protected屬性name和age，可以使用labrador.name和labrador.age來訪問。但是在Main類中，無法訪問Labrador的name和age屬性。

二、繼承的常見問題

2.1 父類構造函數

在Java中，子類的構造函數默認會調用父類的無參構造函數。如果父類沒有無參構造函數，子類需要顯式地調用父類的構造函數。例如：

public class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String n, int a) {
        super(n, a);     // 顯式調用父類的構造函數
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

在這個例子中，Animal類的構造函數需要定義兩個參數，所以Dog類的構造函數中需要顯式調用父類的構造函數。

2.2 方法重寫

方法重寫是指子類重新定義了父類已有的方法，使得子類的方法版本覆蓋了父類的方法版本。在Java中，使用@Override註解可以標記一個方法是重寫父類方法的。例如：

public class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String n, int a) {
        super(n, a);
    }

    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

在這個例子中，Dog重寫了Animal的eat()方法，並且使用@Override註解加以標記。在調用Dog的eat()方法時，將會輸出「Dog is eating.」而不是「Animal is eating.」。

2.3 super關鍵字

super關鍵字用於在子類中訪問父類的成員變數和成員方法。例如：

public class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

    public void eat() {
        System.out.println("Animal is eating.");
    }

    public String getName() {
        return name;
    }
}

 public class Dog extends Animal {
    private String barkSound;

    public Dog(String n, int a, String b) {
        super(n, a);
        barkSound = b;
    }

    public void bark() {
        System.out.println("Dog is barking " + barkSound + ".");
    }

    public void getName() {
        System.out.println("The dog's name is " + super.getName() + ".");
    }
}

在這個例子中，Dog類中的getName()方法重寫了Animal類中的getName()方法，並且在方法中使用super關鍵字來訪問父類的getName()方法，輸出「The dog’s name is Max.」。

三、繼承的高級應用

3.1 介面與抽象類

介面和抽象類都是Java中用於實現類似多繼承的方法。介面可以理解為一種規範，它定義了一些方法的簽名，不包含方法的實現。類實現介面時必須實現介面中定義的所有方法。抽象類則是一種中介形態，它可以定義一些成員變數和方法，但方法不需要全部實現。子類繼承抽象類後，必須實現抽象類中未實現的方法。例如：

public interface Swim {
    public void swim();
}

public abstract class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

    public void eat() {
        System.out.println("Animal is eating.");
    }

    public abstract void makeSound();     // 抽象方法

    public abstract void move();          // 抽象方法
}

public class Dog extends Animal implements Swim {
    private String barkSound;

    public Dog(String n, int a, String b) {
        super(n, a);
        barkSound = b;
    }

    public void bark() {
        System.out.println("Dog is barking " + barkSound + ".");
    }

    public void makeSound() {
        System.out.println("Dog is making sound.");
    }

    public void move() {
        System.out.println("Dog is moving.");
    }

    public void swim() {
        System.out.println("Dog is swimming.");
    }
}

在這個例子中，Swim是一個介面，定義了一個swim()方法。Animal是一個抽象類，其中定義了兩個抽象方法makeSound()和move()。Dog繼承了Animal並且實現了Animal中的兩個抽象方法以及Swim介面中的swim()方法。

3.2 其他高級應用

除了介面和抽象類之外，Java中還有一些其他的高級繼承應用，例如final類和final方法。final類表示該類不能被繼承，final方法表示該方法不能被重寫。

public final class Animal {}     // final類

public class Dog {
    public final void bark() {}   // final方法
}

四、總結

Java類的繼承是面向對象編程中最重要和最基本的概念之一。一個類可以通過extends關鍵字繼承另一個類的屬性和方法。被繼承的類稱為父類或超類，繼承的類稱為子類或派生類。Java中支持多級繼承，即一個子類可以通過繼承多個父類來獲取更多的屬性和方法。使用protected關鍵字可以控制屬性和方法的訪問範圍。子類需要顯式地調用父類的構造函數。方法重寫是指子類重新定義了父類已有的方法，使用@Override註解可以標記一個方法是重寫父類方法的。使用super關鍵字可以在子類中訪問父類的成員變數和成員方法。除了介面和抽象類之外，Java中還有一些其他的高級繼承應用，例如final類和final方法。