Android设计模式——工厂模式和抽象工厂模式

简单说就是父类抽象出方法来，子类去实现。工厂模式可以降低系统的耦合度，创建对象的时候不再是new这个对象了，而是通过工厂来创建。

普通工厂模式：创建同类产品的不同类型，如例子中红苹果/绿苹果都是苹果。

抽象工厂模式：创建不同类的产品，如例子中底盘和语音系统是不同类产品。

举例说明：

普通工厂模式：

1，先定义一个苹果的抽象类，并抽象出摘苹果的方法

public abstract class Apple {
    public abstract void pluckApple();
}

2，以下两个子类继承父类，实现抽象方法，一个是红苹果，一个是绿苹果。

public class RedApple extends Apple{
    @Override
    public void pluckApple() {
        Log.d("RedApple","种红苹果的工厂在摘苹果");
    }
}

public class GreenApple extends Apple{
    @Override
    public void pluckApple() {
        Log.d("GreenApple","种绿苹果的工厂在摘苹果");
    }
}

3，接下来就要实现工厂类了，先建一个基类，抽象出生产苹果的方法，这儿用了泛型：

public abstract class Factory{
    public abstract <T extends Apple> T produceApple(Class<T> clz);
}

再建苹果工厂：

public class AppleFactory extends Factory {
    @Override
    public <T extends Apple> T produceApple(Class<T> clz) {
        Apple apple = null;
        try {
            //这儿使用了反射机制
            apple = (Apple) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) apple;
    }
}

//如果你不想用反射机制，就酱紫判断吧，或者单独创建生产红苹果和绿苹果的工厂
@Override
public <T extends Apple> T produceApple(Class<T> clz) {
    Apple apple = null;
    if ("RedApple".equals(clz.getSimpleName())){
        apple = new RedApple();
    }else if("GreenApple".equals(clz.getSimpleName())){
        apple = new GreenApple();
    }
    return (T) apple;
}

4，最后就是使用了，创建一个工厂，工厂分别生产了红苹果和绿苹果，并调用了采摘苹果的方法

Factory factory = new AppleFactory();
factory.produceApple(RedApple.class).pluckApple();//打印的是 摘的是红苹果
factory.produceApple(GreenApple.class).pluckApple();//打印的是 摘的是绿苹果

简单说下我自己的理解：

工厂模式需要：产品、工厂、客户端。

首先，红苹果和绿苹果都需要采摘，所以有个苹果的抽象类，并有采摘的抽象方法。

然后，需要一个厂家来生产苹果，可以通过约定来生产不同的苹果。

最后，客户端通过工厂来生成不同的苹果就好。

备注：在工厂创建产品时，我用的是反射机制实现的。如果不想用反射机制，那当产品比较多时，判断的逻辑就会很长，这时候，就可以用工厂方法模式解决了（我就不写这个模式了，懒癌犯了），工厂方法模式简单说就是解决产品过多的问题，就是创建不同的苹果工厂继承Factory，我举得例子里只是创建了一个苹果工厂，在这一个苹果工厂里判断是生成哪个产品。但如果创建了不同的苹果工厂，那就不用进行逻辑判断了，当新增产品时，不需要修改代码，直接新增一个产品的工厂就好，符合面向对象编程的开放封闭原则。

 

抽象工厂模式：

1，要创造个机器人产品，并抽象出它的零件底盘和语音系统

public interface Rebot {
     interface BasePlate{
         void walk();
     }
     interface Mouse{
         void talk();
     }
}

2，底盘有圆的和方的

public class CircleBasePlate implements Rebot.BasePlate {
    @Override
    public void walk() {
        Log.d("CircleBasePlate","调用了圆底盘的walk方法");
    }
}

public class RectangleBasePlate implements Rebot.BasePlate {
    @Override
    public void walk() {
        Log.d("RectangleBasePlate","调用了方底盘的walk方法");
    }
}

3，语音系统有适合大机器人的和小机器人的

public class BigMouse implements Rebot.Mouse {
    @Override
    public void talk() {
        Log.d("BigMouse","大机器人在说话");
    }
}

public class SmallMouse implements Rebot.Mouse {
    @Override
    public void talk() {
        Log.d("SmallMouse","小机器人在说话");
    }
}

4，建工厂，需要生产底盘和语音系统

public abstract class Factory2 {
    public abstract Rebot.BasePlate createBasePlate(Class clz);
    public abstract Rebot.Mouse createMouse(Class clz);
}

5，工厂实现类

public class RebotFactory extends Factory2{

    @Override
    public Rebot.BasePlate createBasePlate(Class clz) {
        Rebot.BasePlate basePlate = null;
        try {
            basePlate = (Rebot.BasePlate) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return basePlate;
    }
    @Override
    public Rebot.Mouse createMouse(Class clz) {
        Rebot.Mouse mouse = null;
        try {
            mouse = (Rebot.Mouse) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return mouse;
    }
}

6，测试代码

//创建一个大机器人
Factory2 factory2 = new RebotFactory();
factory2.createBasePlate(CircleBasePlate.class).walk();
factory2.createMouse(BigMouse.class).talk();

//创建一个小机器人
factory2.createBasePlate(RectangleBasePlate.class).walk();
factory2.createMouse(SmallMouse.class).talk();

我的理解是：抽象工厂模式，创建的是不同类，比工厂模式多了一步要抽象出不同的类，如机器人有底盘和语音系统，底盘会有不同形式的底盘。底盘和语音系统是完全不相关的，有不同的实现方法。

首先，将不同类的产品封装成一个接口，即Robot，并提供不同产品相对应的方法。

然后，所有产品都继承相对应的产品类型，并实现抽象的方法；

再然后，开始建工厂，有生产底盘的工厂，也有生产语音系统的工厂；

最后，客户端创建工厂后，通过工厂生成不同的产品。