Android中的工厂模式

什么是工厂模式？

顾名思义，就是专门用来创建对象的工厂，这里的对象指的是具有相同接口的类的对象。工厂模式可以决定将哪一个类进行实例化，不必事先知道每次要实例化的是哪一个类。

工厂模式有以下三种形态:
1、简单工厂模式：又称为静态工厂方法模式。
2、工厂方法模式：又称为多态性工厂模式或虚拟构造子模式。
3、抽象工厂模式：又称为工具箱模式。

一、简单工厂模式

角色分析：
工厂类角色：工厂类在客户端的直接调用下创建产品对象。
抽象产品角色：代表工厂类所要创建对象的父类或者共同拥有的接口。
具体产品角色：工厂类所要创建的角色实例。

/*
 * Abstract Product
 * */
public interface Fruit {
    void grow();
    void harvest();
    void plant();
}

/*
 * Concrete product
 * */
public class Apple implements Fruit{

    @Override
    public void grow() {
        System.out.println("Apple is growing...");

    }

    @Override
    public void harvest() {
        System.out.println("Apple has been harvested");

    }

    @Override
    public void plant() {
        System.out.println("Apple has been planted");

    }

}

/*
 * Concrete product
 * */
public class Grape implements Fruit {

    @Override
    public void grow() {
        System.out.println("Grape is growing...");

    }

    @Override
    public void harvest() {
        System.out.println("Grape has been harvested");

    }

    @Override
    public void plant() {
        System.out.println("Grape has been planted");

    }

}

/*
 * simple factory
 * */
public class Factory {
    public static Fruit factory(String name) {
        Fruit fruit = null;
        if (name.equals("Apple")) {
            fruit = new Apple();
        } else if (name.equals("Grape")) {
            fruit = new Grape();
        }
        return fruit;
    }
}

/*
 * client
 * */
public class Client {

    public static void main(String[] args) {
        Apple apple = (Apple) Factory.factory("Apple");
        Grape grape = (Grape) Factory.factory("Grape");

        apple.grow();
        apple.harvest();
        apple.plant();

        grape.grow();
        grape.harvest();
        grape.plant();
    }

}

优点：允许客户端相对独立于产品创建的过程，并且在系统中引入新产品的时候无需修改客户端。
缺点：对”开-闭”原则的支持不够，很明显，如果有新产品加入，就需要修改工厂类，将必要的逻辑加入到工厂类。例如，如果我们需要加入Orange这个产品类。很明显，我们需要修改Factory中的factory方法，将Orange这个产品的创建加入进去。

修改它的方法有两种：
1、使用反射进行处理

/*
 * simple factory
 * */
public class Factory {
    public static Fruit factory(Class clz) {
        Fruit fruit = null;
        try {
            fruit = (Fruit) Class.forName(clz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return fruit;
    }
}

2、使用工厂方法模式

工厂方法模式主要是对工厂类进行了抽象，具体的创建工作由其子类来进行操作，这样进一步抽象使得在引入新产品的时候父工厂类不被修改，只需要创建对应的工厂子类就可以了。

抽象工厂角色：具体的创建对象的工厂类必须实现这个接口，它不负责创建工作。
具体工厂角色：实现抽象工厂类，会被客户端调用来创建对象。
抽象产品角色：工厂方法模式所创建的对象的超类型。
具体产品角色：实现了抽象产品角色，工厂方法模式所创建的具体对象。

public interface AbstractFactory {
    public AbstractProduct factory();
}

public interface AbstractProduct {

}

public class ConcreteFactory implements AbstractFactory {

    @Override
    public AbstractProduct factory() {
        return new ConcreteProduct();
    }

}

public class ConcreteProduct implements AbstractProduct {
    public ConcreteProduct() {
        System.out.println("create ConcreteProduct");
    }
}

public class Client {

    public static void main(String[] args) {
        AbstractFactory factory = (AbstractFactory) new ConcreteFactory();
        factory.factory();
    }

}

从上面可以看到工厂方法模式的一个明显的缺点：工厂方法模式中的每个工厂只能生产一类产品，这样有多少个产品类就会对应多少这个工厂类，明显这样会给系统带来大量的工厂类。

上面的问题可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是抽象工厂模式。抽象工厂模式用来创建一组相关或者相互依赖的对象。与工厂方法模式的区别在于工厂方法模式针对的是一个产品等级结构；抽象工厂模式则是针对的多个产品等级结构。工厂方法模式提供的所有产品都是实现同一个接口，而抽象工厂模式所提供的产品是实现自不同的接口。

抽象工厂:声明一组用于创建一族产品的方法，每一个方法对应一种产品。
具体工厂:实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族.
抽象产品:它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
具体产品:定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

public interface AbstractFactory {
    public AbstractProductA factoryA();

    public AbstractProductB factoryB();
}

public class ConcreteFactory implements AbstractFactory {

    @Override
    public AbstractProductA factoryA() {
        return new ConcreteProductA();
    }

    @Override
    public AbstractProductB factoryB() {
        return new ConcreteProductB();
    }

}

public interface AbstractProductA {

}

public interface AbstractProductB {

}

public class ConcreteProductA implements AbstractProductA {
    public ConcreteProductA() {
        System.out.println("create ConcreteProductA");
    }
}

public class ConcreteProductB implements AbstractProductB {
    public ConcreteProductB() {
        System.out.println("create ConcreteProductB");
    }
}

public class Client {
    public static void main(String[] args) {
        ConcreteFactory factory = new ConcreteFactory();
        factory.factoryA();
        factory.factoryB();
    }
}