abstract factory（抽象工厂） 对象创建型模式

每一个模式都有其适用的场景，不乱套敢质疑是学习的根本。另外模式是抽象的，不是一蹴而就的。要多多回顾。

abstract factory（抽象工厂） 对象创建型模式一，

意图：提供一个接口，让该接口负责创建一系列相关或者相互依赖的对象，无需指定它们具体的类。

注意两点：

1.一系列对象，也就是说产品不是一个，是多个，

2.相关或者相互依赖，这些产品是相互相关，至于相关才能抽象出不同系列抽象工厂

二，适用性

1、一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的；（要通过工厂模式生产）

2、这个系统有多于一个的产品组合，而系统只需要使用其中某一产品组合；（产品有系列）

3、同属于同一个产品组合的产品是在一起使用的，这一约束必须在系统的设计中体现出来；（抽象工厂决定了具体工厂）

4、系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现；（实现产品和客户分离）

三，结构

四，参与者

抽象工厂（Abstract Factory）角色：声明一个抽象方法用于创建抽象产品业务。

具体工厂（Concrete Factory）角色：实现这个抽象工厂的具体对象。

抽象产品（Abstract Product）角色：声明一个抽象的产品对象具体产品（Concrete Product）角色：

实现抽象产品对象。

客户 (Client) 角色：调用抽象工厂来实现某个具体的产品。

五，协作

1.通常在运行时刻创建一个ConcreteFactory类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的产品对象，客户端应使用不同的具体工厂。

2.AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。

六，实现

1，它分离了具体的类

Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。

2，它使得易于交换产品系列

一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。

3，它有利于产品的一致性

当一系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而AbstractFactory很容易实现这一点。

4，难以支持新种类的产品难以扩展

抽象工厂以生产新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。支持新种类的产品就需要扩展该工厂接口，这将涉及AbstractFactory类及其所有子类的改变。

自己写的例子。客户向工厂定制衣服，可以区分为春装，夏装，秋装等，而一件套装定义为上衣和裤子，利用抽象工厂模式，就可以把具体工厂定义为春装，夏装工厂，抽象工厂负责与客户交互。春装工厂组装是生产的是春装上衣和春装裤子，依次可以定义出春装系列，夏装系列，秋装系列。

package abstractfactory;
// 上衣
public abstract class Coat {
	public abstract Coat getCoat();
}

// 裤子
package abstractfactory;

public abstract class Pants {
public abstract Pants getPants();
}

package abstractfactory;
//春装上衣
public class SpringCoat extends Coat{

	@Override
	public SpringCoat getCoat() {
		// TODO Auto-generated method stub
		return new SpringCoat();
	}

}

package abstractfactory;
//春装裤子
public class SpringPants extends Pants {

	@Override
	public SpringPants getPants() {
		// TODO Auto-generated method stub
		return new SpringPants();
	}

}

package abstractfactory;
// 夏装上衣
public class SummerCoat extends Coat{

	@Override
	public SummerCoat getCoat() {
		// TODO Auto-generated method stub
		return new SummerCoat();
	}

}

package abstractfactory;
// 夏装裤子
public class SummerPants extends Pants {

	@Override
	public SummerPants getPants() {
		// TODO Auto-generated method stub
		return new SummerPants();
	}

}

package abstractfactory;
// 抽象套装工厂
public abstract class SuitFactory {
	public abstract Pants createPants();

	public abstract Coat createCoat();
}

package abstractfactory;
// 春装生产工厂
public class SpringSuitFactory extends SuitFactory {

	@Override
	public Pants createPants() {
		// TODO Auto-generated method stub
		return new SpringPants();
	}

	@Override
	public Coat createCoat() {
		// TODO Auto-generated method stub
		return new SpringCoat();
	}

}

package abstractfactory;
//夏装生产工厂
public class SummerSuitFactory extends SuitFactory {

	@Override
	public Pants createPants() {
		// TODO Auto-generated method stub
		return new SummerPants();
	}

	@Override
	public Coat createCoat() {
		// TODO Auto-generated method stub
		return new SummerCoat();
	}

}

package abstractfactory;
// 客户端下订单
public class Client {
	public void orderSuit(SuitFactory sf) {
		sf.createCoat();
		sf.createPants();
	}
}

抽象工厂模式要点：

1.产品是多样的成系列的并且相关连依赖的

2.客户与类的实现分离，对内可以易于交换产品系列，对外隐藏了实现细节

3.如果我突然想在套装里面加一个帽子产品，改变幅度较大，涉及面较广，也就是耦合度较高

没有一个模式是完美的，活学活用最重要。