Java超類如何實現代碼復用

在Java中，超類（也稱為父類或基類）可以通過以下幾種方式實現代碼復用：

1. 繼承：子類可以繼承超類的屬性和方法。這意味著子類會自動獲得超類的所有非私有成員。通過繼承，可以在多個子類之間共享代碼，從而減少重復。

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

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

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

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

2. 方法重寫：子類可以重寫超類的方法，以提供特定于子類的實現。這樣，當調用子類對象的方法時，將執行子類的實現，而不是超類的實現。

class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound.");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks.");
    }
}

3. 模板方法模式：在超類中定義一個算法的骨架，將一些步驟延遲到子類中實現。這樣，可以在不改變算法結構的情況下，重新定義算法的某些特定步驟。

abstract class AbstractClass {
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }

    protected abstract void step1();
    protected abstract void step2();
    protected void step3() {
        System.out.println("Step 3 is implemented in the abstract class.");
    }
}

class ConcreteClass extends AbstractClass {
    @Override
    protected void step1() {
        System.out.println("Step 1 is implemented in the concrete class.");
    }

    @Override
    protected void step2() {
        System.out.println("Step 2 is implemented in the concrete class.");
    }
}

4. 組合：在超類中使用其他類的對象作為成員變量，從而實現代碼復用。這種方式可以讓你更靈活地選擇要使用的類，并在運行時更改它們。

class Engine {
    public void start() {
        System.out.println("Engine is starting.");
    }
}

class Car {
    private Engine engine;

    public Car() {
        engine = new Engine();
    }

    public void startCar() {
        engine.start();
        System.out.println("Car is starting.");
    }
}

通過使用這些方法，可以在Java中實現超類的代碼復用，從而提高代碼的可維護性和可擴展性。