软件工程个人作业03

设计思想：在‘四则运算二’的基础上加上新的功能。首先，对上一个的源代码，进行一次优化。然后加上我新的功能。

1）计算题目答案功能，把实现的语句加入到判断的方法体中。我会代表分子的一个数组和一个分母的数组，加上一个运算符的数组，记录题目计算的中间

过程。根据四则运算的规则，先算乘除，后算加减。所以第一次遍历运算符数组，计算乘除法的计算，把两个数的结果记录到后一个的分子和分母上，同时前一个数的分子赋值为0，两数中间的运算符修改为+号。第二次遍历计算加减，依次从左到又依次计算。最后的答案为运算数数组中最后一个数，一个分母，一个分子，在进行化简。

2）打印对齐。我会根据运算式的种类（2个数或者多项式），定义两个长度，如果运算式的长度小于定义长度，则输出空格，直至与定义长度相同

3）除法与分数区别开，分数用括号区分开来。

4）最后会对题目是否有乘除法、题目是否有括号、取值范围、加减有无负数、除法有无余数、题目中是否包含分数这六个参数进行整合。

源程序代码：

//范亚雷    2016年03月21号
//二柱子问题第三次编写


import javax.swing.JOptionPane;
import java.util.Arrays;

class DateANDShow{
    int[] Parameter=new int[6];       //分别对应6个参数的一个长度为6的数组
    int[] z=new int[11];int z1;       //随机产生加减乘除的四则运算（0+；1-；2*；3/）
    int[] Num1=new int[10];           //代表可能的多项式运算的运算数或分子
    int[] Num2=new int[10];           //代表可能的多项式运算的分母
    int Magnification=0;                //数值范围
    int OperationNum=2;                 //有括号情况确定运算个数
    int[] Brace_position=new int[6];  //3个括号位置
    String answer=new String();
    String output=new String();
    DateANDShow(){}
    DateANDShow(int a1,int a2,int a3,int a4,int a5,int a6){     //传进可控参数，并确定一些必要数据
        output="";
        Parameter[0]=a1;     //代表是否有乘除法
        
        if(Parameter[0]==0)  //确定题目中有无乘除
            z1=4;            
        if(Parameter[0]==1)
            z1=2;
        
        Parameter[1]=a2;     //代表是否有括号
        
        //确定计算个数
        if(Parameter[1]==0)
            OperationNum=(int)(Math.random()*9+2);
        if(Parameter[1]==1)
            OperationNum=2;
        System.out.println("OperationNum"+OperationNum);
        
        Parameter[2]=a3;     //代表取值范围
        
        //确定取值范围
        if(Parameter[2]==0)
            Magnification=100;
        if(Parameter[2]==1)
            Magnification=200;
        if(Parameter[2]==2)
            Magnification=300;
        if(Parameter[2]==3)
            Magnification=500;
        if(Parameter[2]==4)
            Magnification=1000;
        if(Parameter[2]==5)
            Magnification=5000;
        if(Parameter[2]==6)
            Magnification=10000;
        Parameter[3]=a4;     //代表加减有无负数
        Parameter[4]=a5;     //代表除法有无余数
        Parameter[5]=a6;     //代表题目中是否有分数
    }
     
    public void Generate_random_number(){     //产生随机的数据
        
        //初始化分母
        for(int i=0;i<10;i++)
        {
            Num2[i]=1;
        }
        //产生运算数
        for(int i=0;i<OperationNum;i++)
        {
            Num1[i]=(int)(Math.random()*Magnification);
            
            //随机确定是否为负数,1/14的几率
            int t=(int)(Math.random()*15);
            if(t==10)
                Num1[i]=-Num1[i];
            
            //随机确定是否为分数运算,1/29的几率
            if(Parameter[5]==0)
            {
                 int T=(int)(Math.random()*30);
                 if(T==10)
                    {Num2[i]=(int)(Math.random()*Magnification);}
                 while(Num2[i]==0)
                 {Num2[i]=(int)(Math.random()*Magnification);}
            }
            System.out.println("Num"+Num1[i]);
        
        }
        for(int i=1;i<11;i++)//初始化运算符为非法值
        {
            z[i]=4;
        }
        //产生随机运算符
        for(int i=1;i<OperationNum;i++)
        {
            z[i]=(int)(Math.random()*z1);
            System.out.println("zifu"+z[i]);
        }
        
        //随机确定括号的位置
        if(Parameter[1]==0&&OperationNum>2)
        {
            //初始化括号的位置数组
            for(int j=0;j<6;j++)
                {Brace_position[j]=OperationNum;}
            int i=0;
            if(OperationNum>2&&OperationNum<=5)   //3-5个数运算，随机产生1个括号
                {i=3;}
            if(OperationNum>5&&OperationNum<=7)   //6、7个数运算，随机产生2个括号
                {i=2;}
            if(OperationNum>7&&OperationNum<=10)   //7-10个数运算，随机产生3个括号
                {i=1;}
            switch(i)
            {
             case 0:break;
             case 1:int t1=(int)(Math.random()*10);
                    if(t1==1)
                    {
                        Brace_position[5]=(int)(Math.random()*OperationNum);  //0、1、2、3、4、5。。。OperationNum
                        Brace_position[4]=(int)(Math.random()*OperationNum);
                        
                        while(Brace_position[5]==Brace_position[4]) //排除括号位置相同的情况
                            {Brace_position[4]=(int)(Math.random()*OperationNum);}
                    }
             case 2:int t2=(int)(Math.random()*10);
                    if(t2==1)
                    {
                        Brace_position[3]=(int)(Math.random()*OperationNum);  //0、1、2、3。。。OperationNum
                        while((Brace_position[3]==Brace_position[5])||(Brace_position[3]==Brace_position[4])) //排除括号位置相同的情况
                           {Brace_position[3]=(int)(Math.random()*OperationNum);}
                        Brace_position[2]=(int)(Math.random()*OperationNum);  
                        while((Brace_position[2]==Brace_position[5])||(Brace_position[2]==Brace_position[4])||(Brace_position[2]==Brace_position[3])) //排除括号位置相同的情况
                           {Brace_position[2]=(int)(Math.random()*OperationNum);}
                    }
             case 3:int t3=(int)(Math.random()*10);
                    if(t3==1)
                    {
                        Brace_position[1]=(int)(Math.random()*OperationNum);  //0、1、2、3。。。OperationNum
                        while((Brace_position[1]==Brace_position[5])||(Brace_position[1]==Brace_position[4])||(Brace_position[1]==Brace_position[3])||(Brace_position[1]==Brace_position[2])) //排除括号位置相同的情况
                           {Brace_position[1]=(int)(Math.random()*OperationNum);}
                        Brace_position[0]=(int)(Math.random()*OperationNum);
                        while((Brace_position[0]==Brace_position[5])||(Brace_position[0]==Brace_position[4])||(Brace_position[0]==Brace_position[3])||(Brace_position[0]==Brace_position[2])||(Brace_position[0]==Brace_position[1])) //排除括号位置相同的情况
                           {Brace_position[0]=(int)(Math.random()*OperationNum);}
                    }
                    break;
            }
        }
    }
    public void The_Fraction_In(int a,int b){ //化简分数
        int gcd=1;
        for(int k=2;k<=a&&k<=b;k++)
            {
                if(a%k==0&&b%k==0)
                {gcd=k;}
            }
        a=a/gcd;b=b/gcd;
        System.out.println("答案："+a+"/"+b);
        if(b==1||a==0)
            {answer=""+a;}
        else
            {answer=""+a+"/"+b;}
    }
    public void Judge1(){     //判断是否符合参数（只有两个数运算且没有分数）
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]+Num1[1])<0)&&(Parameter[3]==1))
                {
                   Num1[0]=(int)(Math.random()*Magnification);
                   Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+Num1[0];
            output=output+"+";
            int sum=Num1[0]+Num1[1];
            answer=""+sum;
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            if(Num1[1]>Num1[0]&&Parameter[3]==1)
                {
                int t=Num1[1];
                Num1[1]=Num1[0];
                Num1[0]=t;
                }
            output=output+Num1[0];
            output=output+"-";
            int sum=Num1[0]-Num1[1];
            answer=""+sum;
        }    
       
        if(z[1]==2)
        {
            output=output+Num1[0];
            output=output+"*";
            int sum=Num1[0]*Num1[1];
            answer=""+sum;
           }
           if(z[1]==3)     //排除除法为0和有余数的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
               if(Parameter[4]==1)
               {
                   while((Num1[0]%Num1[1]!=0)||(Num1[1]==0))
                   {
                       Num1[1]=(int)(Math.random()*Magnification+1);
                       Num1[0]=(int)(Math.random()*Magnification);
                   }
               }        
            output=output+Num1[0];
            output=output+"/"; 
            if((Num1[0]%Num1[1]!=0))
             {int sum=Num1[0]/Num1[1];
              answer=""+sum;}
            else
            {answer=""+Num1[0]+"/"+Num1[1];}
            }
 
           output=output+Num1[1]+"=";
           //System.out.println(output+"output");
    }
    public void Judge11(){    //判断是否符合参数（只有两个数运算但第一个为分数）
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]/Num2[0]+Num1[1])<0)&&(Parameter[3]==1))
                {
                   Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"+";
            
            int fenzi=Num1[0]+Num2[0]*Num1[1];
            int fenmu=Num2[0];
            answer=""+fenzi+"/"+fenmu;
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            while(Num1[1]>(Num1[0]/Num2[0])&&Parameter[3]==1)
                {
                Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"-";
            
            int fenzi=Num1[0]-Num2[0]*Num1[1];
            int fenmu=Num2[0];
            answer=""+fenzi+"/"+fenmu;
        }    
       
        if(z[1]==2)
        {
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"*";
            
            int fenzi=Num1[0]*Num1[1];
            int fenmu=Num2[0];
            answer=""+fenzi+"/"+fenmu;
           }
           if(z[1]==3)     //排除除法为0的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
            output=output+Num1[0];
            output=output+"/"; 
            
            int fenzi=Num1[0];
            int fenmu=Num2[0]*Num1[1];
            The_Fraction_In(fenzi,fenmu);
 
           output=output+Num1[1]+"=";
        }
    }
    public void Judge12(){    //判断是否符合参数（只有两个数运算但第二个为分数）
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]+Num1[1]/Num2[1])<0)&&(Parameter[3]==1))
                {
                   Num1[0]=(int)(Math.random()*Magnification);
                }
            output=output+Num1[0];
            output=output+"+";
            
            int fenzi=Num1[1]+Num2[1]*Num1[0];
            int fenmu=Num2[0];
            The_Fraction_In(fenzi,fenmu);
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            while(Num1[0]<(Num1[1]/Num2[1])&&Parameter[3]==1)
                {
                Num1[0]=(int)(Math.random()*Magnification);
                }
            output=output+Num1[0];
            output=output+"-";
            
            int fenzi=Num2[1]*Num1[0]-Num1[1];
            int fenmu=Num2[1];
            The_Fraction_In(fenzi,fenmu);
        }    
       
        if(z[1]==2)
        {
            output=output+Num1[0];
            output=output+"*";
            
            int fenzi=Num1[0]*Num1[1];
            int fenmu=Num2[1];
            The_Fraction_In(fenzi,fenmu);
           }
           if(z[1]==3)     //排除除法为0的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
            output=output+Num1[0];
            output=output+"/"; 
            
            int fenzi=Num2[1]*Num1[0];
            int fenmu=Num1[1];
            The_Fraction_In(fenzi,fenmu);
 
           output=output+"("+Num1[1]+"/"+Num2[1]+")"+"=";
        }
           
    }
    public void Judge13(){    //判断是否符合参数（只有两个数运算但均为为分数）
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]/Num2[0]+Num1[1]/Num2[1])<0)&&(Parameter[3]==1))
                {
                   Num1[0]=(int)(Math.random()*Magnification);
                   Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"+";
            
            int fenzi=Num1[0]*Num2[1]+Num1[1]*Num2[0];
            int fenmu=Num2[0]*Num2[1];
            answer=""+fenzi+"/"+fenmu;
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            while(Num1[0]<(Num1[1]/Num2[1])&&Parameter[3]==1)
                {
                Num1[0]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"-";
            
            int fenzi=Num1[0]*Num2[1]-Num1[1]*Num2[0];
            int fenmu=Num2[0]*Num2[1];
            answer=""+fenzi+"/"+fenmu;
        }    
       
        if(z[1]==2)
        {
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"*";
            
            int fenzi=Num1[0]*Num1[1];
            int fenmu=Num2[1]*Num2[0];
            answer=""+fenzi+"/"+fenmu;
           }
           if(z[1]==3)     //排除除法为0的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
               output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"/"; 
            
            int fenzi=Num1[0]*Num2[1];
            int fenmu=Num2[0]*Num1[1];
            answer=""+fenzi+"/"+fenmu;
 
           output=output+"("+Num1[1]+"/"+Num2[1]+")"+"=";
        }
    }
    public void Judge2(){     //判断是否符合参数（只有两个数运算但有分数参与）
        if(Num2[0]==1&&Num2[1]==1)  //包含分数，但随机确定的均未产生分数
        {
            Judge1();
        }
        else if(Num2[0]!=1&&Num2[1]==1)
        {
            Judge11();
        }
        else if(Num2[0]==1&&Num2[1]!=1)
        {
            Judge12();
        }
        else
        {
            Judge13();
        }
    }
    public void Arithmetic(){              //进行四则运算(没有括号)
        int[] Operator=new int[10];    //运算符
        int[] Num3=new int[10];        //运算数
        int[] Num4=new int[10];        //运算结果的分母
        //The_Fraction_In(a,b);
        for(int i=0;i<OperationNum;i++)      //初始化为0
            {
                Num3[i]=Num1[i];  //运算数写入Num2数组中
                if(Parameter[5]==1)
                 {Num4[i]=1;}
                if(Parameter[5]==0)
                 {Num4[i]=Num2[i];}
                if(i!=0)
                  {Operator[i]=z[i];}  //运算符 写入sum数组中
            }
        //先计算乘除
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==2)
            {
                Num3[i]=Num3[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
            if(Operator[i]==3)
            {
                while(Num3[i]==0)
                       {Num3[i]=(int)(Math.random()*Magnification);}
                    
                Num3[i]=Num4[i-1]*Num3[i];
                Num4[i]=Num4[i]*Num3[i-1];
                Num3[i-1]=0;
                Operator[i]=0;
                //交换分子和分母
                int t;
                t=Num3[i];
                Num3[i]=Num4[i];
                Num4[i]=t;
            }
        }
        //后计算加减
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==0)
            {
                    Num3[i]=Num4[i-1]*Num3[i]+Num4[i]*Num3[i-1];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Operator[i]=0;
            }
            if(Operator[i]==1)
            {
                Num3[i]=Num4[i]*Num3[i-1]-Num4[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
        }
        for(int i=0;i<OperationNum;i++)
        {
            if(Num2[i]!=1)
            {output=output+"(";}
            
            output=output+Num1[i];
            
            if(Num2[i]!=1)
            {output=output+"/"+Num2[i]+")";}
            
            if(z[i+1]==0)
                {output=output+"+";}
            if(z[i+1]==1)
                {output=output+"-";}
            if(z[i+1]==2)
                {output=output+"*";}
            if(z[i+1]==3)
                {output=output+"/";}
        }
        output=output+"=";
        System.out.println("output"+output);
        The_Fraction_In(Num3[OperationNum-1],Num4[OperationNum-1]);
        
    }
    public void Braces_polynomial(){  //进行四则运算（有括号）
        int[] Operator=new int[10];      //运算符
        int[] Num3=new int[10];          //运算数
        int[] Num4=new int[10];          //运算结果的分母
        int[] Brace_position1=new int[6]; //括号位置
        int j=0;                           //代表括号的数量
        int Left=0;int Right=0;
        for(int i=0;i<OperationNum;i++)      //初始化为0
            {
                Num3[i]=Num1[i];  //运算数写入Num2数组中
                if(Parameter[5]==1)
                 {Num4[i]=1;}
                if(Parameter[5]==0)
                 {Num4[i]=Num2[i];}
                if(i!=0)
                  {Operator[i]=z[i];}  //运算符 写入sum数组中
            }
         for(int i=0;i<6;i++)
            {
                if(Brace_position[i]!=OperationNum)
                    {j++;}
                Brace_position1[i]=Brace_position[i];
                System.out.println("kuohao"+i+":  "+Brace_position[i]);
                System.out.println("kuohao"+Brace_position1[i]);
            }
        Arrays.sort(Brace_position1);  //括号位置排序
        System.out.println(j);
        int x=j;
         //先计算括号里面的情况
        for(int a=0;a<x/2;a++)
        {
            Left=Brace_position1[j/2-1];  //左括号位置
            System.out.println("left"+Left);
            Right=Brace_position1[j/2];   //右括号位置
            System.out.println("right"+Right);
            
            for(int i=Left+1;i<Right+1;i++)
            {
                if(Operator[i]==2)
                {
                    Num3[i]=Num3[i-1]*Num3[i];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Num4[i-1]=1;
                    Operator[i]=0;
                }
                if(Operator[i]==3)
                {
                    while(Num3[i]==0)
                           {Num3[i]=(int)(Math.random()*Magnification);}
                        
                    Num3[i]=Num4[i-1]*Num3[i];
                    Num4[i]=Num4[i]*Num3[i-1];
                    Num3[i-1]=0;
                    Num4[i-1]=1;
                    Operator[i]=0;
                    //交换分子和分母
                    int t;
                    t=Num3[i];
                    Num3[i]=Num4[i];
                    Num4[i]=t;
                }
            }
            //后计算加减
            for(int i=Left+1;i<Right+1;i++)
            {
                if(Operator[i]==0)
                {
                        Num3[i]=Num4[i-1]*Num3[i]+Num4[i]*Num3[i-1];   //分子
                        Num4[i]=Num4[i-1]*Num4[i];   //分母
                        Num3[i-1]=0;
                        Num4[i-1]=1;
                        Operator[i]=0;
                }
                if(Operator[i]==1)
                {
                    Num3[i]=Num4[i]*Num3[i-1]-Num4[i-1]*Num3[i];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Num4[i-1]=1;
                    Operator[i]=0;
                }
            }
            Brace_position1[j/2-1]=OperationNum;
            Brace_position1[j/2]=OperationNum;
            Arrays.sort(Brace_position1);  //括号位置排序
            j=j-2;
        }
         
         //后计算括号外面
         //先计算乘除
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==2)
            {
                Num3[i]=Num3[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
            if(Operator[i]==3)
            {
                while(Num3[i]==0)
                       {Num3[i]=(int)(Math.random()*Magnification);}
                    
                Num3[i]=Num4[i-1]*Num3[i];
                Num4[i]=Num4[i]*Num3[i-1];
                Num3[i-1]=0;
                Operator[i]=0;
                //交换分子和分母
                int t;
                t=Num3[i];
                Num3[i]=Num4[i];
                Num4[i]=t;
            }
        }
        //后计算加减
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==0)
            {
                    Num3[i]=Num4[i-1]*Num3[i]+Num4[i]*Num3[i-1];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Operator[i]=0;
            }
            if(Operator[i]==1)
            {
                Num3[i]=Num4[i]*Num3[i-1]-Num4[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
        }
        //输出
        Arrays.sort(Brace_position);  //括号位置排序
        for(int i=0;i<OperationNum;i++)
        {
            for(int y=0;y<x;y++)
            {
                if(Brace_position[y]==i)
                {
                    if(y<x/2)
                    {output=output+"(";}
                }
            }
            if(Num2[i]!=0&&Num2[i]!=1)
                {output=output+"(";}
            
            output=output+Num1[i];
            
            if(Num2[i]!=0&&Num2[i]!=1)
                {output=output+"/"+Num2[i]+")";}
            
            for(int y=0;y<x;y++)
            {
                if(Brace_position[y]==i)
                {
                    if(y>=x/2)
                    {output=output+")";}
                }
            }
            
            if(z[i+1]==0)
                {output=output+"+";}
            if(z[i+1]==1)
                {output=output+"-";}
            if(z[i+1]==2)
                {output=output+"*";}
            if(z[i+1]==3)
                {output=output+"/";}
        }
        output=output+"=";
        The_Fraction_In(Num3[OperationNum-1],Num4[OperationNum-1]);
        
    }
    public void Judge3(){     //判断是否符合参数（多项式运算，没有有分数）
        
          int j=0;
        
          for(int i=0;i<6;i++)
        {
            if(Brace_position[i]!=OperationNum)
                {j=1;break;}
            else
                {j=2;}
        }
          System.out.println("zhixingj:"+j);
        switch(j){
            case 1:Braces_polynomial();break; //包含括号的多项式的运算
            case 2:Arithmetic();break;        //没有括号的多项式的运算
        }
        
        
    }
    public void Judge4(){     //判断是否符合参数（多项式运算，有分数）
        
          int j=0;
        
          for(int i=0;i<6;i++)
        {
            if(Brace_position[i]!=OperationNum)
                {j=1;break;}
            else
                {j=2;}
        }
        switch(j){
            case 1:Braces_polynomial();break; //包含括号的多项式的运算
            case 2: Arithmetic();break;       //没有括号的多项式的运算
        }
    }
    public String OutputANDJudge(String s){    //对随机数进行判断，并保证随机题目的正确性
      //只有两个数运算且没有分数参与运算
      if(OperationNum==2&&Parameter[5]==1)
      {     
          Judge1();
      }
      //只有两个数运算但有分数参与运算
      else if(OperationNum==2&&Parameter[5]==0)
      {
          Judge2();
      }
     //有多个数运算且没有分数参与运算
      else if(OperationNum>2&&Parameter[5]!=0)
      {
          System.out.println("yunxing");
          Judge3();
      }
      //有多个数运算但有分数参与运算
      else
      {
          Judge4();
      }
      s=output;
      return s;
    }
    public String getAnswer(){
    return answer;
}
}


public class Run {
    public boolean NoSame(String s,String s1,int k){
        boolean flag=true;
        String s2=s;
        int start,end;
        for(int i=1;i<k;i++)
        {
            start=s2.indexOf(". ");
            end=s2.indexOf("
");
            if(s1.equals(s2.substring(start+1,end-1)));
               {flag=false;}
             s2=s2.substring(end+1);
        }
        
        return flag;
    }
    public static void main(String[] args) {
        
        //可控参数
        int Remainder=3;
        Object[] options1={"有","没有"};
        int MultDiv=JOptionPane.showOptionDialog ( null, "请选择","题目是否有乘除法",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options1, options1[0] );
        
        Object[] options2={"有","没有"};
        int Parentheses=JOptionPane.showOptionDialog ( null, "请选择","题目是否有括号",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options2, options2[0] );
        
        Object[] options3={"0-100","0-200","0-300","0-500","0-1000","0-5000","0-10000"};
        int ValueRange=JOptionPane.showOptionDialog ( null, "请选择","取值范围",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options3, options3[0] );
        
        Object[] options4={"有","没有"};
        int Negative=JOptionPane.showOptionDialog ( null, "请选择","加减有无负数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options4, options4[0] );
        
        if(MultDiv==0)
        {
            Object[] options5={"有","没有"};
            Remainder=JOptionPane.showOptionDialog ( null, "请选择","除法有无余数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options5, options5[0] );
        }
        
        Object[] options6={"有","没有"};
        int Fraction=JOptionPane.showOptionDialog ( null, "请选择","题目中是否包含分数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options6, options6[0] );
        //System.out.println(Fraction);
        //定制
        String inputValue1 = JOptionPane.showInputDialog("请输入要自动生成题目数量：");
        int Num=Integer.parseInt(inputValue1);
        String inputValue2 = JOptionPane.showInputDialog("请输入每行输出个数：");
        int PrintNum=Integer.parseInt(inputValue2);
        
        String s="";
        String s1="";
        String[] answer=new String[Num];
        //输出
        for(int i=0;i<Num;i++)
        {
            DateANDShow a=new DateANDShow(MultDiv,Parentheses,ValueRange,Negative,Remainder,Fraction);

            s=s+(i+1)+". ";
            a.Generate_random_number();
            s1=a.OutputANDJudge(s1);
            answer[i]=a.getAnswer();
            s=s+s1;
            
            //保持打印的格式,保持运算式一定的长度
            if(Parentheses==1)
            {
                for(int l=0;l<(10-s1.length());l++)
                {
                    s=s+" ";
                }
                
            }
            if(Parentheses==0)
            {
                for(int l=0;l<(40-s1.length());l++)
                {
                    s=s+" ";
                }
            }
            
            if((i+1)%PrintNum==0)   //换行打印
            {
                s=s+"
";
            }
        }
        System.out.print(s);
        
        Object[] options7={"是","否"};
        int answerQuestion=JOptionPane.showOptionDialog ( null, "请选择","现在是否开始答题",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options7, options7[0] );
        if(answerQuestion==0)
        {
            for(int i=0;i<Num;i++)
            {
                String answer1= JOptionPane.showInputDialog("请输入第"+(i+1)+"题的答案：");
                if(answer1.equals(answer[i]))
                {
                    JOptionPane.showMessageDialog( null , "恭喜您答题正确！" ,"结果" , JOptionPane.ERROR_MESSAGE) ;
                }
                else
                {
                    JOptionPane.showMessageDialog( null , "很遗憾，您的答案不正确！正确答案为："+answer[i] +"。","结果" , JOptionPane.ERROR_MESSAGE) ;
                }
            }
        }
        
    }
}

运行结果截图：

。。。答题过程就不一一列出了

没有括号，只有加减运算

多项式运算，加减乘除，不包含分数

多项式运算，包含分数且加减乘除且有括号（分数用括号以与除法区别）

编程总结分析：

这一次的编写，整合了以前所实现的功能，同时实现了两个新的功能，及答题并判断正误和打印进行对齐。这其中遇到了挺多难发现，难修改的bug。其中还是最常出现的错误：数组长度溢出。编写过程中要对数组的变化提高非常高的警惕。同时要对复杂的东西学会调用多个方法来实现。

合作开发工作照片：

PSP0级：

项目计划日志：

项目计划日志

姓名：范亚雷     日期：2016/03/21

时间/任务	听课	编写程序	阅读资料	准备考试			日总结
周日							0
周一	120		45				165
周二							0
周三		60	23				83
周四		85	15				100
周五		125	15				140
周六		240	20				260
周总结	120	510	118				748
阶段时间和效率                                                                                      周数：4
总计	120	510	118				748
平均	17	72.8	16.8				106.8
最大	120	240	45				260
最小	0	0	0				0
以前各周的累计时间
总计	180	600	610	748			2138
平均	180	600	610	748			2138
最大	180	600	610	748			2138
最小	180	600	610	748			2138

时间记录日志：

时间记录日志

学生：范亚雷                               日期：2016/03/21

教师：王建民                               课程：软件工程概论

日期	开始时间	结束时间	中断时间	净时间	活动	备注	c	u
03/21	8：00	9：50		20	听课	软件工程概论
	14：35	13：20		45	查阅资料	查阅java的数组排序
03/23	19：03	19：45		42	编写程序	整理整体程序
	19：45	20：08		23	查阅资料	查看方法化简
	20：08	20：26		18	编写程序	继续优化方法
03/24	19：00	19：25		25	编写程序	写入打印规格功能
	19：25	19：40		15	查阅资料	查看网上的例子
	19：40	20：40		60	编写程序	根据例子完成余下方法
03/25	19：06	19：21		15	查阅资料
	19：21	19：50		29	编写程序	完善程序
	20：00	21：40		100	编写程序	继续
03/26	13：15	17：25		240	编写程序	修改程序中的bug

缺陷记录日志：

缺陷记录日志

学生：范亚雷                                      日期：03/21

日期	编号	类型	引入阶段	排除阶段	修复时间	修复缺陷
03/18	1		编码	译码	35
	描述：修改了程序中不能输出的问题
03/18	2		编码	译码	25
	描述：修改程序中只有两个运算数时，分数不能输出括号。
03/18	3		编码	译码	65
	描述：修改程序中有多个运算数时，实现计算括号内的，然后计算括号外面的。
03/19	4		编码	译码	65
	描述：修改程序中判断方法不能正确使用