设计模式：简单工厂、原型，模板方法模式

1.简单工厂模式（Simple Factory Pattern）

目的： 简单工厂模式是一种创建型设计模式，它提供一个静态方法来决定应该创建哪种类型的对象。这个静态方法可以根据输入参数或其他条件来选择正确的产品类，并返回其实例。简单工厂常被用于集中管理和控制对象的创建过程，将客户端与具体产品类的实例化过程解耦。

结构：

• Factory（简单工厂）：包含一个静态方法，此方法基于传入的参数决定创建哪个具体产品类的实例，并返回该实例。
• Product（产品接口/抽象类）：定义了所有产品共有的公共接口，具体产品必须实现这个接口。
• ConcreteProduct（具体产品）：实现了产品接口的具体类，是简单工厂要创建的目标对象。

示例场景： 创建不同种类动物的实例，如狗、猫，有一个 AnimalFactory 类，通过传入字符串类型来决定创建 Dog 或 Cat 对象。

// Product
interface Animal {
    void makeSound();
}

// ConcreteProduct
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// Factory
class AnimalFactory {
    public static Animal createAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Invalid animal type");
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Animal dog = AnimalFactory.createAnimal("dog");
        dog.makeSound(); // 输出：Woof!
    }
}

2.原型模式（Prototype Pattern）

目的： 原型模式是一种创建型设计模式，它通过拷贝现有的实例来创建新对象，而不是新建对象。这种模式适用于那些初始化成本高或状态变化大的对象，通过复制已存在的实例可以节省创建的时间和资源。

结构：

• Prototype（抽象原型）：声明克隆自身的接口。
• ConcretePrototype（具体原型）：实现抽象原型接口，提供复制自身的方法（clone 方法）。
• Client（客户端）：请求创建新对象时，向原型请求克隆。

示例场景： 数据库连接对象，创建连接耗时且消耗资源，因此可以通过原型模式复制已建立好的连接对象，而非每次都新建连接。

// Prototype
interface CloneableAnimal {
    CloneableAnimal clone();
}

// ConcretePrototype
class Dog implements CloneableAnimal {
    @Override
    public CloneableAnimal clone() {
        return new Dog();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        CloneableAnimal clonedDog = dog.clone();
    }
}

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

目的： 模板方法模式是一种行为设计模式，它在一个抽象类中定义一个算法的骨架，允许子类在不改变结构的情况下重写某些步骤。这种方式使框架的设计者可以在抽象类中定义一套算法的固定步骤，而具体实现步骤由子类来提供。

结构：

• AbstractClass（抽象类）：定义了算法的骨架，包含了一个或多个基本操作的模板方法（一般是 final 的），以及一些抽象方法供子类实现。
• ConcreteClass（具体子类）：实现抽象类中定义的抽象方法，完成算法中的具体步骤。

示例场景： 咖啡制作流程，抽象类 Coffee 里定义了制作咖啡的基本步骤（磨豆、煮水、冲泡等），而具体的美式咖啡 AmericanCoffee 和拿铁咖啡 LatteCoffee 分别实现了加奶、加糖等特定步骤。

// AbstractClass
abstract class Coffee {
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    abstract void brew();

    void boilWater() {
        System.out.println("Boiling water...");
    }

    void pourInCup() {
        System.out.println("Pouring into cup...");
    }

    abstract void addCondiments();
}

// ConcreteClass
class AmericanCoffee extends Coffee {
    @Override
    void brew() {
        System.out.println("Dripping coffee through filter...");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding sugar and milk...");
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        AmericanCoffee coffee = new AmericanCoffee();
        coffee.prepareRecipe();
    }
}