一、介绍，定义

抽象工厂模式也是创建型模式之一，抽象工厂模式起源于对不同操作系统的图形化解决方案，如不同操作系统的按钮和文本框控件及其实现。

为创建一组相关或者相互依赖的对象提供接口，而不需要具体指定他们的具体类。

二、使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。(比如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时，对应的零件类又要增加，这是此模式一个弊端，就是类的徒增，如果工厂类过多，势必导致文件非常多，开发中一定要权衡。

五、模式的优缺点:

优点：

分离接口与实现，客户端使用抽象工厂来创建需要的对象，二客户端根本不知道具体实现的是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象工厂方法模式在切换产品类时更加灵活，容易。

缺点：

一是文件的爆炸性增加，而是不太容易扩展新的产品类，因为每当我们增加一个产品类就需要修改抽象工厂，那么所以的具体工厂均会被修改。