设计模式——工厂模式

工厂模式概念 

在软件设计中，创建对象的过程往往需要考虑很多因素，包括对象的种类、数量以及如何将对象的创建与使用分离。工厂模式（Factory Pattern）作为一种创建型设计模式，提供了一种灵活的方式来管理对象的创建过程。

工厂模式是一种创建对象的设计模式，其核心思想是通过定义一个工厂接口或抽象类来决定创建哪个具体产品，而不直接在客户端代码中进行实例化。这种方式有助于将对象的创建过程与使用过程分离，从而提高代码的灵活性和可维护性。

工厂模式的类型

简单工厂模式

简单工厂模式，又称为静态工厂方法模式，通过一个工厂类来决定创建哪一种产品的实例。客户端只需要知道工厂类，而不需要了解具体的产品类。

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
public class ProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂类
public class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        throw new IllegalArgumentException("未知的产品类型");
    }
}

ProductFactory 类负责创建不同类型的 Product 实例。客户端只需通过 createProduct 方法获取所需产品，而无需关心产品的具体实现。

工厂方法模式

工厂方法模式通过定义一个工厂接口，让具体的子类实现这个接口来创建对象。工厂方法模式允许子类决定实例化哪一个产品。

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

// 具体产品B
public class ProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

// 工厂接口
public interface ProductFactory {
    Product createProduct();
}

// 具体工厂A
public class ProductAFactory implements ProductFactory {
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂B
public class ProductBFactory implements ProductFactory {
    public Product createProduct() {
        return new ProductB();
    }
}

ProductFactory 是一个接口，具体的工厂类实现了 createProduct 方法来创建具体的产品。这样，客户端可以通过工厂接口来获取产品，而不需要了解具体的产品类。

抽象工厂模式

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。通常用于创建多个产品族的对象。

// 产品A接口
public interface ProductA {
    void use();
}

// 产品B接口
public interface ProductB {
    void use();
}

// 具体产品A1
public class ProductA1 implements ProductA {
    public void use() {
        System.out.println("使用产品A1");
    }
}

// 具体产品A2
public class ProductA2 implements ProductA {
    public void use() {
        System.out.println("使用产品A2");
    }
}

// 具体产品B1
public class ProductB1 implements ProductB {
    public void use() {
        System.out.println("使用产品B1");
    }
}

// 具体产品B2
public class ProductB2 implements ProductB {
    public void use() {
        System.out.println("使用产品B2");
    }
}

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

// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2
public class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA2();
    }
    public ProductB createProductB() {
        return new ProductB2();
    }
}

AbstractFactory 定义了创建一系列相关产品的方法。具体工厂实现了这些方法，并返回对应的产品实例。这种模式适用于需要创建多个产品族时，客户端通过工厂来获取一系列产品的实例，而不需要知道具体的实现。

总结

从上到下的优化来看，工厂方法模式并不复杂，甚至这样的开发结构在你有所理解后，会发现更加
简单了。那么这样的开发的好处道后，也可以总结出来它的优点； 避免创建者与具体的产品逻辑耦合、满⾜足单⼀一职责，每⼀一个业务逻辑实现都在所属⾃自⼰己的类中完成、满⾜足开闭原则，无需更更改使⽤用调⽤用⽅方就可以在程序中引入新的产品类型。但这样也会带来一些问题，比如有非常多的奖品类型，那么实现的子类会极速扩张。因此也需要使用其他的模式进行优化，这些在后续的设计模式中会逐步涉及到。