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

朴灿烈づ我的快乐病毒、 2022-09-22 03:43 163阅读 0赞

# 为什么要用设计模式 #

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

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

## 举例子引出设计模式: ##

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

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

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

###  ###

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

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