设计模式-工厂方法模式学习笔记

Love The Way You Lie 2021-09-30 16:48 270阅读 0赞

**工厂方法模式**

*  ***定义***

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

--------------------

*  ***优缺点***

优点：

1.  相比简单工厂方法模式，工厂方法模式对修改不在开放，满足了开闭原则（工厂类抽象成了父类，判断创建对象的代码放到了客户端）

缺点：

1.  一种对象对应一个工厂，类的数量增加了，程序变得复杂

--------------------

*  ***特点***

1.  抽象出一个工厂父类
2.  工厂子类new出具体产品对象，并返回
3.  新增具体产品对象时，对应新增工厂子类

--------------------

*  ***结构***

Creator:工厂父类，返回一个产品父类的对象

ConcreteCreator:工厂子类，返回一个具体产品类的对象

Product:产品父类，工厂创建对象的父类

ConcreteProduct:具体的产品类，被工厂创建的类

![1619227-20190516040014184-778206659.png][]

--------------------

*  ***代码***

例子：计算器

类图：

![1619227-20190516040717534-1363516848.png][]

工厂父类

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 0:59
     * @ Description：工厂父类
     */
    public interface Creator {
        Operation createOperation();
    }

工厂子类

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 1:00
     * @ Description：加法工厂
     */
    public class AddFactory implements Creator{
        @Override
        public Operation createOperation() {
            System.out.println("加法运算");
            return new Add();
        }
    }

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 1:06
     * @ Description：除法工厂
     */
    public class DivideFactory implements Creator{
        @Override
        public Operation createOperation() {
            System.out.println("除法运算");
            return new Divide();
        }
    }

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 1:08
     * @ Description：乘法工厂
     */
    public class MultiplyFactory implements Creator {
        @Override
        public Operation createOperation() {
            System.out.println("乘法运算");
            return new Multiply();
        }
    }

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 1:09
     * @ Description：减法工厂
     */
    public class SubtractFactory implements Creator{
        @Override
        public Operation createOperation() {
            System.out.println("减法运算");
            return new Subtract();
        }
    }

产品对象父类（算法父类）

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 1:02
     * @ Description：算法父类
     */
    public interface Operation {
        Double getResult(Double num1,Double num2);
    }

具体产品对象类（算法子类）

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 1:01
     * @ Description：加法算法
     */
    public class Add implements Operation{
        @Override
        public Double getResult(Double num1, Double num2) {
            return num1 + num2;
        }
    }

public class Divide implements Operation{
        @Override
        public Double getResult(Double num1, Double num2) {
            return num1 / num2;
        }
    }

public class Multiply implements Operation{
        @Override
        public Double getResult(Double num1, Double num2) {
            return num1 * num2;
        }
    }

public class Subtract implements Operation{
        @Override
        public Double getResult(Double num1, Double num2) {
            return num1 - num2;
        }
    }

客户端调用类

/**
     * @ Author     ：fonxi
     * @ Date       ：2019/5/15 0:50
     * @ Description：客户端调用类
     */
    public class TestController {
        public void print(){
            try {
                Scanner s = new Scanner(System.in) ;
                System.out.println("请输入第一个数字");
                Double num1 = s.nextDouble();
    
                System.out.println("请输入第二个数字");
                Double num2 = s.nextDouble();
    
                System.out.println("请输入运算");
                String operator = s.next();
                Operation operation ;
                Creator creator = null;
    
                try{
                    switch (operator){
                        case "+":
                            creator = new AddFactory();
                            break;
                        case "-":
                            creator = new SubtractFactory();
                            break;
                        case "*":
                            creator = new MultiplyFactory();
                            break;
                        case "/":
                            creator = new DivideFactory();
                            break;
                        default:
                            System.out.println("输入运算符有误");
                            break;
                    }
                }catch (Exception e){
                    System.out.println("输入有误"+e.getMessage());
                }
                operation = creator.createOperation();
    
                System.out.println("运算结果："+operation.getResult(num1,num2));
            }catch (Exception e){
                System.out.println("输入有误"+e.getMessage());
            }
        }
    }

运算结果

请输入第一个数字
    80
    请输入第二个数字
    3
    请输入运算
    /
    除法运算
    运算结果：26.666666666666668

--------------------

*  ***总结***

**工厂方法模式又称工厂模式，23种设计模式的一种，属于创建型模式，它保持了简单工厂模式的优点，又克服了简单工厂模式的缺点，但是在一定程度上增加了程序的复杂度。**

转载于:https://www.cnblogs.com/fonxi/p/10873350.html

[1619227-20190516040014184-778206659.png]: /images/20210724/c84a1f73d53f4c90858ede544f37ed88.png
[1619227-20190516040717534-1363516848.png]: /images/20210724/605375f09f254e5aa4534e4d07b275b2.png