7、Android设计模式---（创建型设计模式）抽象工厂模式

一、介绍，定义

抽象工厂模式也是创建型模式之一，抽象工厂模式起源于对不同操作系统的图形化解决方案，如不同操作系统的按钮和文本框控件及其实现。
为创建一组相关或者相互依赖的对象提供接口，而不需要具体指定他们的具体类。

二、使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。（比如Android、IOS、Windows Phone下都有短信和拨号软件）

三、UML类图

8.png

AbstractFactory：抽象工厂角色，声明了一组用于创建一种产品的方法，每个方法对应生产一种产品，上面生成产品A和B。
ConcreteFactory：具体工厂角色，实现了抽象工厂中定义的创建产品的方法，生成一组具体的产品，每一个产品又位于某个产品等级中。
AbstractProduct：抽象产品角色，定义了每种产品应有的方法
ConcreteProduct：具体的产品角色，定义了具体工厂生产的具体产品对象，实现抽象产品中声明的方法。

四、通用模式代码

抽象的产品A和B

public abstract class AbstractProductA {
   public abstract void method();
}
public abstract class AbstractProductB {
   public abstract void method();
}

具体的产品A1，A2，B1，B2

public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("产品A1的方法");
    }
}
public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("产品A2的方法");
    }
}
public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("产品B1的方法");
    }
}
public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("产品B2的方法");
    }
}

抽象工厂：

public abstract class AbstractFactory {
    public abstract AbstractProductA createProductA();
    public abstract AbstractProductB createProductB();
}

具体的工厂1和2

public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

五、简单实现

上一篇讲到，小民开了个Audi车组装工厂。随着小民生意越做越大，发现Q3，Q5，Q7使用的零件各不相同，他们的零件又有差别，Q3的发动机是国产的，轮胎是铁的。Q7的发动机是外国的，轮胎是塑料的。不同的轮胎，不同的发动机，都也是一种产品类型，这时候就能用抽象产品模式：
首先汽车工厂需要生产轮胎、发动机、制动系统这三种部件：

public abstract class CarFactory {
    //轮胎
    public abstract ITire createTire();
    //发动机
    public abstract IEngine createEngine();
    //制动系统
     public abstract  IBrake createBrake();  //返回 制动系统 对象
}

这里我们为每一个零件定义一个接口，并分别创建两个不同的实现类表示不同的零部件产品

public interface ITire {
    //轮胎接口
    void tire();
}

public class NormalTire implements  ITire {
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

public class SUVTire implements  ITire {
    @Override
    public void tire() {
        System.out.println("越野轮胎");
    }
}

public interface IEngin {
    //发动机
    void engine();
}

public class DomesticEngin implements  IEngin {
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}
public class ImportEngin implements  IEngin {
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

public interface  IBrake {
    //制动系统
    void  brake();
}

public class NormalBrake implements  IBrake {
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}
public class SeniorBrake implements  IBrake {
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

具体的不同的生产车厂 Q3 生产厂

public class Q3Factory extends  CarFactory {
    @Override
    public ITire createTire() {
        return new NormalTire();    //返回普通的轮胎类
    }
    @Override
    public IEngin createEngine() {
        return  new DomesticEngin(); //返回国产发动机
    }
    @Override
    public IBrake createBrake() {
        return new NormalBrake(); //返回一般制动
    }
}

具体的不同的生产车厂 Q7 生产厂

public class Q7Factory extends CarFactory {
    @Override
    public ITire createTire() {
        return new SUVTire(); //返回SUV 车胎
    }
    @Override
    public IEngin createEngine() {
        return new ImportEngin(); //返回进口轮胎
    }
    @Override
    public IBrake createBrake() {
        return  new SeniorBrake(); //返回高级制动
    }
}

客户类具体的实例化调用生产

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //构造一个生产Q3 的工厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();

        //构造一个 生产Q7 的 工厂
        CarFactory factoryQ7 = new Q7Factory();
        factoryQ7.createTire().tire();
        factoryQ7.createEngine().engine();
        factoryQ7.createBrake().brake();
    }
}

结果如下

9.png

可见当需要添加Q5时，对应的零件类又要增加，这是此模式一个弊端，就是类的徒增，如果工厂类过多，势必导致文件非常多，开发中一定要权衡。

五、模式的优缺点:

优点：
分离接口与实现，客户端使用抽象工厂来创建需要的对象，二客户端根本不知道具体实现的是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象工厂方法模式在切换产品类时更加灵活，容易。
缺点：
一是文件的爆炸性增加，而是不太容易扩展新的产品类，因为每当我们增加一个产品类就需要修改抽象工厂，那么所以的具体工厂均会被修改。