工厂模式（Factory Pattern）
类型：创建型模式
主要解决对象：一个接口有多个实现类时，调用端需要知道每个实现类的构造函数才能创建不同的实例。
解决方法：创建工厂类，所有接口的子类实例都在工厂中实现。
工厂模式主要分为简单工厂模式、工厂方法模式和抽象工厂模式，三者结构层层递进。
1.简单工厂模式
简单工厂模式
我们常说的工厂模式其实就是简单工厂模式。简单工厂模式有一个具体的工厂类，可以进行一个接口中所有实现类的实例化。因为简单工厂类负责生产、功能固定，所以基本采用静态方法的形式实现，代码实现如下：
//Shape.java--接口
public interface Shape {
void draw();
}
//Rectangle.java--实现类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Rectangle!");
}
}
//Circle.java--实现类
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle!");
}
}
//ShapeFactory.java--可创建接口中所有实现类的对象
//客户想要获取任意Shape实现类，调用该工厂类即可。
public class ShapeFactory {
public static final int RECTANGLE = 0;
public static final int CIRCLE = 1;
public static Shape getShape(int type){
if(type == RECTANGLE){
return new Rectangle();
}else if(type == CIRCLE){
return new Circle();
}
return null;
}
}
简单工厂模式虽然完成了工厂模式主要功能，但工厂类单一，需要负责所有实现类的创建。当实现类越来越多的时候，工厂类的代码就会非常臃肿，而且扩展时需要考虑工厂类内部逻辑，违背了高聚合的原则。因此，就有了改进后的工厂方法模式。
2.工厂方法模式
工厂方法模式
工厂方法模式，也是通过工厂类进行一个接口中实现类的实例化。但不同的是，每个工厂只负责一个接口实现类的实例化。与此同时，工厂类也在原有的基础上抽象出一个抽象工厂类。在获取实例时，客户只需要知道具体工厂名称就可以得到所要的实例。代码实现如下：
//Shape.java--需实现的接口
public interface Shape {
void draw();
}
//Rectangle.java--实现类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Rectangle!");
}
}
//Circle.java--实现类
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle!");
}
}
//AbstractFactory.java--抽象工厂接口
public interface AbstractFactory{
public Shape getShape();
}
//RectangleFactory.java--工厂实现类
public class RectangleFactory implements AbstractFactroy{
public Shape getShape(){
System.out.println("Create Rectangle!");
return new Rectangle();
}
}
//CircleFactory.java--工厂实现类
public class CircleFactory implements AbstractFactroy{
public Shape getShape(){
System.out.println("Create Circle!");
return new Circle();
}
}
//Main.java--客户实例化
public class Main{
public static void main(String[] args){
try{
AbstractFactory af = new RectangleFactory(); //客户只需关注应该使用哪个工厂
Shape shape = af.getShape();
shape.draw();
}catch(Exception e){
System.out.println(e.getMessage());
}
}
}
相比于简单工厂模式，工厂方法模式为每一个实现类创建了一个工厂。这样，当接口需要扩展实现类时，就可以为其同步添加新的工厂（实现抽象工厂接口），而不需要修改以前类中的代码逻辑。体现了对扩展开放，对修改关闭的原则。
工厂方法模式虽然对简单工厂模式改进，但缺点也是显而易见：
- 为每一个实现类添加工厂，类的个数大大增加，复杂度也因此提升；
- 每一个具体工厂只能创建一种实现类；
- 一个抽象工厂只创建一个接口下的实现类（这个问题在简单工厂模式中同样存在）。
因此，继续在简单工厂模式和工厂方法模式下改进，便得到了抽象工厂模式。
3.抽象工厂模式
抽象工厂模式
抽象工厂模式解决了系统中有多个接口的多个实现类，客户需要调用任一接口的一个实现类的方法的情况。抽象工厂模式提供了一个创建一系列相关或相互依赖的对象的接口，而无需指定它们具体的类。从类图中可以看出，抽象工厂模式相对于是对简单工厂模式和工厂方法模式的整合。代码实现如下：
//Shape.java--接口1
public interface Shape {
void draw();
}
//Square.java--实现类1.1
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
//Circle.java--实现类1.2
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
//Color.java--接口2
public interface Color {
void fill();
}
//Red.java--实现类2.1
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
//Green.java--实现类2.2
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}
//Blue.java--实现类2.3
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
//AbstractFactory.java--抽象工厂，客户直接调用该工厂类获取实例
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape) ;
}
//ShapeFactory.java--接口1工厂类
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();
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
//ColorFactory.java--接口2工厂类
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
public 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;
}
}
//FactoryProducer.java--工厂生成器，用于创建具体的工厂
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;
}
}
抽象工厂模式相当与实现了两次简单工厂模式：对每个接口创建相应的工厂，可以得到具体的实现类实例；再对每个工厂创建一个工厂生成器（即工厂的工厂），用于创建具体的工厂。