四、工厂设计模式

1. 工厂设计模式介绍

工厂设计模式定义了一个用于创建对象的接口，让子类决定实例化哪个类。是创建型设计模式之一。

2. 工厂设计模式使用场景

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

3. 工厂设计模式UML类图

4. 工厂设计模式简单实现

情景描述，汽车A,B,C内部的结构差异不大，整体一致，所以用一个生产线就可以生产A,B,C三款汽车。

• Car 汽车抽象类：

public abstract class Car {
            /**
             * 车可以启动开走
             */
            public abstract void drive();

            /**
             * 车可以自动导航
             */
            public abstract void selfNavigation();
        }

* CarFactory 汽车生产工厂抽象类:

        public abstract class CarFactory {
            /**
             * 生产某车型的工厂类
             *
             * @param clazz
             * @param <T>
             * @return
             */
            public abstract <T extends Car> T createCar(Class<T> clazz);
        }

• CarABCFactory 生产类型A,B,C的具体实现类：

public class CarABCFactory  extends CarFactory{

            public <T extends Car> T createCar(Class<T> clazz) {
                Car car = null;
                try {
                    car = (Car) Class.forName(clazz.getName()).newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return (T) car;
            }
        }

• CarA ,CarB,CarC 汽车具体实现类：

public class CarA extends Car {
            @Override
            public void drive() {
                System.out.println("CarA 启动");
            }

            @Override
            public void selfNavigation() {
                System.out.println("CarA 自动导航");
            }
        }

• Client 测试类：

public class Client {
            public static void main(String[] args) {
                //工厂类
                CarABCFactory carFactory = new CarABCFactory();

                //汽车A
                CarA carA = carFactory.createCar(CarA.class);
                carA.drive();
                carA.selfNavigation();

                //汽车B
                CarB carB = carFactory.createCar(CarB.class);
                carB.drive();
                carB.selfNavigation();

                //汽车C
                CarC carC = carFactory.createCar(CarC.class);
                carC.drive();
                carC.selfNavigation();

            }
        }

5. 工厂设计模式在Android系统

• 常用的数据结构中，例如List和Set都继承于Collection接口，Collection接口又继承于Iterable接口，Iterable接口如下：

public interface Iterable<T> {
             *
             * @return an Iterator.
             */
            Iterator<T> iterator();
}

在ArrayList和HashSet中，Iterator()方法具体实现如下：
ArrayList:

  public Iterator<E> iterator() {
            return listIterator();
    }
HashSet:

    public Iterator<E> iterator() {
            return map.keySet().iterator();
    }

• Android中的OnCreate()方法中，不同的Activity通过setContentView()可以设置不同的View，这也是一个典型的工厂设计模式。

6. 工厂设计模式在开发中

情景如下，Android数据持久化的操作由很多，常见的有：文件操作；XML操作；数据库操作。但是操作方法无外乎增、删、改、查。所以我们可以将每种操作方式作为一个产品类。

• 抽象类 IOHandler:

    public abstract class IOHandler {

            /**
             * 添加一个个人信息
             *
             * @param id
             * @param name
             */
            public abstract void add(String id, String name);

            /**
             * 删除一个个人信息
             *
             * @param id
             */
            public abstract void remove(String id);

            /**
             * 更新一个个人信息
             *
             * @param id
             * @param name
             */
            public abstract void update(String id, String name);

            /**
             * 查询身份证对应的人名
             *
             * @param id
             * @return
             */
            public abstract String query(String id);
        }

具体实现类：FileHandler、DBHandler、XmlHandler如下：

public class FileHandler extends IOHandler {
        @Override
        public void add(String id, String name) {

        }

        @Override
        public void remove(String id) {

        }

        @Override
        public void update(String id, String name) {

        }

        @Override
        public String query(String id) {
            System.out.println("FileHandler");
            return null;
        }
    }

• IoFactory 工厂类：

public class IOFactory {

            public static <T extends IOHandler> T getIOHandler(Class<T> clazz) {
                IOHandler ioHandler = null;
                try {
                    ioHandler = (IOHandler) Class.forName(clazz.getName()).newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return (T) ioHandler;
            }
        }

• 测试类：

public class Client {
            public static void main(String[] args) {
                FileHandler fileHandler = IOFactory.getIOHandler(FileHandler.class);
                XmlHandler xmlHandler = IOFactory.getIOHandler(XmlHandler.class);
                DBHandler dbHandler = IOFactory.getIOHandler(DBHandler.class);

                fileHandler.query("");
                xmlHandler.query("");
                dbHandler.query("");
            }
        }

7. 总结

• 优点：工厂设计模式降低了对象之间的耦合度；同时，工厂方法依赖于抽象架构，其将实例化的任务交给子类去完成，有良好的扩展性。
• 缺点：每次为工厂方法模式添加新的产品时，就要编写一个新的产品类，同时还要引入抽象层，导致类的结构的复杂化。