1.抽象工厂模式是什么
1.百度百科
抽象工厂模式（Abstract Factory）是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。
2.维基百科
The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes.[1] In normal usage, the client software creates a concrete implementation of the abstract factory and then uses the generic interface of the factory to create the concrete objects that are part of the theme. The client doesn't know (or care) which concrete objects it gets from each of these internal factories, since it uses only the generic interfaces of their products. This pattern separates the details of implementation of a set of objects from their general usage and relies on object composition, as object creation is implemented in methods exposed in the factory interface.
3.LZ的理解
抽象工厂模式是创建一个接口，用来创建一组相互依赖的接口或者抽象类，而无需指定具体实现类。
2.抽象工厂模式解决了什么问题
抽象工厂模式是对工厂模式的升级。解决了工厂方法模式一次只能建造一个产品的问题。抽象工厂模式一次可以建造多个抽象产品。
3.抽象工厂模式用法
当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。
我们还是拿车的设计来说事，在工厂方法模式中LZ用一个工厂创建了2种类型的车。现在需要给这两个车分别提供自动驾驶的车和手动驾驶的车。那么我们该怎么做呢。
首先我们创建2个产品类的抽象接口和实现类
//自动驾驶车
public interface AutopiloCar {
/**
* 自动驾驶
*/
public void autopilo();
}
//手动驾驶车
public interface ManualDrivingCar {
/**
* 驾驶
*/
public void drive();
}
//jmn牌自动驾驶车
public class JMNAutopiloCar implements AutopiloCar {
public JMNAutopiloCar() {
System.out.println("JMN建造好了");
}
@Override
public void autopilo() {
System.out.println("JMN自动驾驶自动车开走了");
}
}
//bmw牌自动驾驶车
public class BMWAutopiloCar implements AutopiloCar {
public BMWAutopiloCar() {
System.out.println("BMW自动驾驶车建造好了");
}
@Override
public void autopilo() {
System.out.println("BMW自动驾驶自动车开走了");
}
}
//jmn手动驾驶车
public class JMNManualDrivingCar implements ManualDrivingCar {
public JMNManualDrivingCar() {
System.out.println("JMN人工驾驶车建造好了");
}
@Override
public void drive() {
System.out.println("JMN人工驾驶车建造好了");
}
}
//bmw手动驾驶车
public class BMWManualDrivingCar implements ManualDrivingCar {
public BMWManualDrivingCar() {
System.out.println("BMW人工驾驶车建造好了");
}
@Override
public void drive() {
System.out.println("BMW人工驾驶车开走了");
}
}
下面是抽象工厂类和抽象工厂实现类
//抽象工厂
public interface CreatorFactory {
/**
* 建造自动驾驶车
* @return
*/
public AutopiloCar createAutopiloCar();
/**
* 建造手动驾驶车
* @return
*/
public ManualDrivingCar createManualDrivingCar();
}
//jmn建造工厂
public class JMNCreatorFactory implements CreatorFactory {
@Override
public AutopiloCar createAutopiloCar() {
return new JMNAutopiloCar();
}
@Override
public ManualDrivingCar createManualDrivingCar() {
return new JMNManualDrivingCar();
}
}
//bmw建造工厂
public class BMWCreateFactory implements CreatorFactory{
@Override
public AutopiloCar createAutopiloCar() {
return new BMWAutopiloCar();
}
@Override
public ManualDrivingCar createManualDrivingCar() {
return new BMWManualDrivingCar();
}
}
下面是客户端调用方式
public class Customer {
public static void main(String[] args) {
//创建bmw工厂
CreatorFactory creator = new BMWCreateFactory();
AutopiloCar bmwAutopiloCar = creator.createAutopiloCar();
ManualDrivingCar bmwManualDrivingCar = creator.createManualDrivingCar();
bmwAutopiloCar.autopilo();
bmwManualDrivingCar.drive();
//创建jmn工厂
creator = new JMNCreatorFactory();
AutopiloCar jmnAutopiloCar = creator.createAutopiloCar();
ManualDrivingCar jmnManualDrivingCar = creator.createManualDrivingCar();
jmnAutopiloCar.autopilo();
jmnManualDrivingCar.drive();
}
}
上面的方式是不是用一个工厂创建了两种类型的车呢
4.抽象工厂模式的问题
抽象工厂模式有一个弊端就是需要拓展产品的时候。会修改几乎所有的工厂类。所以使用抽象工厂模式需要对产品的结构划分清晰。
5.总结
抽象工厂模式比工厂方法模式更高级。但LZ光编写这个demo接口抽象类实现类就达到了10个之多。更高的抽象水平意味着更复杂的结构。复杂的结构意味着问题的排查会更加困难。所以合适的项目用合适的结构才是代码清晰，可读性高的条件。项目的架构要依据业务来拓展。最后借用58架构师沈剑的一句话,一切脱离业务的新技术的引入都是耍流氓。
引用
http://blog.csdn.net/zhengzhb/article/details/7359385/
https://www.cnblogs.com/zuoxiaolong/p/pattern6.html