场景：
考虑组装电脑,客户需要自己选择一系列的电脑配件,组装电脑的公司需要根据客户所选择的的配件去组装.
但这样会有一个问题,如果客户了解CPU和主板的兼容配置还好,万一选了俩个不一样的则会出现错误,该争么样防止客
户选错呢?这就需要组装电脑的公司提供给客户一些参数,像多套兼容的CPU和主板配置,客户从中选取其中一套方案就
不会出错,因为每一套规格都是组装公司定制好的,不会出现不兼容。
抽象工厂是为了解决只知道一系列对象的接口,不知道具体实现或者是不知道具体使用哪一个实现,另外这系
列对象是相互依赖的.也就是既要创建接口的对象,还要约束它们之间的关系。
定义：
提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。
角色：
Abstract Factory:
抽象工厂,定义创建一系列产品对象的操作接口.
package com.kris.study;
public interface AbstractFactory {
public AbstractProductA createProductA();
public AbstractProductB createProductB();
}
Concrete Factory:
具体的工厂，实现抽象工厂定义的方法，具体实现一系列有关产品的创建.
package com.kris.study;
public class ConcreteFactory implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ProductA();
}
@Override
public AbstractProductB createProductB() {
return new ProductB();
}
}
package com.kris.study;
public class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ProductB2();
}
}
Abstract Product:
定义一类产品的接口
package com.kris.study;
public interface AbstractProductA {
//抽象产品A的相关操作 例如返回针脚数目
public int getHeadNum();
public void displayHeadNum();
}
package com.kris.study;
public interface AbstractProductB {
//抽象产品B的相关操作 例如返回针脚数目
public int getFootNum();
public void displayFootNum();
}
Concrete Product:
具体的产品实现对象，通常是在具体工厂Concrete Factory里面创建的具体产品对象。
package com.kris.study;
public class ProductA implements AbstractProductA {
@Override
public int getHeadNum() {
return 115;
}
@Override
public void displayHeadNum() {
System.out.println(getHeadNum());
}
}
package com.kris.study;
public class ProductB implements AbstractProductB {
@Override
public int getFootNum() {
return 115;
}
@Override
public void displayFootNum() {
System.out.println(getFootNum());
}
}
package com.kris.study;
public class ProductA2 implements AbstractProductA {
@Override
public int getHeadNum() {
return 224;
}
@Override
public void displayHeadNum() {
System.out.println(getHeadNum());
}
}
package com.kris.study;
public class ProductB2 implements AbstractProductB {
@Override
public int getFootNum() {
return 224;
}
@Override
public void displayFootNum() {
System.out.println(getFootNum());
}
}
Client:
客户端
package com.kris.study;
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory();
factory.createProductA().displayHeadNum();
factory.createProductB().displayFootNum();
System.out.println("----------");
AbstractFactory factory2 = new ConcreteFactory2();
factory2.createProductA().displayHeadNum();
factory2.createProductB().displayFootNum();
}
}
原理分析：
抽象工厂的功能是为一系列相关的对象或相互依赖对象创建一个接口。接口内的方法一定是一系列相关的或相互依赖
的方法而不是任意堆砌的，通常AbstractFactory定义的创建产品的方法可以看成是工厂方法.由于抽象工厂定义的是
一系列产品簇,也就是切换不同产品簇的时候,只要提供不同的工厂就可以了,也就是以整个产品簇作为整体切换。
优点：
分离接口和实现,切换产品簇(相互依赖的一系列对象)变的容易、
缺点：
不太容易扩展新的产品，容易照成类层次复杂。每一层负责一种选择,也就是一层屏蔽一种变化。
本质：选择产品簇的实现
区别：
工厂方法或简单工厂关注的是单个产品对象的创建，只不过简单工厂是在父类直接选择实现,工厂方法是把实现
延迟到子类。
抽象工厂关注的是一系列的产品,这些产品相互之间有依赖关系,需要进行约束。