* 24种设计模式——抽象工厂模式-优快云博客

本文链接：https://blog.youkuaiyun.com/yifanSJ/article/details/74937529

核心：为创建一组或相互依赖的对象提供接口，而无需指定具体类。

在场景类中，没有任何一个方法与实现类有关系，对于一个产品来说，我们只要知道它的工厂方法就可以直接生产一个产品对象，无须关心它的实现类。

一、女娲造人（男、女）

1、人种接口

public interface Human {
	//每个人种都有相应的颜色
	public void getColor();
	//人类会说话
	public void talk();
	//每个人都性别
	public void getSex();
}

2、黑色人种

public abstract class AbstractBlackHuman implements Human{
	public void getColor() {
		System.out.println("黑色人种的皮肤颜色是黑色的");
	}
	public void talk() {
		System.out.println("黑人会说话，一般人听不懂!");
	}
}

3、白色人种

public abstract class AbstractWhiteHuman implements Human{
	public void getColor() {
		System.out.println("白色人种的皮肤颜色是白色的!");
	}
	public void talk() {
		System.out.println("白色人种会说话，一般说的都是单字节!");
	}
}

4、黄色人种

public abstract class AbstractYellowHuman implements Human{
	public void getColor() {
		System.out.println("黄色人种的皮肤颜色是黄色的!");
	}
	public void talk() {
		System.out.println("黄色人种会说话，一般说的都是双字节!");
	}
}

5、黄色女性人种

public class FemaleYellowHuman extends AbstractYellowHuman{
	public void getSex() {
		System.out.println("黄人女人");
	}
}

6、黄色男性人种

public class MaleYellowHuman extends AbstractYellowHuman{
	public void getSex() {
		System.out.println("黄人男性");
	}
}

7、八卦炉定义

public interface HumanFactory {
	//制造一个黄色人种
	public Human createYellowHuman();
	//制造一个白色人种
	public Human createWhiteHuman();
	//制造一个黑色人种
	public Human createBlackHuman();
}

8、生产女性的八卦炉

public class FemaleFactory implements HumanFactory{
	//生产出黄人女性
	public Human createYellowHuman() {
		return new FemaleYellowHuman();
	}
	//生产出白人女性
	public Human createWhiteHuman() {
		return new FemaleWhiteHuman();
	}
	//生产出黑人女性
	public Human createBlackHuman() {
		return new FemaleBlackHuman();
	}
}

9、生产男性的八卦炉

public class MaleFactory implements HumanFactory{
	//生产出黄人男性
	public Human createYellowHuman() {
		return new MaleYellowHuman();
	}
	//生产出白人男性
	public Human createWhiteHuman() {
		return new MaleWhiteHuman();
	}
	//生产出黑人男性
	public Human createBlackHuman() {
		return new MaleBlackHuman();
	}
}

10、女娲造人

/**
 * 符合迪米特法则
 */
public class NvWa {
	public static void main(String[] args) {
		//第一条生产线，男性生产线
		HumanFactory femaleFactory = new FemaleFactory();
		//第二条生产线，女性生产线
		MaleFactory maleFactory = new MaleFactory();
		//开始生产人
		Human femaleBlackHuman = femaleFactory.createBlackHuman();
		Human maleBlackHuman = maleFactory.createBlackHuman();
		System.out.println("生产一个黑人女性");
		femaleBlackHuman.getColor();
		femaleBlackHuman.talk();
		femaleBlackHuman.getSex();
		System.out.println("生产一个黑人男性");
		maleBlackHuman.getColor();
		maleBlackHuman.talk();
		maleBlackHuman.getSex();
	}
}

==》

生产一个黑人女性
黑色人种的皮肤颜色是黑色的
黑人会说话，一般人听不懂!
黑人女人
生产一个黑人男性
黑色人种的皮肤颜色是黑色的
黑人会说话，一般人听不懂!
黑人男人

二、抽象工厂的模式的定义

1. 抽象产品A类

public abstract class AbstractProductA {
	//每个产品共有的方法
	public void shareMethod(){
		System.out.println("这是共有方法");
	}
	//每个产品相同方法，不同实现
	public abstract void doSomething();
}

2. 产品A1（等级1）的实现类

public class ProductA1 extends AbstractProductA{
	public void doSomething() {
		System.out.println("产品A1的实现方法");
	}
}

3. 产品A2（等级2）的实现类

public class ProductA2 extends AbstractProductA{
	public void doSomething() {
		System.out.println("产品A2的实现方法");
	}
}

4. 抽象产品B类

public abstract class AbstractProductB {
	public void sharemethod(){
		
	}
	public abstract void doSomething();
}

5. 产品B1（等级1）的实现类

public class ProductB1 extends AbstractProductB{
	public void doSomething() {
		System.out.println("产品B1的实现方法");
	}
}

6. 产品B2（等级2）的实现类

public class ProductB2 extends AbstractProductB{
	public void doSomething() {
		System.out.println("产品B的实现方法");
	}
}

7. 抽象工厂类

public abstract class AbstractCreator {
	//创建A产品家族
	public abstract AbstractProductA createProductA();
	//创建B产品家族
	public abstract AbstractProductB createProductB();
}

8. 产品等级1的实现类

public class Creator1 extends AbstractCreator{
	//只生产产品等级为1的A产品
	public AbstractProductA createProductA() {
		return new ProductA1();
	}
	//只生产产品等级为1的B产品
	public AbstractProductB createProductB() {
		return new ProductB1();
	}
}

9. 产品等级2的实现类

public class Creator2 extends AbstractCreator{
	//只生产产品等级为2的A产品
	public AbstractProductA createProductA() {
		return new ProductA2();
	}
	//只生产产品等级为2的B产品
	public AbstractProductB createProductB() {
		return new ProductB2();
	}
}

10. 场景类

public class Client {
	public static void main(String[] args) {
		//定义出两个工厂
		AbstractCreator creator1 = new Creator1();
		AbstractCreator creator2 = new Creator2();
		//产生A1对象
		AbstractProductA a1 = creator1.createProductA();
		//产生A2对象
		AbstractProductA a2 = creator2.createProductA();
		//产生B1对象
		AbstractProductB b1 = creator1.createProductB();
		//产生B2对象
		AbstractProductB b2 = creator2.createProductB();
		//...
	}
}

三、抽象工厂的模式的应用

1. 抽象工厂的优点

封闭性：每个产品的实现类不是高层模块要关心的，它只关心接口或者抽象，它不关心对象是如何创建出来，这由谁负责呢？工厂类，只要知道工厂类是谁，我就能创建一个需要的对象。

2. 抽象工厂的缺点

产品族扩展困难，如果增加了产品C，也就是说产品家庭由原来的2个增加到3个，程序就会有很大改动，

抽象类AbstractCreator要增加一个方法createProductC()，然后两个实现类都要修改，严重违反了开闭原则，更重要的是改变了“契约”——接口或抽象类，有是一段有毒代码。

3. 抽象工厂的使用场景

一个对象族（或一组没有关系的对象）有相同的约束，则可以使用抽象工厂模式。比如：某个文本编辑器在不同系统中虽然界面一样，但是内部代码不同，于是我们就可编写多个工厂类分别调用。

4. 抽象工厂的注意事项

缺点中，抽象工厂模式的产品族扩展比较困难，但是产品等级扩展非常容易。

上面的女娲造人，增加一个双性人这个产品等级很容易，只用增加三个产品类分别extendsAbstractBlackHuman三个肤色，分别对应不同肤色，然后创建一个工厂类，专门负责不同肤色人的双性人的创建。

四、最佳实践