设计模式——工厂模式

分类

简单工厂模式
工厂方法模式
抽象工厂模式

简单工厂模式

作用：在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。

1、创建父类或父接口

public class Product {

    private String productName;

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                '}';
    }
}

2、多个子类继承或实现

3、简单工厂实现

public class SimpleFactory {

    public static Product createProduct(ProductTypeEnum productType){
        if(ProductTypeEnum.product_ONE.equals(productType)){
            return new ProductOne();
        } else if(ProductTypeEnum.product_TWO.equals(productType)){
            return new ProductTwo();
        } else{
            return new Product();
        }
    }
}

4、客户端调用

public class FactoryClient {

    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct(ProductTypeEnum.product_ONE);
        System.out.println(product);
    }
}

工厂方法模式

作用：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。

在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。工厂类直接被抽象化，需要具体特定化的逻辑代码转移到实现抽象方法的子类中，这样我们就不要再去修改工厂类，即不用再去做什么 if else 的修改。

简单说就是为了提供代码结构的扩展性，屏蔽每一个功能类中的具体实现逻辑。让外部可以更加简单的只是知道调用即可，同时，这也是去掉众多ifelse的方式。当然这可能也有一些缺点，比如需要实现的类非常多，如何去维护，怎样减低开发成本。

1、创建工厂方法类

public abstract class FactoryMethod {

    public abstract Product createProduct();
    public abstract void registerProduct(Product product);

    public Product create(){
        Product product = createProduct();
        registerProduct(product);
        return product;
    }
}

2、实现工厂方法的子类

// 不同类型的商品的工厂
public class ProductFactory extends FactoryMethod{
    @Override
    public Product createProduct() {
        Product product = new ProductOne();
        System.out.println("创建商品 " + product.toString());
        return product;
    }

    @Override
    public void registerProduct(Product product) {
        System.out.println("注册商品 " + product.toString());
    }
}

3、客户端调用

public class FactoryClient {

    public static void main(String[] args) {
        FactoryMethod factoryMethod = new ProductFactory();
        Product product = factoryMethod.create();
        System.out.println(product);
    }
}

何时使用工厂方法模式，而非简单工厂

当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。

而使用简单工厂模式，将所有的创建逻辑都放到一个工厂类中，会导致这个工厂类变得很复杂

抽象工厂模式

工厂方法类中只有一个抽象方法，要想实现多种不同的类对象，只能去创建不同的具体工厂方法的子类来实列化，而抽象工厂则是让一个工厂负责创建多个不同类型的对象。

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

实现思路

1 2	public class AbstractProductA { }

1 2	public class AbstractProductB { }

1 2	public class ProductA1 extends AbstractProductA { }

1 2	public class ProductA2 extends AbstractProductA { }

1 2	public class ProductB1 extends AbstractProductB { }

1 2	public class ProductB2 extends AbstractProductB { }

public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}

public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        AbstractProductB productB = abstractFactory.createProductB();
        // do something with productA and productB
    }
}