Android(安卓)内功心法(1.2.1)——android常用设计模式之工厂模式后续抽象工厂模式

我们接着上一篇《Android 内功心法(1.2)——android常用设计模式之工厂模式》来写抽象工厂模式。

因为抽象工厂代码比较多，结构比较复杂，也是最佳工厂写法。所以专门另起一篇博客写抽象工厂模式。

若想要了解抽象工厂模式那么必须先去理解简单工厂和工厂方法模式。

抽象工厂模式的中心思想就是工厂抽象，产品抽象。以抽象替换具体，达到最佳的松耦合和开闭原则。

因为抽象工厂的例子实在是不想去想了，就在csdn上找了一个例子稍微的修改了一下贴出来。
先来看代码。首先先定义一个抽象工厂的基类接口。

/** * 抽象工厂的基类接口 */public interface AbstractFactory {     public ProductA factoryA();//抽象产品A接口    public ProductB factoryB();//抽象产品B接口}

其中包含了两个抽象产品类。
接下拉定义两个产品的接口。

/** * 抽象产品A */public interface ProductA {    //抽象产品A定义了产品的公共方法，产品1和2属于一个产品族    public void methodA1();    public void methodA2();}/** * 抽象产品B */public interface ProductB {    //抽象产品B定义了产品的公共方法，产品1和2属于一个产品族    public void methodB1();    public void methodB2();}

有了抽象的工厂和抽象的产品，接下来就是将抽象赋予具体。
先来实现具体的工厂类

/** * 具体工厂（生产等级为1的族产品） */public class ConcreateFactoryA implements AbstractFactory {    //生产等级为1的产品A    @Override    public ProductA factoryA() {        return new ConcreateProductAA();    }    //生产等级为1的产品B    @Override    public ProductB factoryB() {        return new ConcreateProductBA();    }}/** * 具体工厂（生产等级为2的族产品） */public class ConcreateFactoryB implements AbstractFactory {    //生产等级为2的产品A    @Override    public ProductA factoryA() {        return new ConcreateProductAB();    }    //生产等级为2的产品B    @Override    public ProductB factoryB() {        return new ConcreateProductBB();    }}

具体的工厂实现以后，就是产生产品的时候。
产品的产出就是最后的方法了。
产品类的实现：

/** * 具体产品（等级为1的A产品） */public class ConcreateProductAA implements ProductA {    @Override    public void methodA1() {        System.out.println("等级为1的产品A的method1()");    }    @Override    public void methodA2() {        System.out.println("等级为1的产品A的method2()");    }}/** * 具体产品（等级为2的A产品） */public class ConcreateProductAB implements ProductA {    @Override    public void methodA1() {        System.out.println("等级为2的产品A的method1()");    }    @Override    public void methodA2() {        System.out.println("等级为2的产品A的method2()");    }}/** * 具体产品（等级为1的B产品） */public class ConcreateProductBA implements ProductB {    @Override    public void methodB1() {        System.out.println("等级为1的产品B的method1()");    }    @Override    public void methodB2() {        System.out.println("等级为1的产品B的method2()");    }}/** * 具体产品（等级为2的B产品） */public class ConcreateProductBB implements ProductB {    @Override    public void methodB1() {        System.out.println("等级为2的产品A的method1()");    }    @Override    public void methodB2() {        System.out.println("等级为2的产品A的method2()");    }}

调用具体产品：

 AbstractFactory abstractFactory = new ConcreateFactoryA();//实例化A工厂        ProductA productA = abstractFactory.factoryA();//调用A工厂的方法实例化A产品        productA.methodA1();//得到生产1级产品的A产品中的方法

最后的输出的结果就是：

等级为1的产品A的method1()

可能看到这里有些程序员比较懵逼。
总之看清楚几点：
1，抽象工厂（包含所有抽象产品）
2，抽象产品
3，工厂实现类（包含实例产品）
4，产品实现类（具体实现产品的逻辑）

接下来画张图更加直观

其中
黑色箭头代表依包含关系
红色中空箭头代表实现关系
红色箭头代表调用方法

可以看出。抽象工厂的目的是把工厂和产品都变成抽象。
这样，不管你是新增加工厂还是新增加某个工厂下的产品都只需要实现抽象的接口就可以了。
如代码：

/** * 具体工厂（生产等级为3的族产品） */public class ConcreateFactoryC implements AbstractFactory {    //生产等级为3的产品A    @Override    public ProductA factoryA() {        return new ConcreateProductAC();    }    //生产等级为3的产品B    @Override    public ProductB factoryB() {        return new ConcreateProductBC();    }}////////////////////////////////////////** * 具体产品（等级为3的A产品） */public class ConcreateProductAC implements ProductA {    @Override    public void methodA1() {        System.out.println("等级为3的产品A的method1()");    }    @Override    public void methodA2() {        System.out.println("等级为3的产品A的method2()");    }}/////////////////////////////////////产生新产品AbstractFactory abstractFactoryC = new ConcreateFactoryC();        ProductA productCA = abstractFactoryC.factoryA();        ProductB productCB = abstractFactoryC.factoryB();        //获得新产品        productCA.methodA1();        productCA.methodA2();        productCB.methodB1();        productCB.methodB2();

这样一来，不管是新增产品（XXX implements ProductA）还是新增工厂（XXX implements AbstractFactory）都是可以做到最大限度的松耦合和“开闭原则”的。

抽象工厂就简单工厂和工厂方法模式来说，每个具体工厂可以生产多种产品。而同时又可以拥有多个工厂。

还有一种方法实现抽象工厂更加简单和直观，这里因为时间原因就不写出来了，可以自行百度“使用反射机制实现抽象工厂”。

说到这里我要引用《大话设计模式》中的一段话：所有用简单工厂的地方，都可以考虑用反射来去除switch或if，分支判断带来的耦合。

更多相关文章

随机推荐