Java子類繼承父類的所有屬性和方法

一、繼承的概念

繼承是面向對象編程中的一個重要概念。它允許我們創建新的類（子類），從已有的類（父類）中繼承其屬性和方法。這樣，子類就具有了父類的所有屬性和方法，還可以在此基礎上添加些許新的屬性和方法。

Java中，默認情況下，每個類都是Object類的子類，因此Java中大多數類都繼承了Object提供的屬性和方法。

二、Java中繼承的實現

在Java中，繼承可以通過「extends」關鍵字來實現，使用該關鍵字後，子類可以從父類中繼承所有的非私有（private）屬性和方法。

// 定義父類Person
public class Person {
    public String name;
    public int age;
    public void sayHello() {
        System.out.println("Hello, I am " + name);
    }
}

// 定義子類Student，繼承Person
public class Student extends Person {
    public String school;
    public void study() {
        System.out.println(name + " is studying in " + school);
    }
}

// 測試，從Student中調用繼承自Person中的方法和屬性
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "Li Lei";
        student.age = 18;
        student.school = "No.1 High School";
        student.sayHello(); // Hello, I am Li Lei
        student.study(); // Li Lei is studying in No.1 High School
    }
}

三、訪問修飾符對繼承的影響

Java中有四個訪問修飾符：public、protected、default、private。它們的作用範圍不同，如果使用不當，會對繼承產生影響。

1. public

使用public修飾的屬性和方法可以被子類直接訪問，例如：

// 父類Student中使用public修飾的屬性和方法
public class Person {
    public String name;
    public int age;
    public void sayHello() {
        System.out.println("Hello, I am " + name);
    }
}

// 子類Student中直接訪問繼承自父類Person中使用public修飾的屬性和方法
public class Student extends Person {
    public void sayHelloToTeacher() {
        System.out.println("Hello, Teacher");
        sayHello(); // 調用繼承自Person中使用public修飾的方法
        System.out.println("My name is " + name); // 訪問繼承自Person中使用public修飾的屬性
    }
}

2. protected

使用protected修飾的屬性和方法可以被子類訪問，但是對於子類的外部類或無關類是不可見的。這意味着，子類可以在子類內部或其子類內部使用父類中的受保護成員，但是在子類外部不可使用。

// 父類Person中使用protected修飾的屬性和方法
public class Person {
    protected String name;
    protected int age;
    protected void sayHello() {
        System.out.println("Hello, I am " + name);
    }
}

// 子類Student中調用繼承自父類Person中使用protected修飾的方法
public class Student extends Person {
    public void sayHelloToTeacher() {
        System.out.println("Hello, Teacher");
        sayHello(); // 調用繼承自Person中使用protected修飾的方法
        System.out.println("My name is " + name); // 訪問繼承自Person中使用protected修飾的屬性
    }
}

// 無關類中無法訪問繼承自Person中使用protected修飾的屬性和方法
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Tom"; // 編譯錯誤，無法訪問使用protected修飾的屬性
        person.sayHello(); // 編譯錯誤，無法訪問使用protected修飾的方法
    }
}

3. default

不使用訪問修飾符，即使用默認訪問修飾符聲明的屬性和方法，對於子類和同一包中的其他類都是可見的。但是，對於不在同一包中的類，使用default修飾的屬性和方法都是不可見的。

// 父類Person中使用默認訪問修飾符聲明的屬性和方法
public class Person {
    String name;
    int age;
    void sayHello() {
        System.out.println("Hello, I am " + name);
    }
}

// 子類Student中會繼承從父類Person中使用default訪問修飾符聲明的屬性和方法
public class Student extends Person {
    public void sayHelloToTeacher() {
        System.out.println("Hello, Teacher");
        sayHello(); // 調用繼承自Person中使用default訪問修飾符聲明的方法
        System.out.println("My name is " + name); // 訪問繼承自Person中使用default訪問修飾符聲明的屬性
    }
}

// 另一個類，在同一包中可以訪問使用default訪問修飾符聲明的屬性和方法
public class AnotherClass {
    public void test(Person person) {
        person.name = "Alex"; // 可以訪問使用default訪問修飾符聲明的屬性
        person.sayHello(); // 可以訪問使用default訪問修飾符聲明的方法
    }
}

// 不在同一包中的類無法訪問使用default訪問修飾符聲明的屬性和方法
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "Tom"; // 編譯錯誤，無法訪問使用default訪問修飾符聲明的屬性
        person.sayHello(); // 編譯錯誤，無法訪問使用default訪問修飾符聲明的方法
    }
}

4. private

使用private修飾的屬性和方法只能被該類的內部訪問，其他類無法訪問。因此，私有成員是不可繼承的，子類中無法訪問父類的私有屬性和方法。

// 父類Person中使用private修飾的屬性和方法
public class Person {
    private String name;
    private int age;
    private void sayHello() {
        System.out.println("Hello, I am " + name);
    }
}

// 子類Student中無法訪問從父類Person中繼承的私有成員
public class Student extends Person {
    public void sayHelloToTeacher() {
        System.out.println("Hello, Teacher");
        sayHello(); // 編譯錯誤，無法訪問繼承自Person中的私有方法
        System.out.println("My name is " + name); // 編譯錯誤，無法訪問繼承自Person中的私有屬性
    }
}

四、super關鍵字

在子類中如果想要調用父類中的方法或屬性，可以使用super關鍵字。使用super關鍵字可以訪問父類的成員變量和成員方法，並且可以調用父類的構造函數。

// 父類Person中的構造函數
public class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 子類Student中使用super關鍵字訪問父類的構造函數
public class Student extends Person {
    public String school;
    public Student(String name, int age, String school) {
        super(name, age); // 調用父類的構造函數
        this.school = school;
    }
}

// 測試
public class Test {
    public static void main(String[] args) {
        Student student = new Student("Li Lei", 18, "No.1 High School");
        System.out.println(student.name); // 輸出："Li Lei"
        System.out.println(student.age);  // 輸出：18
        System.out.println(student.school); // 輸出："No.1 High School"
    }
}

五、總結

繼承是面向對象編程中的重要概念，它允許子類繼承父類的所有屬性和方法，並且可以在此基礎上添加些許新的屬性和方法。在Java中，使用extends關鍵字可以實現繼承，子類可以從父類中繼承所有的非私有屬性和方法。在使用過程中，訪問修飾符對於繼承有一定的影響，如public修飾的屬性和方法可以被子類直接訪問，而private修飾的成員是不可繼承的。使用super關鍵字可以訪問父類的構造函數和成員變量，同時也可以調用父類的方法。