工厂设计模式

工厂设计模式

工厂设计模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，工厂模式的核心是定义一个创建对象的接口，但是让实现这个接口的类来决定实例化哪一个类。工厂模式将实例化的过程延迟到子类中进行。

类型：

工厂设计模式有不同的变种，其中包括：

1. 简单工厂模式：由一个工厂对象来决定创建出哪一个类的对象。

简单工厂模式负责创建产品对象而不向客户端直接暴露创建逻辑。简单工厂模式中，客户端请求创建一个产品对象，工厂返回一个根据参数创建的产品对象。如下面的代码：

public class Main {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        Product productB = factory.createProduct("B");
        productA.operation();
        productB.operation();
    }
}

// 产品接口
interface Product {
    // 每一个产品需要完成的功能
    void operation();
}

// 具体产品A
class ProductA implements Product {

    @Override
    public void operation() {
        System.out.println("Product A is doing its job...");
    }
}

// 具体产品B
class ProductB implements Product {

    @Override
    public void operation() {
        System.out.println("Product B is doing its job...");
    }
}

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        }

        return null;
    }
}

结果如下:

Product A is doing its job...
Product B is doing its job...

2. 工厂方法模式：定义一个创建产品对象的工厂接口，而子类决定实例化哪一个具体的类。

工厂方法模式定义了一个创建产品对象的接口，但允许子类决定实例化哪一个类。工厂方法模式让类的实例化推送到子类中。如下面的代码：

public class Main {
    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();

        AbstractFactory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();

        productA.operation();
        productB.operation();
    }
}


// 抽象产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("A 产品正在工作");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("B 产品正在工作");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements AbstractFactory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements AbstractFactory{
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

运行结果如下：

A 产品正在工作
B 产品正在工作

3. 抽象工厂模式：提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。

抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类，抽象工厂模式通常适用于一组相关的对象，它们共同工作，如下面的代码：

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();

        productA.operationA();
        productB.operationB();
    }
}


// 抽象产品族A接口
interface ProductA {
    void operationA();
}

// 抽象产品族B接口
interface ProductB {
    void operationB();
}

// 具体产品族A实现
class ConcreteProductA implements ProductA{
    @Override
    public void operationA() {
        System.out.println("A族产品正在工作");
    }
}

// 具体产品族B实现
class ConcreteProductB implements ProductB{
    @Override
    public void operationB() {
        System.out.println("B族产品正在工作");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂
class ConcreteFactory implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB();
    }
}

运行结果如下：

A族产品正在工作
B族产品正在工作

优点：

• 减少系统耦合度
• 符合开闭原则，增加新的产品对象不影响已存在的工厂结构。

总结：

• 简单工厂模式：适用于客户端只需要知道产品的类型，不需要关注具体的产品创建逻辑。
• 工厂方法模式：适用于需要将产品的创建逻辑封装在不同的工厂中，客户端可以根据需要选择不同的工厂。
• 抽象工厂模式：适用于需要创建一组相关或依赖的对象，并希望将这些对象的创建逻辑封装在一个工厂中。