定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到了其子类。

一、经典工厂方法模式

/**
 * 抽象工厂接口，用于创建计算对象
 */
public interface IFactory {
    Calculate getCalculate();
}

/**
 * 抽象计算接口，表示用于实现的业务
 */
public interface Calculate {
    Integer getResult(int a, int b);
}

/**
 * 具体工厂类，实现抽象工厂接口，返回一个具体的计算对象
 */
class AddFactory implements IFactory{
    @Override
    public Calculate getCalculate() {
        return new Add();
    }
}

class SubFactory implements IFactory{
    @Override
    public Calculate getCalculate() {
        return new Sub();
    }
}

class MulFactory implements IFactory{
    @Override
    public Calculate getCalculate() {
        return new Mul();
    }
}

class DivFactory implements IFactory{
    @Override
    public Calculate getCalculate() {
        return new Div();
    }
}

/**
 * 具体操作，实现计算接口
 */
class Add implements Calculate {
    @Override
    public Integer getResult(int a, int b) {
        return a + b;
    }
}

class Sub implements Calculate {
    @Override
    public Integer getResult(int a, int b) {
        return a - b;
    }
}

class Mul implements Calculate {
    @Override
    public Integer getResult(int a, int b) {
        return a * b;
    }
}

class Div implements Calculate {
    @Override
    public Integer getResult(int a, int b) {
        return a / b;
    }
}

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        IFactory factory = new AddFactory();
        Calculate calculation = factory.getCalculate();
        calculation.getResult(1, 2);
    }
}

工厂方法模式优点：与简单工厂相比，工厂方法模式克服了简单工厂违背开放-封闭原则的缺点，又保持了风窗对象创建过程的优点。
简单工厂模式优点：工厂类中包含了必要的判断，根据客户端选择条件，动态实例化相关的类。
工厂方法模式缺点：每增加一个产品，就需要额外的增加一个产品工厂的类，增加了额外的开发量。

小结：可以看出：工厂方法模式实现时，客户端需要决定实例化哪一个工厂，选择判断还是在的；工厂方法把简单工厂的内部逻辑判断移动到了客户端，原来是更改工厂类，现在是更改客户端。

二、《Thinking in java》中改动后的工厂模式（使用匿名内部类，客户端少了实例化具体工厂的步骤）

/**
 * 抽象工厂接口，用于创建计算对象
 */
public interface IFactory {
    Calculate getCalculate();
}

/**
 * 抽象计算接口，表示用于实现的业务
 */
public interface Calculate {
    Integer getResult(int a, int b);
}

/**
 * 具体工厂，使用匿名内部类实现接口
 */
public class AddFactory implements Calculate{
    @Override
    public Integer getResult(int a, int b) {
        return a+b;
    }
    public static IFactory factory = new IFactory() {
        public Calculate getCalculate(){
            return new AddFactory();
        }
    };
}

/**
 * 将改动的工厂类，做实际运算（可以加入扩展方法，实现各个具体工厂）
 */
public class Factories {
    public static Integer getResult() {
        Calculate calculation = AddFactory.factory.getCalculate();
        return calculation.getResult(1, 2);
    }
}

/**
 * 好处：不用改动客户端
 */
public class Test {
    public static void main(String[] args) {
        Integer result = Factories.getResult();
        System.out.println(result);
    }
}

优点：减少了类的创建次数，只需要创建一个工厂类（经典的工厂方法模式在增加产品时，需要创建具体操作类和具体操作工厂类）

可以使用的手段：
1.客户端可以不用修改，只修改Factories类的一个方法（实现了对客户端细节的屏蔽），但只能使用其中一种具体工厂类
2.可增加Factories类中的方法，让其有多个具体操作类的实现，但是客户端此时就需要知道有什么方法了，虽然增加了客户端的负担，但可实现代码的复用