工厂方法模式在平时开发中非常常见，这里还会举例三种工厂模式，多工厂模式、简单工厂模式、抽象工厂模式。

一、工厂方法模式概述

1. 定义

定义一个用于创建对象的接口，让子类去决定实例化哪个类。

2. 应用场景

• 需要生成复杂对象的地方，都可以使用工厂模式。
• 简单地用new就可以完成创建的对象无需使用工厂模式。

3. 工厂方法模式模板

主要分为四个模块：

• 抽象工厂，为工厂方法模式的核心。
• 具体工厂，实现了具体业务逻辑，提供具体产品。
• 抽象产品，工厂模式创建的所有产品的父类。
• 具体产品。

代码实现：

抽象产品

public abstract class Product {
    public abstract void method();
}

具体产品

public class ProductA extends Product {
    @Override
    public void method() {
        System.out.println("Product A");
    }
}

抽象工厂

public abstract class Factory {
    public abstract Product createProduct();
}

具体工厂

public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

使用

public class Test {
    public static void test() {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.method();
    }
}

修改需求

此时如果需求变化，不需要生产ProductA了，换成ProductB。

public class ProductB extends Product {
    @Override
    public void method() {
        System.out.println("Product B");
    }
}

要实现这一变化，并不需要修改使用部分的代码，只需要修改具体工厂的代码。

public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
//        return new ProductA();
        return new ProductB();
    }
}

二、工厂方法模式的扩展

1. 使用更灵活的反射

除了上面修改工厂的实现，还可以修改抽象工厂和具体工厂，传入类型参数，来动态的决定实例化哪个对象。

public abstract class Factory {
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

public class ConcreteFactory extends Factory {
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product product = null;
        try {
            product = (Product) Class.forName(clz.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

使用的时候就可以更灵活的传入需要实例的类。

public class Test {
    public static void test() {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct(ProductB.class);
        product.method();
    }
}

2. 多工厂模式

除了上面的利用反射，死办法也是有的，为每一个产品都创建一个对应的工厂，这种方式叫做多工厂模式。

为ProductB新增对应的工厂。

public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

使用的时候想生产什么产品，就使用什么工厂。

public class Test {
    public static void test() {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        product.method();
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.method();
    }
}

3. 简单工厂模式

简单工厂模式也叫静态工厂模式。如果工厂类只有一个，就可以将抽象工厂省略，修改Factory。

public class Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

相当于工厂方法的弱化版本。

三、集合框架中的工厂方法模式

List和Set都继承Collection接口。

public interface Collection<E> extends Iterable<E>

Collection接口继承了Iterable接口，里面有一个抽象方法。

public interface Iterable<T> {
    Iterator<T> iterator();
}

看一看在具体集合中这个方法的集合。ArrayList实现：

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E>

所以ArrayList实现的是返回一个ArrayList内部的迭代器。

再看ArraySet的iterator()。返回属于ArraySet的iterator()。

@Override
public Iterator<E> iterator() {
    return getCollection().getKeySet().iterator();
}

这样看来，其实Iterable接口就相当于抽象工厂，ArrayList和ArraySet的iterator()就相当于工厂方法。

四、抽象工厂模式

1. 定义

为创建一组相关或相互依赖的对象提供一个接口，而不需要指定它们的具体类。

2. 抽象工厂模式模板

解释一下UML图。有两种产品A和B，其中A分为两种具体类型A1和A2，B也有两种具体类型B1和B2。工厂会提供A和B两个产品，具体类型由具体工厂决定。两个具体工厂，一个提供A1产品和B1产品，另一个工厂提供A2产品和B2产品。

理解了UML，代码其实就很简单了，抽象工厂模式模板实现：

抽象产品

public abstract class ProductA {
    public abstract void method();
}

public abstract class ProductB {
    public abstract void method();
}

具体产品

public class ConcreteProductA1 extends ProductA {
    @Override
    public void method() {
        System.out.println("A1");
    }
}

public class ConcreteProductA2 extends ProductA {
    @Override
    public void method() {
        System.out.println("A2");
    }
}

public class ConcreteProductB1 extends ProductB {
    @Override
    public void method() {
        System.out.println("B1");
    }
}

public class ConcreteProductB2 extends ProductB {
    @Override
    public void method() {
        System.out.println("B2");
    }
}

抽象工厂

public abstract class Factory {
    public abstract ProductA createProductA();
    public abstract ProductB createProductB();
}

具体工厂

public class ConcreteFactory1 extends Factory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

public class ConcreteFactory2 extends Factory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

五、 Android中抽象工厂模式的应用

在Android源码中，利用抽象工厂模式的地方不多，大部分情况下使用工厂模式就可以解决。在开发中主要是应用于出现多个产品品种的情况。

主题切换

六、小结

1. 先说缺点

工厂方法模式使用范围非常广泛，但是也有缺点，需要添加新的产品类还要引入抽象层，会导致类结构的复杂化，所以在只有一个具体工厂是可以考虑省去工厂抽象层，使用简单工厂模式。

至于抽象工厂模式，它比工厂模式还要复杂，类文件的爆炸性增加，不容已扩展新的产品类，因为如果要增加一个产品类，就需要修改抽象工厂。比如上面主题切换的例子，如果想添加一个ThemeTextView，就意味着需要在抽象工厂中增加一个抽象方法createTextView()。

2. 再说优点

工厂模式依赖于抽象的架构，将其实例化的任务交由子类完成，有良好的扩展性。

抽象工厂模式分离接口与实现，使用抽象工厂创建对象时，根本不需要知道具体实现是谁，面向接口编程，使其从具体产品中解耦，同时在切换产品类时非常灵活。