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中实现超类的代码复用，从而提高代码的可维护性和可扩展性。