软件工程（2018）结对编程第二次作业

目录

一.题目要求

• 我们在刚开始上课的时候介绍过一个小学四则运算自动生成程序的例子，请实现它，要求：
  • 能够自动生成四则运算练习题
  • 可以定制题目数量
  • 用户可以选择运算符
  • 用户设置最大数（如十以内、百以内等）
  • 用户选择是否有括号、是否有小数
  • 用户选择输出方式（如输出到文件、打印机等）
  • 最好能提供图形用户界面（根据自己能力选做，以完成上述功能为主）

二.角色分工

驾驶员：杨浩（本人）
领航员：冯俊鹏

三.代码及代码地址

代码地址

题目生成

class binarytree 
{
    
    private treenode root;
    private int num;
    private arraylist<treenode> opelist = new arraylist<treenode>();
    
    public binarytree(int num){
        this.num=num;
    }
    
    public int getnum(){
        return num;
    }
    
    public void setnum(int num){
        this.num = num;
    }
    
    public void settreenode(treenode root){
        this.root = root;
    }
    
    
    /**
     * 获取最终的表达式，必须在calandval()方法后调用
     * 
     * @return str
     */
    public string tostring(){
        string str = root.tostring();
        str = str.substring(1, str.length()-1);
        return str;
    }
    
    /**
     * 计算并验证表达式
     * 
     * @return result
     */
    public string calandval(){
        return root.getresult();
    }
    
    /**
     * 计算二叉树的深度(层数) 
     * 
     * @return deep
     */
    public int getdeep(){
        int i = this.num;
        int deep = 2;
        while(i/2 > 0){
            deep++;
            i /= 2;
        }
        return deep;
    }
    
    /**
     * 生成二叉树
     * 
     */
    public void createbtree(){
        treenode lchild, rchild, lnode, rnode;
        
        if(num == 1){
            lchild = new treenode(string.valueof(ran.getnumber(10)), null, null);
            rchild = new treenode(string.valueof(ran.getnumber(10)), null, null);
            root = new treenode(string.valueof(ran.getoperator()), lchild, rchild);
        }
        else{
            int num1 = 0;
            int n = getdeep() - 3;
            boolean[] place = ran.getchildplace(num);
            root = new treenode(string.valueof(ran.getoperator()), null, null);
            opelist.add(root);
            
            for(int i = 0; i < n; i++){
                for(int j = 0; j < (int)math.pow(2, i); j++, num1++){
                    lchild = new treenode(string.valueof(ran.getoperator()), null, null);
                    rchild = new treenode(string.valueof(ran.getoperator()), null, null);
                    opelist.get(j + num1).setchild(lchild, rchild);  //?
                    opelist.add(lchild);
                    opelist.add(rchild);
                }
            }
            
            for(int i = 0; i < place.length; i++){
                if(place[i]){
                    lnode  = new treenode(string.valueof(ran.getnumber(10)), null, null);
                    rnode  = new treenode(string.valueof(ran.getnumber(10)), null, null);
                    if(i%2 == 0){
                        lchild = new treenode(string.valueof(ran.getoperator()), lnode, rnode);
                        opelist.add(lchild);
                        opelist.get(num1).setlchild(lchild);
                    }
                    else{
                        rchild = new treenode(string.valueof(ran.getoperator()), lnode, rnode);
                        opelist.add(rchild);
                        opelist.get(num1).setrchild(rchild);
                    }
                }
                else{
                    if(i%2 == 0){
                        lchild = new treenode(string.valueof(ran.getnumber(10)), null, null);
                        opelist.get(num1).setlchild(lchild);
                    }
                    else{
                        
                        rchild = new treenode(string.valueof(ran.getnumber(10)), null, null);
                        opelist.get(num1).setrchild(rchild);
                    }
                }
                num1 = num1 + i%2;
            }
        }
    }
}

 class ran {
    
    /**
     * 获取随机的符号
     * 
     * @return operator
     */
    
    public static char getoperator(){
        char operator = 0;
        random ran = new random();
        int i = ran.nextint(4);
        switch(i){
            case 0:
                operator = '+';
                break;
            case 1:
                operator = '-';
                break;
            case 2:
                operator = '*';
                break;
            case 3:
                operator = '/';
                break;
        }
        return operator;
    }
    
    
    /**
     * 根据输入的范围获取随机数
     * 
     * @param max
     * @return number
     */
    
    public static int getnumber(int max){
        int number = 0;
        max=test.maxnum;
        
            random ran = new random();
            number = ran.nextint(max+1);
            return number;
    }
    
    /**
     * 根据运算符的个数随机产生子节点的位置
     * 
     * @param num
     * @return childplace
     */
    
    public static boolean[] getchildplace(int num){
        int d = 0;
        int size = 0, j=1;
        while(num >= (int)math.pow(2, j)){
            j++;
        }
        d = (int)math.pow(2, j) - 1 - num;
        size = (int)math.pow(2, j-1);
        boolean[] k = new boolean[size];
        for(int i = 0; i < size; i++){
            k[i] = true;
        }
        for(int i = 0; i < d; i++){
            random ran = new random();
            int f = ran.nextint(size);
            while(k[f] == false)
            {
                f = ran.nextint(size);
            }
            k[f] = false;
        }
        return k;
    }
}

 class treenode {
    
    private string str;
    private treenode rchild = null;
    private treenode lchild = null;
    
    public treenode(string str){
        this.str = str;
    }
    
    public treenode(string str, treenode lchild, treenode rchild){
        this.str = str;
        this.rchild = rchild;
        this.lchild = lchild;
    }
    
    public void setchild(treenode lchild, treenode rchild){
        this.lchild = lchild;
        this.rchild = rchild;
    }
    
    public treenode getrchild() {  
        return rchild;  
    }  
    public void setrchild(treenode rchild) {  
        this.rchild = rchild;  
    }  
    public treenode getlchild() {  
        return lchild;  
    }  
    public void setlchild(treenode lchild) {  
        this.lchild = lchild;  
    }
    
    public string getstr(){
        return str;
    }
    
    /**
     * 获取每个节点的运算结果，并检验除法
     * 1)除数为0
     * 2)不能整除
     * 出现以上两种情况的话将该运算符转换成其他三种运算符
     * 
     * @return result
     */
    public string getresult(){
        if(haschild()){
            switch(str){
                case "+":
                    return string.valueof(integer.parseint(getlchild().getresult()) + integer.parseint(getrchild().getresult()));
                case "-":
                    return string.valueof(integer.parseint(getlchild().getresult()) - integer.parseint(getrchild().getresult()));
                case "*":
                    return string.valueof(integer.parseint(getlchild().getresult()) * integer.parseint(getrchild().getresult()));
                case "/":
                    if(getrchild().getresult().equals("0")){
                        while(str.equals("/")){
                            str = string.valueof(ran.getoperator());
                        }
                        return this.getresult();
                    }
                    else if(integer.parseint(getlchild().getresult()) % integer.parseint(getrchild().getresult()) != 0){
                        while(str.equals("/")){
                            str = string.valueof(ran.getoperator());
                        }
                        return this.getresult();
                    }
                    else
                        return string.valueof(integer.parseint(getlchild().getresult()) / integer.parseint(getrchild().getresult()));
            }
        }
        return str;
    }     
    
    /**
     * 先对每个运算式添加括号，然后根据去括号法则，去掉多余的子式的括号
     * 
     * @return string
     */
    public string tostring(){
        string lstr = "", rstr = "", str = "";
        if(haschild()){
            //右子树如果有孩子，说明右子树是一个表达式，而不是数字节点。
            if(getrchild().haschild()){                         
                //判断左邻括号的运算符是否为'/'
                if(str.equals("/")){
                    //获取右子树的表达式，保留括号
                    rstr = getrchild().tostring();              
                }
                //判断左邻括号的运算符是否为'*'或'-'
                else if(str.equals("*") || str.equals("-")){
                    //判断op是否为'+'或'-'
                    if(getrchild().str.equals("+") || getrchild().str.equals("-")){ 
                        rstr = getrchild().tostring();          
                    }
                    else{
                        //获取右子树的表达式，并且去括号 
                        rstr = getrchild().tostring().substring(1, getrchild().tostring().length()-1);  
                    }
                }
                else{
                    //右子树除此之外都是可以去括号的。
                    rstr = getrchild().tostring().substring(1, getrchild().tostring().length()-1);      
                }
            }
            else{
                rstr = getrchild().str;
            }
            //左子树的情况同右子树类似
            if(getlchild().haschild()){                                             
                if(str.equals("*") || str.equals("/")){
                    if(getlchild().str.equals("+") || getlchild().str.equals("-")){
                        lstr = getlchild().tostring();
                    }
                    else{
                        lstr = getlchild().tostring().substring(1, getlchild().tostring().length()-1);
                    }
                }
                else{
                    lstr = getlchild().tostring().substring(1, getlchild().tostring().length()-1);
                }
            }
            else{
                lstr = getlchild().str;
            }
            //获取当前的运算式，并加上括号
            str = "(" + lstr + str + rstr + ")";                                    
        }
        else{
            //若没有孩子，说明是数字节点，直接返回数字
            str = str;
        }
        return str;
    }
    
    public boolean haschild(){
        if(lchild == null && rchild == null)
            return false;
        else
            return true;
    }
}

图形界面生成及输出

public static void initui()
    {
        jframe frame =new jframe();
        frame.settitle("四则运算");
        frame.setsize(500, 500);
        frame.setlocationrelativeto(null);
        frame.setdefaultcloseoperation(3);
        
        flowlayout f1=new flowlayout(flowlayout.left);
        frame.setlayout(f1);
        
        jlabel name1=new jlabel("请输入题目个数：");
        frame.add(name1);
        
        jtextfield name1text=new jtextfield();//文本框
        name1text.setpreferredsize(new dimension(50, 30));
        frame.add(name1text);
        
        jlabel name=new jlabel();//空
        name.setpreferredsize(new dimension(110,30));
        frame.add(name);
        
        jlabel name2=new jlabel("请输入最大值：");
        frame.add(name2);
        
        jtextfield name2text=new jtextfield();//文本框
        name2text.setpreferredsize(new dimension(50, 30));
        frame.add(name2text);
        
        jlabel name4=new jlabel("是否输出到文件：");
        frame.add(name4);
        
        jradiobutton jrb1, jrb2;
        jrb1 = new jradiobutton("是");
        jrb2 = new jradiobutton("否");
        frame.add(jrb1);
        frame.add(jrb2);
        
        jlabel name5=new jlabel();//空
        name5.setpreferredsize(new dimension(110,30));
        frame.add(name5);
        
        jbutton bu=new jbutton("生成");
        bu.setpreferredsize(new dimension(80,30));
        frame.add(bu);
        
        jlabel name3=new jlabel();//空
        name3.setpreferredsize(new dimension(50,30));
        frame.add(name3);
        
        jlabel name7=new jlabel("题目：");
        frame.add(name7);
        
        jlabel name6=new jlabel();//空
        name6.setpreferredsize(new dimension(250,30));
        frame.add(name6);
        
        jtextfield titletext=new jtextfield();//文本框
        titletext.setpreferredsize(new dimension(450, 300));
        frame.add(titletext);
        
        
        /**
         * 事件监听器
         */
        bu.addactionlistener(new actionlistener(){
            public void actionperformed(actionevent e) {
                string a=name1text.gettext();
                int title_num = integer.parseint(a);  //string转换为int
                string b=name2text.gettext();
                maxnum = integer.parseint(b);  //string转换为int
                string[] title=new string[title_num];
                string[] result1=new string[title_num];
                for(int i = 0; i < title_num; i++){
                    binarytree btree;
                    btree = new binarytree(2);
                    btree.createbtree();
                    string result = btree.calandval();
                    title[i]=btree.tostring();
                    result1[i]=result;
                    system.out.println(title[i]+"="+result1[i]);
                }
                
                
                    titletext.settext(getstringbyarray(title,result1));
                
                /**
                 * 文件输出
                 */
                if(jrb1.isselected()) {
                    try{
                        printstream mytxt=new printstream("./test.txt");
                        printstream out=system.out;
                        system.setout(mytxt);
                        for(int i = 0; i < title_num; i++){
                            system.out.println(title[i] + "=" + result1[i]);
                        }
                        system.setout(out);
                        }catch(filenotfoundexception e1){
                        e1.printstacktrace();
                        }
                }
                
            }
        });
        
        frame.setvisible(true);
    }
    /**
     * 
     * @将题目整和成一个字符串，方便settext输出
     * @param b
     * @return str
     */
    public static string getstringbyarray(string[] a,string[] b) {
        string str = "";
        for(int i=0;i<a.length;i++) {
            str += a[i];
            str += '=';
            str += b[i];
            str += ' ';
            str += ' ';
            str += ' ';
            str += ' ';
        }
        return str;
    }

四.运行结果截图

图形框架截图

输出到文本框

输出到文件

五.参考资料

java实现图形界面
java 图形化界面设计（gui）实战练习（代码）
java如何画图形用户界面

六.工作照片

七.评价及总结

 在这次的作业中，我的领航员是冯俊鹏同学，他在过程中给了我很大的帮助，不断地督促我尽快完成，遇到不会的问题和我一起解决，是使我的代码更加完善，没有他的话我很难完成这次的作业。
 通过这次作业，我完成了我的第一个拥有图形界面的作品，在这之前一直都是用黑框进行操作，编写代码的过程是非常困难的，有许许多多的问题根本不知道如何解决，例如图形化界面的实现、界面的输入和输出和事件监听器的编写等等，碰到这些问题只能去网上搜索 ，找了很多的参考文章，上面列举出的仅仅只是其中一小部分，程序实现了一部分功能，但还有几个功能没有实现，例如选择小数和选择括号，图形界面的编写也比较混乱，但是，在这次的代码编写过程中，我学到了很多以前根本不会的知识，收获了很多。