软件工程个人作业02

程序设计思想：

         大体的思路还是不变，用生成随机数的方式生成若干个操作数，并且设置不同的参数来控制算术题的格式。但是这次的程序有了新的需求，而且新的需求实现过程更加困难，若是还是按照结构化思想来解决问题，将面临巨大的困难。所以，此次我用面向对象的方法来解决问题。

         将算术式封装成一个类，用字符串来存放一个算式。在这个类中，主要的问题还是如何构造算式。运算符、操作数和操作数的个数都可以用随机数来生成。但是，有三项难题需要解决：控制乘除有没有余数、加减有没有复数和控制有没有括号。要控制结果首先需要求出结果。现在已经不再是2个数一种运算符的求值了。多个数、多个优先级的运算符还有括号需要考虑，这是不可能在生成运算符和操作数时就可以得到正确结果的。所以我用到了数据结构中学到的一种算法——应用栈将中缀表达式化为后缀表达式，然后计算表达式结果。这个算法是去年学的，算法的步骤我还记忆犹新，但是实现的细节已经不太熟了，怎出这个算法也是花了我不少时间。第二个问题就是在支持余数的情况下怎么运算。整型的数据相除必然还会是整型数据，这样肯定得不到正确答案，所以为了解决这个问题，我还设计了另一个类Fraction类用来进行分数的运算符。将整数都化为分数，最后得到的结果就都是准确结果了。第三个问题，怎么让式子中包含括号。这个问题倒是真的难倒我了。想来想去我也只有一个办法，大致想法是先在第N个操作数前插入前括号，然后在第N+2个操作数后插入后括号，N为大于0小于操作数个数的一个随机数。这个方法基本上解决了问题，但是这只能为一个算式插入一对括号。

程序源代码：

         因为怎个程序代码较长，所以以下仅展示核心类的实现。

public class Equation {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean flag = true;
        boolean sc = flag,fs=flag,kh=flag,fus=flag;
        int mun = 0,beg=0,end=100;
        
        Scanner scan = new Scanner(System.in);
        while(flag){
            try{
                System.out.println("请输入表达式的个数：");
                mun = scan.nextInt();
                System.out.println("是否支持乘除法？（true/false）");
                sc = scan.nextBoolean();
                if(sc){
                    System.out.println("除法是否有余数？（true/false）");
                    fs = scan.nextBoolean();
                }
                System.out.println("是否有括号？（true/false）");
                kh = scan.nextBoolean();
                System.out.println("是否有负数？（true/false）");
                fus = scan.nextBoolean();
                flag = false;
            }catch(Exception e){
                System.out.println("输入错误！请重新输入：");
                flag = true;
            }
        }
        Equation array[] = new Equation[mun];
        for(int i = 0; i < mun; i++){
            array[i] =new Equation(beg,end,(int)(Math.random()*8)+2,sc,fs,kh,fus);
            System.out.println((i+1)+":"+array[i].getExpress()+"="+array[i].getValue());
        }
        scan.close();
    }
    public static final boolean 
        SUPPORT_FRACTION=true,            //支持分数
        NONSUPPORT_FRACTION=false,        //不支持分数
        NONSUPPORT_MINUS=false,            //不支持支持复数
        SUPPORT_MINUS=true,                //支持复数
        NONSUPPORT_MULTIPLICATION=false,//增加常量表示没有乘除法
        SUPPORT_MULTIPLICATION=true,    //表示含有乘除法
        NONSUPPORT_BRACKET=false,        //表示没有括号
        SUPPORT_BRACKET=true;            //表示带括号
    

    private String express,value;
    
/**
 * 2017年3月10日修改记录：
 * 将原来用静态方法生成表达式的方法该为用构造方法生成表达式，更加符合面向对象的程序设计思路。
 * */    
    public Equation() {
        // TODO Auto-generated constructor stub
        this(0,100,10,true,true,true,true);
    }
    public Equation(int beg,int end,int n){
        this(beg,end,n,true,true,true,true);
    }
    public Equation(boolean mul,boolean fraction,boolean bra,boolean minus){
        this(0,100,10,mul,fraction,bra,minus);
    }
     public Equation(String e){
        express = e;
        try {
            evaluation(true,true);
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }
    public Equation(int beg,int end,int m,boolean mul,boolean fraction,boolean bra,boolean minus)
    //beg表示操作数的最小值，end表示最大值，n表示操作数的个数，
    //mul表示是否支持乘除，bra是否支持括号，minus表示是否有负数，fraction表示是否支持分数
    {
        createExpress(beg,end,m,mul,fraction,bra,minus);
        //计算结果                
        boolean tag = true;
        while(tag){
            try {//如果计算结果时出现异常，将递归调用本方法为对象重新赋值
                this.evaluation(fraction,minus);
                tag = false;
            } catch (Exception e) {
                createExpress(beg,end,m,mul,fraction,bra,minus);
                tag = true;
            }
        }
    }

    //setter and get
    public String getExpress(){return express;}
    
    public void setExpress(String ex){express = ex;}
    
    public String getValue(){return value;}
    
    public String toString(){    
            return express+"="+value;
    }    
    public boolean equals(Equation another)//比较两个算式是否相同
    {
        String str1 = new String(this.express);
        String str2 = new String(another.express);
        str1.replaceAll(" ", "");
        str2.replaceAll(" ", "");
        if(str1.equals(str2))
            return true;

        return false;
    }

    private void createExpress(int beg,int end,int m,boolean mul,boolean fraction,boolean bra,boolean minus)
    //生成一个表达式
    {
        //数组operand存放express中的所有操作数
        int n = m;
        int operand[] = new int[n];
        //operator存放所有操作符
        char operator[] = new char[n];
        //oper存放可选择的操作符,如果mul为false，则没有乘除法
        char[] oper = {'+','-','*','/'};
        if(!mul) {oper[2]='+';oper[3]='-';}
        String ss=new String("");
        for(int i = 0; i < n; i++){
            operand[i] =(int) (Math.random()*(end-beg))+beg;
            operator[i]=oper[operand[i]%4];
            ss =ss+ operand[i]+operator[i];
        }
        
        if(bra&&((int)( Math.random()*100))>50){
            //在这里为express中插入一对括号
            
            int first = (int)(Math.random()*(n-1))+1;//括起来的第一个数
            int next = (int)(Math.random()*(n-1))+1;//括起来的最后一个数
            if(first > next){//如果第一个数比第二个数大，则交换两个数的值
                first = first^next;
                next = first^next;
                first=first^next;
            }
            if(next-first >= 2){//如果next和first的差值小于2，则不执行以下步骤，因为括号中至少有两个数
                //length记下表达式字符串的长度，j记下遍历字符串中数字的个数
                int length = ss.length(),j=0;
                //用字符串建立一个动态字符串。
                StringBuffer temp = new StringBuffer(ss);
                //开始循环遍历字符串
                for(int i=0; i < length; i++){
                    char cc = temp.charAt(i);//取出下标为i的字符
                    if(first==1&&i==0)        //如果括号括起来的第一个数字为表达式中第一个操作数，在表达式最前面插入(
                        temp.insert(0, '(');
                    if(cc > '9' || cc < '0'){//如果当前字符是运算符字符
                        j++;                //表示刚刚遍历一个数字，所以j加一
                        if(j==first-1){        //如果j到达first的前一个位置，在当前字符的后面插入“(”
                            temp.insert(i+1, '(');i++;
                        }
                        if(j==next)            //如果j到达next的位置，在当前字符前面插入一个“）”
                            temp.insert(i, ')');
                    }
                }
                ss = temp.toString();//将动态字符串转换为普通字符串
            }
        }
        express = ss.substring(0, ss.length()-1);
    }
    private void evaluation(boolean yushu,boolean fushu) throws Exception//表达式求值
    {
        //申请一个存放分数的栈和一个存放操作符的栈
        java.util.Stack<Fraction> mStack = new java.util.Stack<Fraction>();
        java.util.Stack<Character> oStack= new java.util.Stack<Character>();
        
        String express = new String(this.express+"#");
        boolean flag = false;//旗帜变量标识上一个字符是否为数字字符
        int i = 0,//字符串的下标变量
                len = express.length();//字符串的长度
        oStack.push('#');
        while(i < len){
            char ch  = express.charAt(i);//取出计算式中第i个字符
            //如果当前字符为空字符，跳过这个字符
            if(ch==' '||ch=='	'||ch=='
')i++;
            //如果是数字
            else if(ch >= '0' && ch <= '9'){
                if(flag){
                    //如果前一个字符为数字字符，从mStack栈中弹出一个分数
                    //乘以10加上ch代表的数字后，再压入mStack栈中。
                    Fraction t1 = mStack.pop();
                    t1 = t1.multiply(10);
                    t1 = t1.add(ch-'0');
                    mStack.push(t1);
                    flag = true;//旗帜变量依然是true,标志当前字符为数字字符
                }else{
                    //如果前一个字符不是数字字符，生成一个新的分数压入mStack中
                    mStack.push(new Fraction(ch-'0'));
                    flag = true;//标志当前字符为数字字符
                }i++;//下一个字符
            }else{
                switch(precede(oStack.peek(),ch)){
                //比较oStack栈顶操作符的优先级和操作符ch的优先级
                case '<'://栈顶操作符的优先级大于ch优先级
                    oStack.push(ch);
                    i++;break;
                case '>':
                    //小于ch优先级,从分数栈中弹出两个分数按照运算符栈顶的操作运算，结果压入分数栈
                    Fraction b = mStack.pop();
                    Fraction a = mStack.pop();
                    Fraction c = calculate(a,oStack.pop(),b);
                    if(!yushu && c.getDenominator() > 1)
                        throw new Exception("计算过程出现余数！");
                    if(!fushu && c.lessThan(new Fraction(0)))
                        throw new Exception("计算过程出现负数！");
                    mStack.push(c);break;
                case '=':
                    //优先级相等的情况
                    oStack.pop();//弹出运算符栈顶的运算符
                    i++;
                    break;
                }
                flag = false;//标志当前字符为运算符
            }
        }
        value=mStack.peek().toString();
        
    }
    private Fraction calculate//将分数pop和peek安照pop2代表的运算符计算
            (Fraction pop, Character pop2, Fraction peek)throws Exception
    {
        // TODO Auto-generated method stub
        if(pop2=='+')
            return pop.add(peek);
        else if(pop2=='-')
            return pop.reduce(peek);
        else if(pop2=='*')
            return pop.multiply(peek);
        else if(pop2=='/')
            return pop.divide(peek);
        return null;
    }
    private static char precede(char s,char t)//比较运算符s和t的优先级
    {
        char tag='<';                                      //临时变量，用来保存比较结果
        switch(s){
            case '+':
                if(t == '*' || t == '/' || t == '(')
                    tag = '<';
                else
                    tag = '>';
                break;
            case '-':
                if(t == '*' || t == '/' || t == '(')
                    tag = '<';
                else
                    tag = '>';
                break;
            case '*':
                if(t == '(')
                    tag = '<';
                else
                    tag = '>';
                break;
            case '/':
                if(t == '(')
                    tag = '<';
                else
                    tag = '>';
                break;
            case '(':
                if(t == ')')
                    tag = '=';
                else if(t == '#')
                    break;
                else
                    tag = '<';
                break;
            case ')':
                if(t == '(')
                    break;
                else
                    tag = '>';
                break;
            case '#':

                if(t == ')')
                    break;
                else if(t == '#')
                    tag = '=';
                else
                    tag = '<';
                break;
        }
     
        return tag;
    }
}

程序结果截图：

项目计划日志：

时间记录日志：

缺陷记录日志：