抽象工厂模式

• 抽象工厂模式
• • 抽象工厂模式简略图
  • 解决问题？
  • 案例分析
  • • 低端款
    • 高端款
    • 工厂类
    • 案例代码抽象工厂模式UML图
  • 抽象工厂模式及与工厂模式的区别
  • 抽象工厂模式优缺点对比
  • 工厂模式要点

抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

定义抽象工厂模式（Abstract Factory）,提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类

抽象工厂模式简略图

抽象工厂模式是所有的设计模式里面最为抽象和最具有一般性的一种形态，下面有个图，大家看一下能有一点印象不？

图中左边的代表的就是工厂等级结构，而右边分别就是不同的产品等级，这只是一个简单的模拟图，不用追究里面到底有什么内容。

而抽象工厂模式可以向其他的类提供出一个接口，是的其他的类在不必指定产品的具体类型的情况下，创建出多个产品组中的产品对象，这也是抽象工厂模式的用意所在。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

解决问题？

抽象工厂模式主要解决的是什么问题呢？

每一个设计模式都是针对一定的问题的解决方案，正如前面所说的，抽象工厂模式面对的问题就是多个产品等级结构的设计，我们从下面开始，将抽象工厂引入到系统设计中来。

上图表示产品等级结构图，但是这个产品等级结构图中2和3是平级，，4和5是平级，而这些平级的就未扩展的就构成了产品族，这也就是说每一个产品族中含有的产品的数目和产品等级结构的数据是相等的，

案例分析

假设我们现在有一个汽车工厂，生产两款类型的汽车，一款低端汽车，一款高端汽车。两款汽车在同一个工厂生产，区别只是在于零部件的不同。

低端款的汽车

低端座位，低端轮胎，低端发动机

高端款汽车

高级座位，越野型轮胎，高级发动机

结合该情景，我们可以使用抽象工厂模式。

首先我们创建三个零部件接口

public interface Tyre {
	//轮胎
	void revolve();
}
public interface Seat {
	//座位
	void massage();
}
public interface Engine {
	//发动机
	void run();
}

三个零部件的实现类，实现类分为高端款和低端款

低端款

//低端轮胎实现类
public class LowTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("低端轮胎，打滑");
	}
}
//低端座位
public class LowSeat implements Seat {

	@Override
	public void massage() {
		System.out.println("低端座位，坐起来不舒服");
	}
}
//低端发动机
public class LowEngine implements Engine {

	@Override
	public void run() {
		System.out.println("低端发动机，跑的慢");
	}
}

高端款

//高端轮胎
public class LuxuryTyre implements Tyre {
	
	@Override
	public void revolve() {
		System.out.println("高级轮胎，越野型轮胎");
	}

}
//高端座位
public class LuxurySeat implements Seat {

	@Override
	public void massage() {
		System.out.println("高级座位，真皮，可以按摩");
	}

}
//高端发动机
public class LuxuryEngine implements Engine {
	@Override
	public void run() {
		System.out.println("高级发动机，起步快");
	}

}

工厂类

创建一个抽象工厂类

public interface CarFactory {

	Engine createEngine();

	Seat createSeat();

	Tyre createTyre();

}

接着创建两个工厂子类，分别是高端工厂和低端工厂

高端工厂

public class LuxuryCarFactory implements CarFactory {
	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}
}

低端工厂

public class LowCarFactory implements CarFactory {
	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}
}

最后,在客户端的具体实现。

public class TestFactory {

	public static void main(String[] args) {
		low();
		System.out.println("==================");
		luxury();
	}

	//用低端工厂，生产低端汽车
	public static void low(){
		CarFactory carFactory = new LowCarFactory();
		Engine engine = carFactory.createEngine();
		Seat seat = carFactory.createSeat();
		Tyre tyre = carFactory.createTyre();
		engine.run();
		seat.massage();
		tyre.revolve();
	}

	//用高端工厂，生产高端汽车
	public static void luxury(){
		CarFactory carFactory = new LuxuryCarFactory();
		Engine engine = carFactory.createEngine();
		Seat seat = carFactory.createSeat();
		Tyre tyre = carFactory.createTyre();
		engine.run();
		seat.massage();
		tyre.revolve();
	}

}

最后输出结果

低端发动机，跑的慢
低端座位，坐起来不舒服
低端轮胎，打滑
==================
高级发动机，起步快
高级座位，真皮，可以按摩
高级轮胎，越野型轮胎

上面就是我们模拟的抽象工厂类的代码实现。而如果需要增加一个‘尊贵奢华版’汽车，那么需要增加‘尊贵奢华版’对应类的轮胎，发动机，座位，可以看出，随着具体工厂的增加，类的数目会成倍增加，因此在实际工作中需要控制具体工厂的数目，保持设计模式的简洁性。

案例代码抽象工厂模式UML图

抽象工厂模式及与工厂模式的区别

一般来说，产品种类单一，适合用工厂模式；如果有多个种类，各种类型时，通过抽象工厂模式来进行创建是很合适的。

抽象工厂模式优缺点对比

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

工厂模式要点

简单工厂模式(静态工厂模式)
• 虽然某种程度不符合设计原则，但实际使用最多。

工厂方法模式
• 不修改已有类的前提下，通过增加新的工厂类实现扩展。

抽象工厂模式
• 不可以增加产品，可以增加产品族！

代码案例文件下载地址
http://pvyob7cem.bkt.clouddn/factory.rar