应用最广泛的模式——工厂方法模式

工厂方法模式的定义

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

工厂方法模式的使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。

工厂方法模式示例

工厂方法模式一般分为四个模块：

1. 抽象工厂——工厂方法模式的核心
2. 具体工厂——实现具体的业务逻辑
3. 抽象产品——工厂方法模式所创建的产品的父类
4. 具体产品——实现抽象产品的某个具体产品的对象

抽象产品Product.class

public abstract class Product {
    /**
     * description: 产品类的抽象方法
     * 由具体的产品去实现
     */
    public abstract void method();
}

具体产品ConcreteProductA.class

public class ConcreteProductA extends Product {
    @Override
    public void method() {
        Log.i("ConcreteProductA", "我是具体的产品A");
    }
}

具体产品ConcreteProductB.class

public class ConcreteProductB extends Product {
    @Override
    public void method() {
        Log.i("ConcreteProductB", "我是具体的产品B");
    }
}

抽象工厂Factory.class

public abstract class Factory {
    /**
     * description: 抽象工厂方法
     * 具体生产什么由子类去实现
     */
    public abstract Product createProduct();

    /**
     * description: 也可以用反射的方式更简洁的来生产具体对象
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

具体工厂ConcreteFactory.class

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

    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product product = null;
        try {
            product = (Product) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

调用：

        ConcreteFactory factory = new ConcreteFactory();
        ConcreteProductA concreteProductA = (ConcreteProductA) factory.createProduct();
        concreteProductA.method();

        ConcreteProductB concreteProductB = factory.createProduct(ConcreteProductB.class);
        concreteProductB.method();

当确定你的工厂类只有一个，那么可以简化掉工厂抽象类，只需要将对应的工厂方法改为静态方法即可，这种方式又称为静态工厂模式。

public class ConcreteFactory extends Factory {
    public static Product createProduct() {
        return new ConcreteProductB();
    }
}

小结

优点

工厂方法是一个很好的设计模式，完全符合设计原则，降低了对象之间的耦合度，依赖于抽象的架构，将实例化的任务交给子类去完成，有非常好的扩展性。

缺点

每次工厂方法模式添加新的产品时都要编写一个新的产品类，同时还要引入抽象层，这必然会导致类结构的复杂化。