工厂方法模式

一．背景

在Android其实很多用到该模式的，以onCreate为例，它就可以看作是一个工厂方法，我们在其中可以构造我们的View并通过setContentView返回给frameWork处理

二．具体定义

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

三．工厂方法模式的使用

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

public class ConcreteProductA extends Product {

    @Override
    public void method() {
        System.out.println("我是具体产品A");
    }
}

public class ConcreteProductB extends Product {

    @Override
    public void method() {
        System.out.println("我是具体产品B");
    }
}

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

public class ConcreteFactory extends Factory {

    @Override
    public Product createProduct() {
        return new ConcreteProductA();
        //如果要生产B的话
        //return new ConcreteProductB();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct();
        p.method();
    }
}

缺点：

可以看出缺点在于，每次要生产其他的产品，都要去改ConcreteFactory,这样就很不方便。

解决方案如下：

public abstract class Factory{
    /**
     * 抽象工厂方法
     * 具体生产什么由子类去实现
     * @param clz 产品对象类 类型
     * @return 具体的产品对象
     * */
    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 p = null;
        try {
            p = Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T)p;
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct(ConcreteProductB.class);
        p.method();
    }
}

可以看出需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简洁，动态（学会！！！！！！），如果你不喜欢这种方式，也可以尝试为每一个产品都定义一个具体的工厂，各司其职。

 

（1）简单实现（用的就是上面的方法）

需求：生产奥迪Q3,Q5,Q7,这三个车内部构造差不多，但是自动驾驶的功能各有不同

public abstract class AudiCar{
    /**
     * 汽车的抽象产品类
     * 定义汽车的一个行为方法 车可以启动开走
     * */
    public abstract void drive();

    /**
     *汽车的抽象产品类
     * 定义汽车的一个行为方法 车可以自动巡航
     * */
    public abstract  void selfNavigation();
}

public class AudiQ3 extends AudiCar{

    @Override
    public void drive() {
        System.out.println("Q3  启动了");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q3  自动驾驶");
    }
}

public class AudiQ5 extends AudiCar{

    @Override
    public void drive() {
        System.out.println("Q5  启动了");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q5  自动驾驶");
    }
}

public class AudiQ7 extends AudiCar{

    @Override
    public void drive() {
        System.out.println("Q7  启动了");
    }

    @Override
    public void selfNavigation() {
        System.out.println("Q7  自动驾驶");
    }
}

public abstract  class AudiFactory {
    /**
     * 某车型的工厂方法
     * @param  clz具体的SUV型号类型
     * @return 具体型号的SUV车对象
     * */
    public abstract <T extends AudiCar> T createAudiCar(Class<T> clz);
}

public class AudiCarFactory extends AudiFactory{

    @Override
    public <T extends AudiCar> T createAudiCar(Class<T> clz) {
        AudiCar car = null;
        try {
            car = (AudiCar)Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return (T)car;
    }
}

public class Client{
    public static void main(String[] args){
        //构造一个制造汽车的工厂对象
        AudiFactory factory = new AudiCarFactory();

        //生产Q3并启动
        AudiQ3 audiQ3 = factory.createAudiCar(AudiQ3.class);
        audiQ3.drive();
        audiQ3.selfNavigation();
        //生产Q5并启动
        AudiQ5 audiQ5 = factory.createAudiCar(AudiQ5.class);
        audiQ5.drive();
        audiQ5.selfNavigation();
        //生产Q7并启动
        AudiQ7 audiQ7 = factory.createAudiCar(AudiQ7.class);
        audiQ7.drive();
        audiQ7.selfNavigation();
    }
}

四．Android源码中的工厂方法模式

（1）ArrayList和HashSet中的Iterator其实就相当于一个工厂方法（相当于抓娃娃机器）

（２）

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new LinearLayout(this));
    }

}

每一个Activity都通过设置setContentView来设置不同的View

这其实就是一个工厂模式

 

<1>关于onCreate方法

 

对于一个应用程序来说，其真正的入口时在ActivityThread类中由我们熟悉的main方法

ActivityThread是一个final类，也就是说他不能被继承，一个应用程序对应一个ActivityThread，当Zygote进程孵化出一个新的应用进程后，会执行ActivityThread的main方法，main方法中做了一些比较常规的逻辑，比如准备Looper和消息队列，然后调用ActivityThead的attach方法将其绑定到ActivityManagerService中，开始不断地读取消息并分发消息。

 

分析待添加！！！！。。。。

 

总结：

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