创建型--抽象工厂模式

概念

---

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

工厂模式：一个工厂类用来创建多个产品族中的同一种产品。
抽象工厂模式：多个工厂类用来创建多个产品族。每个产品族中有多个种类的产品。

优点：

1. 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
   缺点：
2. 难以支持在产品族中增加新种类产品。需要在抽象的创建产品对象接口中和它的实现类中修改代码。
    

抽象工厂模式

/* 一个产品族(套装)中包含产品种类:A(上衣),B(裤子)
 * A类产品有A1,A2两个款式
 * B类产品有B1,B2两个款式
  * 套装1包含A1,B1
  * 套装2包含A2,B2
 * */
// 创建A类产品的公共接口
interface AbstractProduceA{
	void Show();
}
// 创建一些A类产品:A1,A2
class ProduceA1 implements AbstractProduceA{
	@Override
	public void Show() {
		System.out.println("ProduceA1 Creation Completion");
	}
}
class ProduceA2 implements AbstractProduceA{
	@Override
	public void Show() {
		System.out.println("ProduceA2 Creation Completion");
	}
}
// 创建B类产品的公共接口
interface AbstractProduceB{
	void Show();
}
// 创建一些A类产品:B1,B2
class ProduceB1 implements AbstractProduceB{
	@Override
	public void Show() {
		System.out.println("ProduceB1 Creation Completion");
	}
}
class ProduceB2 implements AbstractProduceB{
	@Override
	public void Show() {
		System.out.println("ProduceB2 Creation Completion");
	}
}
// 创建某个产品族中的各类产品
interface AbstractFactory {
	//A,B
	AbstractProduceA CreateProduceA();
	AbstractProduceB CreateProduceB();
}
// 创建套装1中各类产品的工厂
class ConcreteFactory1 implements AbstractFactory{
	@Override
	public AbstractProduceA CreateProduceA() {
		return new ProduceA1();
	}
	@Override
	public AbstractProduceB CreateProduceB() {
		return new ProduceB1();
	}
}
// 创建套装2中各类产品的工厂
class ConcreteFactory2 implements AbstractFactory{
	@Override
	public AbstractProduceA CreateProduceA() {
		return new ProduceA2();
	}
	@Override
	public AbstractProduceB CreateProduceB() {
		return new ProduceB2();
	}
}
// 客户端
public class Client {
	public static void main(String[] args) {
		// 创建套装1中的各类产品对象
		AbstractFactory taozhuang1 = new ConcreteFactory1();
		AbstractProduceA a1 = taozhuang1.CreateProduceA();
		AbstractProduceB b1 = taozhuang1.CreateProduceB();
		a1.Show();
		b1.Show();
	}
}

Output:
ProduceA1 Creation Completion
ProduceB1 Creation Completion

/* 如果要增加新种类的产品:帽子C */
// AbstractFactory 要改，其具体实现类也要改
/*
interface AbstractFactory {
	AbstractProduceA CreateProduceA();
	AbstractProduceB CreateProduceB();
	AbstractProduceC CreateProduceC();
}
class ConcreteFactory1 implements AbstractFactory{
	@Override
	public AbstractProduceA CreateProduceA() {
		return new ProduceA1();
	}
	@Override
	public AbstractProduceB CreateProduceB() {
		return new ProduceB1();
	}
	@Override
	public AbstractProduceC CreateProduceC() {
		return new ProduceC1();
	}
}
class ConcreteFactory2 implements AbstractFactory{
	@Override
	public AbstractProduceA CreateProduceA() {
		return new ProduceA2();
	}
	@Override
	public AbstractProduceB CreateProduceB() {
		return new ProduceB2();
	}
	@Override
	public AbstractProduceC CreateProduceC() {
		return new ProduceC2();
	}
}
interface AbstractProduceC{
	void Show();
}
//创建一些C类产品:C1,C2
class ProduceC1 implements AbstractProduceC{
	@Override
	public void Show() {
		System.out.println("ProduceC1 Creation Completion");
	}
}
class ProduceC2 implements AbstractProduceC{
	@Override
	public void Show() {
		System.out.println("ProduceC2 Creation Completion");
	}
}
*/