第8章《工厂方法模式》

1、工厂方法和简单工厂的对比：

1.1、添加新功能时，二者的区别：

(1)简单工厂需要完成工作：添加一个新功能类＋更改工厂类

(2)工厂方法需要完成工作：添加一个新功能类＋添加一个生成对象的工厂＋更改客户端实例化工厂的代码

1.2、二者共同点：集中封装了对象的创建，使得要更换对象时，不需要做大的动作就可实现，降低了客户端程序和产品对象的耦合。

2、工厂方法的优点：

2.1克服了简单工厂的缺点：

简单工厂方法在添加新功能时，需要更改工厂类，这违背了开放－封闭原则。工厂方法通过将工厂类抽象为：接口抽象工厂＋多个具体生成对象的工厂，保证了在新增功能时，只需要通过添加：一个生成对象的工厂＋一个新功能类，即可。如果一定要说有改写代码的地方，那就是客户端，需要添加实例化工厂的代码。此外，再无其它对方的代码修改操作。

实质：将简单工厂的内部逻辑转移到了客户端代码来进行。之前你添加功能时，都是修改工厂类，现在是修改客户端代码。

2.2、保持了简单工厂的优点：

封装了对象的创建过程。

3、工厂方法的缺点：

3.1、工厂方法的缺点也是由其优点带来的：每增加一个功能类时，需要增加一个具体对象生成的工厂类，从而增进了额外的开发量。

3.2、选择判断问题依旧存在。

简单工厂方法在选择实例化哪一个功能类时，是在工厂类里面选择的；而工厂方法则是在客户端决定的，由客户端决定实例化哪一个工厂类，从而确定了实例化哪一个功能类。

 

4、工厂方法模式的准确定义：

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

5、工厂方法的UML图：

      

6、工法的模拟例子：实现加减运算的计算器

6.1、UML类图

6.2、code

依次为：Operation，AddOperation，SubOperation，MulOperation，DivOperation；

CreateFactory，AddFactory，SubFactory，SubFactory，MulFactory，DivFactory；

Client；

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:32
 * @ProjectName: JavaBaseTest
 */
public interface Operation {
    void setFirst(int first);
    void setSecond(int second);
    int  getResult();
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:30
 * @ProjectName: JavaBaseTest
 */
public class AddOperation implements Operation {
    private int first,second;

    @Override
    public void setFirst(int first) {
        this.first=first;
    }

    @Override
    public void setSecond(int second) {
        this.second=second;
    }

    public int getResult(){
        return first+second;
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:43
 * @ProjectName: JavaBaseTest
 */
public class MulOperation implements Operation {
    private int first,second;

    public void setFirst(int first) {
        this.first = first;
    }

    public void setSecond(int second) {
        this.second = second;
    }

    @Override
    public int getResult() {
        return first*second;
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:43
 * @ProjectName: JavaBaseTest
 */
public class MulOperation implements Operation {
    private int first,second;

    public void setFirst(int first) {
        this.first = first;
    }

    public void setSecond(int second) {
        this.second = second;
    }

    @Override
    public int getResult() {
        return first*second;
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:44
 * @ProjectName: JavaBaseTest
 */
public class DivOperation implements Operation {
    private int first,second;

    public void setFirst(int first) {
        this.first = first;
    }

    public void setSecond(int second) {
        this.second = second;
    }

    @Override
    public int getResult() {
        try{
            return first/second;
        }catch (Exception e){
            return 0;
        }
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:33
 * @ProjectName: JavaBaseTest
 */
public interface CreateFactory {
    Operation getOperation();
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:34
 * @ProjectName: JavaBaseTest
 */
public class AddFactory implements CreateFactory {
    @Override
    public Operation getOperation() {
        return new AddOperation();
    }

}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/3 23:36
 * @ProjectName: JavaBaseTest
 */
public class SubFactory implements CreateFactory {
    @Override
    public Operation getOperation() {
        return new SubOperation();
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/6 11:43
 * @ProjectName: JavaBaseTest
 */
public class MulFactory implements CreateFactory {
    @Override
    public Operation getOperation() {
        return new MulOperation();
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/6 11:43
 * @ProjectName: JavaBaseTest
 */
public class DivFacotry implements CreateFactory {
    @Override
    public Operation getOperation() {
        return new DivOperation();
    }
}

package designmodel.eighthchapter;

/**
 * @Author: cxh
 * @CreateTime: 18/1/6 11:44
 * @ProjectName: JavaBaseTest
 */
public class Client{
    public static void main(String[] args) {
        CreateFactory factory;
        Operation operation;

        //加法
        factory=new AddFactory();
        operation=factory.getOperation();
        operation.setFirst(11);
        operation.setSecond(22);
        System.out.println("11+22="+operation.getResult());

        //减法
        factory=new SubFactory();
        operation=factory.getOperation();
        operation.setFirst(11);
        operation.setSecond(22);
        System.out.println("11-22="+operation.getResult());

        //乘法
        factory=new MulFactory();
        operation=factory.getOperation();
        operation.setFirst(11);
        operation.setSecond(22);
        System.out.println("11*22="+operation.getResult());

        //除法
        factory=new DivFacotry();
        operation=factory.getOperation();
        operation.setFirst(22);
        operation.setSecond(11);
        System.out.println("22/11="+operation.getResult());
    }
}

输出：

11+22=33
11-22=-11
11*22=242
22/11=2

参考书籍：《大话设计模式》－程杰