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

为什么要用设计模式

使用设计模式的好处:使得程序能够增强了极大的* 维护性,复用性,扩展性和灵活性*

设计模式一:简单工厂模式

举例子引出设计模式:

用面向对象的方式实现一个计算器，输入两个数和运算符号，得到结果

不用设计模式的情况实现:

public class Calculator {
    //设计一个计算器程序,输入两个数和一个操作符:得到结果
    public double getResult(double number1,double number2,char operator){
        switch(operator){
        case '+':return number1+number2; 
        case '-':return number1-number2;
        case '*':return number1*number2;
        case '/':
              if(number2==0){
                  throw new RuntimeException("除数不能为0");
              }
              return number1/number2;
        default:throw new RuntimeException("输入的操作符无效");
        }
    }
    //主方法测试调用
     public static void main(String[] args) {
        Calculator cal=new Calculator();
        System.out.println(cal.getResult(3, 0, '/'));
    }

}
/*
     * 当前程序满足了基本的四则运算，但是作为一个计算器来讲,其功能远远不止这些,当在加入一个求余数的计算时候,
     * 又不得不重新修改这个程序，这就违背了程序设计时候的开放封闭原则，即就是开放扩展，关闭修改，
     * 这个原则我们后面会总结到,并且，当前的程序还很小，如果遇到了大的程序,那对程序的修改相当于大换血,如果中间还有多处
     * 引用的话，那么修改将会是致命的，整个项目有推倒重来的危险，因此，当前程序要增加功能的话,就得遵照开放封闭原则，
     * ,那么，该如何扩展呢，我们仔细分析,不难得到，几种运算他们都有一个共同的特性，就是都干了一件事:运算。只是不同的
     * 运算其内部实现不同而已，那像这种有共同特性,又便于扩展的,我们当然想到了用接口来设计它比较合适，当再有新运算时候，
     * 新建一个类，实现该接口，并且实现自己的运算方法岂不快哉，好,修改之后的程序是酱紫的
     */

使用设计模式改良之后

package 大话设计模式.简单工厂模式.模式修改1;
/**
 * 定义接口Calculator,用于定义计算器的实现标准:两个数值和一个计算方法
 * @author acer
 *
 */
public abstract class Calculator {
    private  double number1;
    private  double number2;

    public double getNumber1() {
        return number1;
    }

    public void setNumber1(double number1) {
        this.number1 = number1;
    }

    public double getNumber2() {
        return number2;
    }

    public void setNumber2(double number2) {
        this.number2 = number2;
    }
    //定义计算方法
    public abstract double getResult();
}


//定义加法实现类，继承接口，并重写接口中的计算方法，实现具体的加法运算功能
package 大话设计模式.简单工厂模式.模式修改1;

public class AddCal extends Calculator{

    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return this.getNumber1()+this.getNumber2();
    }
}
//定义减法实现类，继承接口，并重写接口中的计算方法，实现具体的减法运算功能
package 大话设计模式.简单工厂模式.模式修改1;

public class JianCal extends Calculator{

    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return this.getNumber1()-this.getNumber2();
    }

}
//定义乘法实现类，继承接口，并重写接口中的计算方法，实现具体的乘法运算功能
package 大话设计模式.简单工厂模式.模式修改1;

public class MulCal extends Calculator{

    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        return this.getNumber1()*this.getNumber2();
    }

}
//定义除法实现类，继承接口，并重写接口中的计算方法，实现具体的除法运算功能
package 大话设计模式.简单工厂模式.模式修改1;

public class DevCal extends Calculator{

    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        if(this.getNumber2()==0){
            throw new RuntimeException("除数不能为0");
        }
        return this.getNumber1()/this.getNumber2();
    }

}
//定义求余数实现类，继承接口，并重写接口中的计算方法，实现具体的求余数运算功能
package 大话设计模式.简单工厂模式.模式修改1;

public class YuCal extends Calculator{

    @Override
    public double getResult() {
        // TODO Auto-generated method stub
        if(this.getNumber2()==0){
            throw new RuntimeException("除数不能为0");
        }
        return this.getNumber1()%this.getNumber2();
    }

}
//定义工厂类:根据不同的输入运算符实例化出不同的对象
public class Factory {
    public Calculator getCal(char c){
     switch(c){
        case '+':return new AddCal(); 
        case '-':return new JianCal();
        case '*':return new MulCal();
        case '/':return new DevCal();
        case '%':return new YuCal();
        default:throw new RuntimeException("输入的操作符无效");
     }
 }
}
//定义主方法测试:
public static void main(String[] args) {
        Factory t=new Factory();
        Calculator cal=t.getCal('/');
        cal.setNumber1(3);
        cal.setNumber2(0);
        System.out.println(cal.getResult());

    }
    //当程序再需要增加其他计算功能时候,只要创建一个子类,实现重写并实现具体方法.之后,在工厂类中增加一种需要实例化该新对象的条件即可,使得程序与程序之间的耦合度降低了

引出简单工厂模式的概念，为什么要用这种设计模式

因为在这里，在创建了多个不同运算类型之后，到底要实例化谁，将来会不会增加实例化的对象，比如我们可能又会加入一个新的运算也尤未可知，这就是很容易变化的地方，因此应该考虑用一个单独的类来做这个创造实例的过程，这个类就是工厂类，这种设计方法就是设计模式