Java封裝繼承多態的理解

一、封裝

封裝是面向對象編程中的重要概念之一，它使得對象的屬性與行為被保護在對象內部，只能通過對象提供的接口來訪問。

Java中實現封裝的方式是使用訪問控制修飾符：public、private、protected以及default。其中，public修飾的屬性和方法可以被任意訪問，private修飾的屬性和方法只能被本類訪問，protected修飾的屬性和方法可以被本類以及子類訪問，default修飾的屬性和方法只能被同一個包中的類訪問。

public class Test {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
}

在上面的例子中，我們使用private修飾了Test類的name屬性，使用public修飾了setName和getName方法，通過setName和getName方法來設置和獲取對象的name屬性，隔離了對象內部屬性與外部訪問的細節，實現了封裝。

二、繼承

繼承是面向對象編程中的另一個重要概念，它允許我們創建一個新的類，作為若干個已有類的衍生版本，重新定義這些類的屬性和方法，使得這些新類具備了原有類的功能，同時還能夠附加上自己的特殊功能。

在Java中，可以使用extends關鍵字來繼承一個已有的類。實現繼承需要注意以下幾點：

• 子類可以訪問父類中的public和protected屬性和方法，但是不能訪問父類的private屬性和方法。
• Java不支持多重繼承，即一個類不能同時繼承多個類。
• Java中所有的類都繼承自Object類，在Java中，如果一個類沒有顯式地繼承其他類，那麼這個類就是繼承了Object類。

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

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

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // Animal eating..
        dog.bark(); // Dog barking..
    }
}

在上面的例子中，我們定義了一個基類Animal和一個子類Dog，Dog繼承了Animal的屬性和方法，在Test類中創建了Dog對象，調用eat方法和bark方法。

三、多態

多態是面向對象編程中的又一個重要概念，它允許一個對象變量引用不同的實現，即同一個對象在不同時刻有不同的外部表現形式。

在Java中，實現多態的方式有兩種：方法重載和方法覆蓋。

方法重載是指在一個類中定義多個具有相同名稱但參數不同的方法，通過參數類型和個數的不同來進行區分。

public class Test {
    public void print(String s) {
        System.out.println("print String: " + s);
    }
    
    public void print(int i) {
        System.out.println("print int: " + i);
    }
    
    public void print(double d) {
        System.out.println("print double: " + d);
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        t.print("Hello"); // print String: Hello
        t.print(123); // print int: 123
        t.print(3.14); // print double: 3.14
    }
}

在上面的例子中，我們定義了三個重載的print方法，分別接收String、int和double類型的參數。在main方法中，我們通過傳遞不同類型的參數來調用不同的方法，實現了方法重載的多態。

方法覆蓋是指子類定義了一個與父類具有相同名稱、形參列表和返回值類型的方法，通過不同的實現來覆蓋父類的方法實現。

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

public class Dog extends Animal {
    public void eat() {
        System.out.println("Dog eating bones..");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat(); // Dog eating bones..
    }
}

在上面的例子中，我們定義了一個基類Animal和一個子類Dog，Dog覆蓋了Animal的eat方法，在Test類中創建了一個Animal對象，但是指向了Dog的實例，調用eat方法，輸出Dog eating bones..。