设计模式-简单工厂设计模式

设计模式-简单工厂设计模式

• 简单计算机计算程序

package lesson1;

public class Lession1 {
    
    public static double getResult(double numberA, double numberB, String operater){
        double result = 0;
        // 切记将未知变量进行equals比较,如果变量为Null,则程序异常(空指针 异常)
        /*if(operater.equals("+")){
            result = numberA + numberB;
        }*/
        if("+".equals(operater)){
            result = numberA + numberB;
        }
        if("-".equals(operater)){
            result = numberA - numberB;
        }
        if("*".equals(operater)){
            result = numberA * numberB;
        }
        if("/".equals(operater)){
            result = numberA / numberB;
        }
        
        return result;
    }
    
    public static void main(String[] args) throws Exception{
        double result = getResult(100, 1, "+");
        System.out.println("计算结果:"+result);
        
        result = getResult(100, 1, "-");
        System.out.println("计算结果:"+result);
        
        result = getResult(100, 1, "*");
        System.out.println("计算结果:"+result);
        
        result = getResult(100, 1, "/");
        System.out.println("计算结果:"+result);
        
        //如果不存在
        result = getResult(100, 1, "&");
        System.out.println("计算结果:"+result);
        
        //除数异常
        result = getResult(100, 0, "/");
        System.out.println("计算结果:"+result);
    }
}

在上面程序中:

    上述程序是一个加减乘除计算方法，其中getResult方法返回值为结果;但是可以看出程序有不健壮性，异常处理等为考虑周全，如果需要加校验，可能需要在方法体内加，代码比较臃肿；
        -可维护：
        -可复用
        -可扩展
        -灵活性好

• 优化后

接口定义,提供getResult方法,进行抽象

package lesson1_1;

public interface IOperation {
    
    double getResult(MathParams mathParams);

}

加法实现类

package lesson1_1;

/**
 * 加法
 * @author PRO
 *
 */
public class OperationAdd implements IOperation{

    @Override
    public double getResult(MathParams mathParams) {
        return mathParams.getNumberA() + mathParams.getNumberB();
    }

}

减法实现类

package lesson1_1;

/**
 * 减法
 * @author PRO
 *
 */
public class OperationSub implements IOperation{

    @Override
    public double getResult(MathParams mathParams) {
        return mathParams.getNumberA() - mathParams.getNumberB();
    }

}

乘法实现类

package lesson1_1;

/**
 * 乘法
 * @author PRO
 *
 */
public class OperationMul implements IOperation{

    @Override
    public double getResult(MathParams mathParams) {
        return mathParams.getNumberA() * mathParams.getNumberB();
    }

}

除法实现类

package lesson1_1;

/**
 * 除法
 * @author PRO
 *
 */
public class OperationDiv implements IOperation{
    
    private static void check(MathParams mathParams){
        if (mathParams.getNumberB() == 0) {
            throw new RuntimeException("除法运算(除数不能为0)");
        }
    }

    @Override
    public double getResult(MathParams mathParams){
        check(mathParams);
        return mathParams.getNumberA() / mathParams.getNumberB();
    }

}

计算参数类

package lesson1_1;

/**
 * 计算参数
 * 
 * @author PRO
 *
 */
public class MathParams {

    private double numberA;
    private double numberB;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

}

操作符枚举

package lesson1_1;

/**
 * 操作符枚举
 * @author PRO
 *
 */
public enum OperateEnum {
    
    ADD,
    
    SUB,
    
    MUL,
    
    DIV;

}

操作工厂类

package lesson1_1;

/**
 * 操作代理类
 * @author PRO
 *
 */
public class OperationFactory {
    
    public static IOperation createOperation(OperateEnum operateEnum){
        IOperation operation = null;
        
        switch (operateEnum) {
        case ADD:
            operation = new OperationAdd();
            break;
        case SUB:
            operation = new OperationSub();
            break;
        case MUL:
            operation = new OperationMul();
            break;
        case DIV:
            operation = new OperationDiv();
            break;
        }
        return operation;
        
    }

}

程序入口

package lesson1_1;

public class Main {
    
    
    public static double getResult(double numberA,double numberB,OperateEnum operateEnum){
        IOperation operation = OperationFactory.createOperation(operateEnum);
        MathParams mathParams = new MathParams();
        mathParams.setNumberA(numberA);
        mathParams.setNumberB(numberB);
        return operation.getResult(mathParams);
    }
    
    public static void main(String[] args){
        double result = getResult(1, 2, OperateEnum.SUB);
        System.out.println(result);
        result = getResult(1, 0, OperateEnum.DIV);
        System.out.println(result);
    }
    
}

    上述之后的代码，用到了Java面向对象中抽象(多态)，分装
    -易维护：程序将加减程序都单独抽离开，各自有各自的实现，如果需要修改程序，只需要维护各自实现的getResult方法;
    -易扩展：程序后期如果需要增加其他运算,只需要创建一个class 实现 interface,在getResult进行代码编写,最后在枚举中添加相关的造作符枚举(主要用于限制用户输入参数);

• 简单工厂模式

•   简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
  

• 基本简介

    实现方式
        简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
    
    工厂（Creator）角色
        简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
        
    抽象产品（Product）角色
        简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
        
    具体产品（Concrete Product）角色
        是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
  

• 优缺点

    优点
        工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。
        
    缺点
        由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
        当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；
        这些缺点在工厂方法模式中得到了一定的克服。
        
    使用场景
        工厂类负责创建的对象比较少；
        客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
        由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。