DesignMode_EasyFactory

简单工厂设计模式--其实就是将面向对象的三大特性玩的很深入的体现，封装，继承，和多态

情景 ：要求用面向对象的思想来写一个计算器

思路 ：要实现还是很简单的，有因数和运算两个主要的元素，但是代码的复用性高不高，灵活性也很差，基本上只能在自己的电脑上运行，而不能拿去别人复用

下面展示简易版的初级计算器

package easyFactory;

import java.util.Scanner;

import org.junit.Test;

/* 这是一个初入门的程序员干的，把所有的运算和逻辑都放在一个类中
 * */

public class LowCounter {
    private double NumberA;
    private double NumberB;
    @Test
    public void testCalculation() {
        System.out.println("please input the first number!");
        Scanner in = new Scanner(System.in);
        NumberA = in.nextDouble();
        System.out.println("please input the next number!");
        NumberB =  in.nextDouble();
        
        System.out.println("please choose the operation sign (+,-,*,/)");
        String sign = in.next();
        System.out.println("sign"+sign);
        double result = 0;
        try{
            switch(sign){
                
                case "+" : result = NumberA + NumberB;
                            System.out.println("result : "+result);
                            break;
                case "-" : result = NumberA - NumberB;
                            System.out.println("result : "+result);
                            break;
                case "*" : result = NumberA * NumberB;
                            System.out.println("result : "+result);
                            break;
                case "/" : if(NumberB == 0){
                                System.out.println("除数不能为0");
                                
                            }else{
                                result = NumberA / NumberB;
                                System.out.println("result : "+result);
                                
                            }
                            break;
                }
            System.out.println("result : "+result);
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        System.out.println("Final result : "+result);
        
    }
}

上面的计算器，可用性不高，每次如果要改代码的话还要到源代码里面去找到相应的内容然后去改，例如你要添加一个开根号的运算，就需要在新的case里面加上相应的操作和条件，耦合度很高，不易维护和扩展。所以我们可以更抽象的出来一些更普遍的类，其实就是一个把具体的实践动作变成更抽象的类，然后继承，封装，随后我们就可以用到多态的方法，进行更方便的添加和维护代码。

运算类的代码 -- 要拥有相应的属性和能体现智能性的方法，也就是可以被重写而体现多态性的方法

package easyFactory;

/* 统称的运算类
 * */

public class Operation {
    private double NumberA;
    private double NumberB;
    private double result;
    public Operation() {
        
    }
    public void setNumberA(double numberA) {
        NumberA = numberA;
    }
    public void setNumberB(double numberB) {
        NumberB = numberB;
    }
    public double getNumberA() {
        return NumberA;
    }
    public double getNumberB() {
        return NumberB;
    }
    // 多态 -- 方法多态：继承与重写必须
    public double getResult() {
        return result;
    }
}

加法类

package easyFactory;

public class AddOperator extends Operation{
    
    @Override
    public double getResult(){
        return super.getNumberA()+super.getNumberB();
    }
}

减法类

package easyFactory;

public class MinusOperator extends Operation{
    
    public double getResult(){
        return super.getNumberA()-super.getNumberB();
    }
}

乘法类

package easyFactory;

public class MultiOption extends Operation{
    
    public double getResult(){
        return super.getNumberA() * super.getNumberB();
    }
}

除法类

package easyFactory;

public class DivisionOperator extends Operation{

    
    public double getResult(){
        double result = 0;
        try{
            if(super.getNumberB() == 0){
                System.out.println("除数不能为0");
            }else{
                result = super.getNumberA()/super.getNumberB();
            }
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return result;
    }
}

得到相应的运算的工厂类

package easyFactory;


/* 将用户的选择操作实例化对象需要一个工厂
 * 
 * */

public class OptionFactory {
    public Operation createOperation(String op){
        Operation oper = null; // 目前还不知道具体的是什么
        switch(op){
        case "+":oper = new AddOperator();
                break;
        case "-":oper = new MinusOperator();
                break;
        case "*":oper = new MultiOption();
                break;
        case "/": oper = new DivisionOperator();
                break;
        }
        return oper;
    }
    
}

客户端的代码 -- 调用一些工厂里面的类就很方便了

package easyFactory;

import java.util.Scanner;

import org.junit.Test;

/*
 * 客户端代码
 * */

public class ClientCode {
    @Test
    public void test(){
        System.out.println("please input the first NUMBER");
        Scanner in = new Scanner(System.in);
        double a = in.nextDouble();
        Operation oper;
        System.out.println("please input the second NUMBER");
        double b = in.nextDouble();
        System.out.println("please input the operation u want");
        OptionFactory factory = new OptionFactory();
        
        
        oper = factory.createOperation(in.next());
        oper.setNumberA(a);
        oper.setNumberB(b);
        System.out.println("result : "+ oper.getResult());
    }
}

所以，我来稍微总结一下，当一个我们要写的一个操作不止一种可能性的时候，就可以采用简单工厂的模式，将这些操作都继承于一个总的操作，里面包含一个基本要做的方法，然后，分支到各个其他的可能性里面去，进行重写，得到相应的不同的结果，其实这个就是多态的含义，方法多态性，从上面的例子可以看出多态最基本的要遵守的条件就是继承和重写。

从客户端的代码就可以看到，这种代码写出来的可复用性很强，并且耦合度也非常的低