前言
本文分别介绍工厂模式和抽象工厂模式，放一起讲有助于大家对他们的区分。
会以同一个例子从工厂模式到抽象工厂模式递进。
工厂模式(Factory Pattern)
是 Java 中最常用的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
优点：
１．一个调用者想创建一个对象，只要知道其名称就可以了
２．扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以
３．屏蔽产品的具体实现，调用者只关心产品的接口
优点很好的体现了开闭原则里的闭。
缺点：
工厂模式在开发中又被分为简单工厂模式，工厂方法，
1. 简单工厂中，每次增加一个产品时，都需要增加一个具体类和 修改对工厂类里的创建方法，违背了 “不修改代码”的原则
2. 工厂方法中，每次增加一个产品族时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度 上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
所以，创建复杂对象时适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，就不要使用工厂模式了，只会增加系统的复杂度
使用场景
在我们明确地知道不同条件下创建功能类似的不同实例时，而每个实例对象内部是复杂的实现，就适合使用工厂模式了。比如下面Shape例子，每个Shape子类的绘制都是复杂的实现，而这些逻辑不需要暴露给使用者，使用者只要在不同情况下明确要使用的实例就可以了。
1.日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方
2.数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时
3.设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口
工厂模式实现
最经典的就是 《21中设计模式》中的例子了，我们引用上面的 创建Shape的例子。类的关系如图：
定义图形接口 Shape,一个draw方法供子类Circle,Square,Rectangle实现。通过工厂类ShapeFactory创建指定的Shape子类。
public interface Shape {
void draw();
}
子类实现
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
工厂对象ShapeFactory实现，
public class ShapeFactory {
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
这就是工厂模式，包含了简单工厂，工厂方法。因为现在只有一个产品 Shape所以，缺点还没有暴露出来，而简单工厂的缺点就已经可以看到了。
每当增加一个shape子类都需要修改Shape工厂的创建。不过我们可以结合反射，我们可以优化创建的方法，规避这个缺点
public class ShapeFactory {
public static Object getClass(Class<?extends Shape> clazz) {
Object obj = null;
try {
obj = Class.forName(clazz.getName()).newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}
}
抽象工厂模式(Abstract Factory Pattern)
理解了工厂模式后，抽象工厂模式是在工厂模式的基础上对工厂进行抽象的一种模式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类 每个生成的工厂都能按照工厂模式提供对象。
优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：
产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体工厂的里面加代码。
使用场景
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，无需指定它们具体的类情况下创建需要使用的接口实现。
当我们开发的系统产品有多于一个的产品族，而系统某些功能只消费其中某一族的各种产品，这时候就适合用抽象工厂模式
抽象工厂模式实现
还是以经典的Shape为例，类关系图：
这里我们Shape工厂类没有变化，新增了一个产品族Color，对应的产品类Red,Green,Blue以及对应的工厂类 ColorFactory。 到这里就是工厂方法的体现了，每当增加一个产品族时就会增加很多类，增加了系统复杂度。
public interface Color {
void fill();
}
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
把ShapeFactory, ColorFactory当做一个产品使用工厂模式，对Shape工厂, Color工厂进行抽象
public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}
然后让它们各自实现抽象出来的接口，实现创建产品的方法
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
@Override
Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("RED")){
return new Red();
} else if(color.equalsIgnoreCase("GREEN")){
return new Green();
} else if(color.equalsIgnoreCase("BLUE")){
return new Blue();
}
return null;
}
}
然后就跟我们的工厂模式一样，创建一个专门创建工厂的工厂类
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
} else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
测试
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//获取形状为 Circle 的对象
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("Green");
//调用 Green 的 fill 方法
color2.fill();
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
//调用 Blue 的 fill 方法
color3.fill();
}
}
验证输出。
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.
这样就实现了抽象工厂模式，所以在掌握了工厂模式后，其实抽象工厂模式大家也就掌握了。
总结
实际上工厂模式不难掌握，难的是在什么时候使用这种模式，什么时候才能判断对象是不是复杂对象，这个就很考验我们面向对象设计的能力了。
