factory pattern

什么是工厂模式
工厂模式的种类
使用工厂模式的时机

什么是工厂模式

我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。比如：您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

工厂模式种类

简单工厂模式(Simple Factory Pattern)

又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

角色：抽象产品、具体产品、简单工厂

抽象产品

1
2
3

public interface Product {
    void desc();
}

具体产品

public class Product1 implements Product{
    @Override
    public void desc() {
        System.out.println("生产了产品1！");
    }
}

public class Product2 implements Product{
    @Override
    public void desc() {
        System.out.println("生产了产品2！");
    }
}

简单工厂

public class SimpleFactory {
    public static final int productType1 = 1;
    public static final int productType2 = 2;

    public static Product produce(int productType) {
        switch (productType) {
            case productType1:
                return new Product1();
            case productType2:
                return new Product2();
            default:
                return new Product2();
        }
    }
}

工厂方法模式(Factory Method)

不再设计一个工厂类来统一负责所有产品的创建,而是将具体按钮的创建过程交给专门的工厂子类去完成,将工厂抽象。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的类型，只需要为这种新类型的创建一个具体的工厂类就可以获得该新产品的实例，这一特点无疑使得工厂方法模式具有超越简单工厂模式的优越性符合”开闭原则”。

角色：抽象产品、具体产品、抽象工厂、具体工厂

抽象工厂

1
2
3

public interface Factory {
    Product produce();
}

具体工厂

public class Factory1 implements Factory{
    @Override
    public Product produce() {
        return new Product1();
    }
}

public class Factory2 implements Factory{
    @Override
    public Product produce() {
        return new Product2();
    }
}

抽象工厂模式(Abstract Factory）

但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。

产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

角色：抽象产品族(多个产品)、针对某个产品族的具体产品、抽象工厂、具体工厂

多个产品(抽象)
对于之前Product抽象类，新添一种产品MutiProduct

public class MutiProduct1 implements MutiProduct {
    @Override
    public void desc() {
        System.out.println("生产了新型产品1！");
    }
}

具体产品

public class MutiProduct1 implements MutiProduct {
    @Override
    public void desc() {
        System.out.println("生产了新型产品1！");
    }
}
public class MutiProduct2 implements MutiProduct {
    @Override
    public void desc() {
        System.out.println("生产了新型产品2！");
    }
}

多个产品族的抽象工厂
生产Product和MutiProduct产品

public interface MutiFactory {
    Product create();

    MutiProduct createMuti();
}

具体工厂

public class MutiFactory1 implements MutiFactory{
    @Override
    public Product create() {
        return new Product1();
    }

    @Override
    public MutiProduct createMuti() {
        return new MutiProduct1();
    }
}

public class MutiFactory2 implements MutiFactory{
    @Override
    public Product create() {
        return new Product2();
    }

    @Override
    public MutiProduct createMuti() {
        return new MutiProduct2();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        System.out.println("simple factory!");
        SimpleFactory simpleFactory = new SimpleFactory();
        Product product1 = simpleFactory.produce(1);
        product1.desc();

        System.out.println("\n");
        System.out.println("factory method!");
        Factory factory = new Factory2();
        Product product2 = factory.produce();
        product2.desc();

        System.out.println("\n");
        System.out.println("abstract factory!");
        MutiFactory mutiFactory1 = new MutiFactory1();
        Product product = mutiFactory1.create();
        MutiProduct mutiProduct = mutiFactory1.createMuti();
        product.desc();
        mutiProduct.desc();

    }
}

simple factory!
生产了产品1！


factory method!
生产了产品2！


abstract factory!
生产了产品1！
生产了新型产品1！

使用工厂模式的时机

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。