设计模式——工厂模式

简单工厂模式

它实际上是一种创建型设计模式，用于通过一个共同的工厂方法来创建不同类型的对象。它在不暴露对象创建逻辑的同时，提供了一种简单的方式来实例化对象。虽然它被称为“工厂模式”，但与其他工厂相关的模式不同，它并不属于GOF（Gang of Four）提出的23种设计模式之一。

// 定义产品接口
interface Animal {
    void makeSound();
}

// 具体产品类：猫
class Cat implements Animal {
    @Override
    public void makeSound() { System.out.println("喵喵喵");}
}
// 具体产品类：狗
class Dog implements Animal {
    @Override
    public void makeSound() {System.out.println("汪汪汪");}
}

// 简单工厂类
class AnimalFactory {
    public Animal createAnimal(String type) {
        if (type.equalsIgnoreCase("cat")) {
            return new Cat();
        } else if (type.equalsIgnoreCase("dog")) {
            return new Dog();
        } else {
            throw new IllegalArgumentException("未知品种");
        }
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        AnimalFactory factory = new AnimalFactory();
        Animal cat = factory.createAnimal("cat");
        cat.makeSound(); // Output: Meow
        Animal dog = factory.createAnimal("dog");
        dog.makeSound(); // Output: Woof
    }
}

尽管这个示例展示了简单工厂模式的基本原理，但它并不是一个严格意义上的工厂模式，因为它没有创建一个专门的工厂接口或基类。实际上，这更像是一个创建对象的静态方法。在更复杂的情况下，您可能会考虑使用工厂方法模式或抽象工厂模式来更好地管理对象的创建过程。

抽象工厂模式

旨在提供一个接口来创建一系列相关或相互依赖的对象，而无需指定其具体类。它允许客户端使用抽象接口来创建一组对象，这些对象在具体工厂的实现中被创建。抽象工厂模式通常用于创建一组相关的产品，这些产品可能需要以一致的方式组合，而客户端又不需要关心具体的产品类。

抽象产品接口

// 抽象产品：按钮
interface Button {
    void render();
    void onClick();
}

// 抽象产品：文本框
interface TextBox {
    void render();
    void onInput();
}

具体产品实现

// 具体产品A：Windows按钮
class WindowsButton implements Button {
    @Override
    public void render() {System.out.println("Render Windows button");}
    @Override
    public void onClick() {System.out.println("Windows button clicked");}
}
// 具体产品A：Windows文本框
class WindowsTextBox implements TextBox {
    @Override
    public void render() {System.out.println("Render Windows textbox");}
    @Override
    public void onInput() {System.out.println("Windows textbox input");}
}
// 具体产品B：Mac按钮
class MacButton implements Button {
    @Override
    public void render() {System.out.println("Render Mac button");}
    @Override
    public void onClick() {System.out.println("Mac button clicked");}
}
// 具体产品B：Mac文本框
class MacTextBox implements TextBox {
    @Override
    public void render() {System.out.println("Render Mac textbox");}
    @Override
    public void onInput() {System.out.println("Mac textbox input");}
}

抽象工厂接口

// 抽象工厂接口
interface GUIFactory {
    Button createButton();
    TextBox createTextBox();
}

具体工厂实现

// 具体工厂A：Windows风格
class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {return new WindowsButton();}
    @Override
    public TextBox createTextBox() {return new WindowsTextBox();}
}
// 具体工厂B：Mac风格
class MacFactory implements GUIFactory {
    @Override
    public Button createButton() { return new MacButton();}
    @Override
    public TextBox createTextBox() {return new MacTextBox();}
}

客户端可以使用抽象工厂接口来创建不同操作系统下的 GUI 元素：

public class Main {
    public static void main(String[] args) {
        // 在 Windows 环境下创建 GUI 元素
        GUIFactory windowsFactory = new WindowsFactory();
        Button windowsButton = windowsFactory.createButton();
        TextBox windowsTextBox = windowsFactory.createTextBox();
        windowsButton.render();
        windowsButton.onClick();
        windowsTextBox.render();
        windowsTextBox.onInput();
        // 在 Mac 环境下创建 GUI 元素
        GUIFactory macFactory = new MacFactory();
        Button macButton = macFactory.createButton();
        TextBox macTextBox = macFactory.createTextBox();
        macButton.render();
        macButton.onClick();
        macTextBox.render();
        macTextBox.onInput();
    }
}

工厂方法模式

产品接口

interface Product {
    void create();
}

然后，我们有两个具体的产品类，实现 Product 接口：

class ConcreteProductA implements Product {
    @Override
    public void create() { System.out.println("Creating ConcreteProductA");}
}
class ConcreteProductB implements Product {
    @Override
    public void create() { System.out.println("Creating ConcreteProductB");}
}

接下来，我们定义一个抽象工厂类 AbstractFactory，其中声明了一个抽象的创建方法：

abstract class AbstractFactory {
    abstract Product createProduct();
}

然后，我们有两个具体的工厂类，分别实现了 AbstractFactory 并实现了创建方法：

class ConcreteFactoryA extends AbstractFactory {
    @Override
    Product createProduct() { return new ConcreteProductA();}
}
class ConcreteFactoryB extends AbstractFactory {
    @Override
    Product createProduct() {return new ConcreteProductB();}
}

最后，我们可以在客户端代码中使用工厂来创建产品，而不需要关心具体的产品创建逻辑：

public class Main {
    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.create();  // Output: Creating ConcreteProductA

        AbstractFactory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.create();  // Output: Creating ConcreteProductB
    }
}