一、简单工厂模式——设计模式学习笔记

作为一个编程菜鸟，过去在学习设计模式的时候，老师给推荐了一本《大话设计模式》。阅读以后受益匪浅，可惜当初没有坚持看完。
最近有时间了，又重新捡起来学习了一遍，整理了一下笔记，由于本人能力有限，欢迎大家批评指正。

1.简单工厂模式 Static Factory Method

• 属于创建型模式，又叫做静态工厂方法模式。但不属于23种GOF设计模式之一。简单共产模式是由一个工厂对象决定创建出哪一种产品类的实例。
• 碰到问题不应简单的以计算机的方式去思考，只为满足当前的需求，而应该从易于维护、扩展、复用进行考量和设计。
• 面向对象编程思想，通过封装、继承、多态把程序的耦合度降低，只有耦合度下降才可以达到易于维护或扩展的需求。

2.uml类图

3.组成

（1）工厂角色

核心，负责创建所有实例的内部逻辑，其创建产品类的方法可以被外界直接调用，创建所需的产品对象。

（2）抽象产品角色

所创建的所有对象的父类。负责描述所有实例所共有的公共接口。

（3）具体产品角色

创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

4.优缺点

（1）优点

工厂类是整个模式的关键，包含了必要的逻辑判断，根据外界得定的信息，决定究竟应该创建哪个具体类的对象，通过使用工厂类，外界可以从直接创建具体产品对象的尴尬局面摆脱出来，仅仅需要“消费”对象即可。而不必管这些对象究竟如何创建及如何组织，明确了各自的职责和权利，有利于整个软件体系结构的优化。

（2）缺点

由于共产类集中了所有实例的创建逻辑，违反了高内聚责任分配的原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则需要改变工厂类了。

5.实例

（1）需求

根据选择执行加减乘除运算。

（2）代码

a.运算抽象类

package com.longinus.sfm;
public abstract class Operation {
    private double numbleA;
    private double numbleB;

    public double getNumbleA() {
        return numbleA;
    }
    public void setNumbleA(double numbleA) {
        this.numbleA = numbleA;
    }
    public double getNumbleB() {
        return numbleB;
    }
    public void setNumbleB(double numbleB) {
        this.numbleB = numbleB;
    }

    public abstract double getResult();
}

b.具体算法类

package com.longinus.sfm;
public class Add extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        return getNumbleA() + getNumbleB();
    }
}

package com.longinus.sfm;
public class Sub extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        return getNumbleA() - getNumbleB();
    }
}

package com.longinus.sfm;
public class Mul extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        return getNumbleA() * getNumbleB();
    }
}

package com.longinus.sfm;
public class Div extends Operation{
    @Override
    public double getResult() {
        // TODO 自动生成的方法存根
        if(getNumbleB() == 0){
            throw new ArithmeticException();
        }
        return getNumbleA() / getNumbleB();
    }
}

c.工厂类

package com.longinus.sfm;
public class StaticFactory {
    private static Operation opr;
    public static String oprStr = "";

    public static Operation createOprate(String str){
        oprStr = str;

        switch (oprStr) {
        case "+":
            opr = new Add();
            break;
        case "-":
            opr = new Sub();
            break;

        case "*":
            opr = new Mul();
            break;

        case "/":
            opr = new Div();
            break;
        default:
            System.out.println("请输入正确的参数");
            break;
        }

        return opr;
    }
}

d.测试类

package com.longinus.sfm;
public class Test {
    public static void main(String[] args) { 
        Operation opr = StaticFactory.createOprate("+");
        opr.setNumbleA(6);
        opr.setNumbleB(2);
        System.out.println(opr.getResult());

        opr = StaticFactory.createOprate("-");
        opr.setNumbleA(6);
        opr.setNumbleB(2);
        System.out.println(opr.getResult());

        opr = StaticFactory.createOprate("*");
        opr.setNumbleA(6);
        opr.setNumbleB(2);
        System.out.println(opr.getResult());

        opr = StaticFactory.createOprate("/");
        opr.setNumbleA(6);
        opr.setNumbleB(2);
        System.out.println(opr.getResult());
    }
} 

e.输出结果

8.0
4.0
12.0
3.0