工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）

一、简单工厂模式

简单工厂(Simple Factory)模式又称为静态工厂方法(Static Factory Method)模式，属于类的创建型模式，但其不属于23种GOF设计模式之一，通常它根据自变量的不同返回不同的类的实例。
UML图：

示例代码：

public abstract class Operation {
    double numberA;
    double numberB;
    abstract double getResult();
}

public class AddOperation extends Operation {
    public double getResult() {
        return numberA + numberB;
    }
}
public class MultiplyOperation extends Operation {
    double getResult() {
        return numberA * numberB;
    }
}
public class DivOperation extends Operation {
    double getResult() {
        return numberA / numberB;
    }
}
public class SubOperation extends Operation {

    double getResult() {
        return numberA - numberB;
    }
}
public class OperationSimpleFactory {
    public static Operation createOperate(String operate) {
        Operation oper = null;
        switch (operate) {
        case "+":
            oper = new AddOperation();
            break;
        case "-":
            oper = new SubOperation();
            break;
        case " *":
            oper = new MultiplyOperation();
            break;
        case "/ ":
            oper = new DivOperation();
            break;
        }
        return oper;
    }
}

优点：
1、简单工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
2、让客户端不用管该用哪个类的实例，只要把条件给工厂，工厂自动就给出了实例，客户端只要去做运算就可以了，不同的实例会实现不同的运算。
3、简单工厂实现了责任的分割。

缺点：
1.如果要加一个新的功能，就要在原有方法中加一个分支条件，就要修改原有的类，违背了开放-封闭原则，于是工厂方法就来了

二、工厂模式

1、工厂方法模式定义了一个创建对象的接口。
2、由子类决定实例化的类是哪一个。
3、工厂方法使一个类的实例化延迟到其子类。

UML图：

先构建一个工厂接口

public interface IFactory {
    Operation CreateOperation();
}

然后加减乘除各建一个具体工厂去实现这个接口

public class AddFactory implements IFactory {
    public Operation CreateOperation() {
        return new AddOperation();
    }

}
public class SubFactory implements IFactory {
    public Operation CreateOperation() {
        return new SubOperation();
    }
}
public class MulFactory implements IFactory {
    public Operation CreateOperation() {
        return new MultiplyOperation();
    }
}
public class DivFactory implements IFactory {
    public Operation CreateOperation() {
        return new DivOperation();
    }
}
public class IFactoryImplement {
    public static void main(String[] args) {
        IFactory operFactory = new AddFactory();
        Operation oper = operFactory.CreateOperation();
        oper.numberA = 1;
        oper.numberB = 2;
        double result = oper.getResult();
        System.err.println(result);
    }
}

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。如果要加功能，本来是改工厂类的，而现在是修改客户端

小结：
1、 一个抽象产品类，可以派生出多个具体产品类，一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类只能创建一个具体产品类的实例。
2、工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。
3、它们都是集中封装了对象的创建，使得要更换对象时，不需要做大的改动就可实现，降低了客户程序与产品对象的耦合。
4、工厂方法模式是简单工厂模式的进一步抽象和推广，由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。
5、缺点是由于每加一个产品，就需要加一个产品工厂的类，增加了额外了开发量。

三、抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

示例代码：

public interface Fridge {
    void make();
}
public interface TV {
    void make();
}
public class HisenseFridge implements Fridge {
    public void make() {
        System.out.println("海信制造的冰箱");

    }
}
public class HaierFridge implements Fridge {
    public void make() {
        System.out.println("海尔制造的冰箱");
    }
}
public class HisenseTV implements TV {
    public void make() {
        System.out.println("海信制造的电视");
    }
}
public class HaierTV implements TV {
    public void make() {
        System.out.println("海尔制造的TV");
    }
}
public interface IFactory {
    Fridge createFridge();
    TV createTV();
}
public class HaierFactory implements IFactory {
    public Fridge createFridge() {
        return new HaierFridge();
    }
    public TV createTV() {
        return new HaierTV();
    }
}
public class HisenseFactory implements IFactory {
    public Fridge createFridge() {
        return new HisenseFridge();
    }
    public TV createTV() {
        return new HisenseTV();
    }
}
public class AbstractFactoryTest {

    public static void main(String[] args) {
        IFactory haierFactory = new HaierFactory();
        Fridge haierFridge = haierFactory.createFridge();
        TV haierTV = haierFactory.createTV();
        haierFridge.make();
        haierTV.make();

        IFactory hisenseFactory = new HisenseFactory();
        Fridge hisenseFridge = hisenseFactory.createFridge();
        TV hisenseTV = hisenseFactory.createTV();
        hisenseFridge.make();
        hisenseTV.make();
    }

}

小结：
1、多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 2、一个抽象工厂类，可以派生出多个具体工厂类。
3、 每个具体工厂类可以创建多个具体产品类的实例。

参考资料设计模式PPT