* 24种设计模式——抽象工厂模 式

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

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

一、女娲造人（男、女）

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三个肤色，分别对应不同肤色，然后创建一个工厂类，专门负责不同肤色人的双性人的创建。

四、最佳实践

使用的场景非常多，比如在产品开发过程中，涉及不同操作系统 的时候，都可以考虑使用抽象工厂模式