抽象类在Java设计模式中的应用

在Java设计模式中，抽象类被广泛应用，因为它们提供了一种定义基础结构的方式，而具体的实现可以由子类来完成。以下是一些常见的Java设计模式，以及抽象类在这些模式中的应用：

1. 模板方法模式（Template Method Pattern）

模板方法模式定义了一个算法的骨架，但将一些步骤延迟到子类中实现。抽象类在这里扮演了定义算法骨架的角色。

示例：

abstract class AbstractClass {
    // 模板方法
    final void templateMethod() {
        primitiveOperation1();
        concreteOperation();
        primitiveOperation2();
    }

    // 基本方法，子类必须实现
    abstract void primitiveOperation1();
    abstract void primitiveOperation2();

    // 钩子方法，子类可以选择实现
    void concreteOperation() {
        // 默认实现
    }
}

class ConcreteClass extends AbstractClass {
    @Override
    void primitiveOperation1() {
        // 实现具体操作
    }

    @Override
    void primitiveOperation2() {
        // 实现具体操作
    }

    @Override
    void concreteOperation() {
        // 覆盖默认实现
    }
}

2. 工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。抽象类在这里定义了工厂方法。

示例：

abstract class Creator {
    // 工厂方法
    abstract Product factoryMethod();

    void someOperation() {
        Product product = factoryMethod();
        // 使用产品
    }
}

class ConcreteCreator extends Creator {
    @Override
    Product factoryMethod() {
        return new ConcreteProduct();
    }
}

interface Product {
    void use();
}

class ConcreteProduct implements Product {
    @Override
    public void use() {
        // 使用产品
    }
}

3. 策略模式（Strategy Pattern）

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。抽象类在这里定义了策略接口。

示例：

interface Strategy {
    void execute();
}

abstract class AbstractStrategy implements Strategy {
    // 可以提供一些默认实现
    public void defaultExecute() {
        // 默认行为
    }
}

class ConcreteStrategyA extends AbstractStrategy {
    @Override
    public void execute() {
        // 具体策略A
    }
}

class ConcreteStrategyB extends AbstractStrategy {
    @Override
    public void execute() {
        // 具体策略B
    }
}

4. 建造者模式（Builder Pattern）

建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。抽象类在这里定义了建造者的接口。

示例：

interface Builder {
    void buildPartA();
    void buildPartB();
    Product getResult();
}

abstract class AbstractBuilder implements Builder {
    protected Product product = new Product();

    @Override
    public Product getResult() {
        return product;
    }
}

class ConcreteBuilder extends AbstractBuilder {
    @Override
    public void buildPartA() {
        // 构建部分A
    }

    @Override
    public void buildPartB() {
        // 构建部分B
    }
}

class Product {
    // 产品类
}

5. 观察者模式（Observer Pattern）

观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会收到通知并自动更新。抽象类在这里定义了观察者接口。

示例：

interface Observer {
    void update(String message);
}

abstract class AbstractObserver implements Observer {
    // 可以提供一些默认实现
    public void defaultUpdate(String message) {
        System.out.println("Default update: " + message);
    }
}

class ConcreteObserverA extends AbstractObserver {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserverA update: " + message);
    }
}

class ConcreteObserverB extends AbstractObserver {
    @Override
    public void update(String message) {
        System.out.println("ConcreteObserverB update: " + message);
    }
}

通过这些示例可以看出，抽象类在设计模式中起到了定义基础结构和接口的作用，使得具体的实现可以灵活地由子类来完成。这不仅提高了代码的可维护性和可扩展性，还遵循了面向对象设计原则中的开闭原则（对扩展开放，对修改关闭）。