20150401 作业2 结对 四则运算

结对 四则运算

编译环境:eclipse

开发人员:de

开发时间:2015-04-07

实现功能:

    1.基本的加减乘除

    2.每次出1道题目,提交后会显示是否答对,如果错了,还会出现正确答案

3.题目是随机的

    4.能出于分数相关的运算以及可以输入真分数

5.可以控制题目的数量

缺点:

    1.分数计算的答案输入分数格式才显示正确

    2.不能用户选择做什么运算

3.还不能统计答题的时间

4.不能统计答题正确的数目

......

个人体会:

    1.能力还是不足,一些东西想到了却不能实现

    2.要多点和伙伴讨论

    3.对于Java的基础不够熟

伙伴的博客链接:http://www.cnblogs.com/zsb1/

界面:    

     

测试结果:      

源代码:

package rjgc;
import java.io.*;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Pattern;
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

import java.math.*;
public class Rj11 {

    public static void main(String[] args) {
        MyFrame frame=new MyFrame();

    }
}
class MyFrame extends JFrame{
    private JLabel L1=new JLabel("题目数");
    private JLabel L2=new JLabel("题目是");
    private JLabel L3=new JLabel("答案是");
    JTextField T1 = new JTextField(15);
    JTextField T2 = new JTextField(15);
    JTextField T3 = new JTextField(5);
    JTextField T4 = new JTextField(20);
    JButton B4=new JButton("确定");
    JButton B1=new JButton("开始");
    JButton B2=new JButton("提交");
    JButton B3=new JButton("下一题");
    MyFrame(){
        this.setTitle("求平方");
        this.setSize(400, 250);
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        this.getContentPane().setBackground(Color.white);
        FlowLayout flow=new FlowLayout(FlowLayout.LEFT,10,15);
        this.setLayout(flow);
        B4.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                Pattern pa = Pattern.compile("[0-9]*");
                String s1=T1.getText();
                if(pa.matcher(s1).matches())//检测用户输入是否正确
                {
                    try
                    {
                        int number=Integer.parseInt(s1);
                        File dir=new File("d:number");
                        if(!dir.exists())
                        {
                            dir.mkdir();
                        }
                        File afile=new File(dir,"data.txt");
                        afile.createNewFile();
                        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                        bw.write(String.valueOf(s1));
                        bw.close();
                    }
                    catch(IOException t)
                    {
                        T4.setText("IO exception thrown:"+t);
                    }
                }
                else
                {
                    T1.setText("输入的格式错误请重新输入!");
                }
            }
        });
        B1.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent y){
                DecimalFormat df=new DecimalFormat("#.00");
                df.setRoundingMode(RoundingMode.HALF_UP);
                char[]ch={‘+‘,‘-‘,‘*‘,‘/‘};
                int c = 0;
                int d=0;
                int h=0;
                int f=0;
                int e=0;
                double answer;
                double ans;
                int right=0;
                int number;
                try
                {
                    File dir1=new File("d:number");
                    File afile1=new File(dir1,"data.txt");
                    BufferedReader br1=new BufferedReader(new InputStreamReader(new FileInputStream(afile1)));
                    String strRead1=br1.readLine();
                    number=Integer.parseInt(strRead1);
                    if(number>=1)
                    {
                        int n = new Random().nextInt(5);//获取运算的方式0—— +    1—— -    2—— *    3—— /
                        if(n==0 || n==2 || n==3 || n==1)//int型的运算
                        {

                            double a1 = new Random().nextDouble()*100;//获取式子的运算随机数
                            double a=Double.parseDouble(df.format(a1));
                            double b1 =new Random().nextDouble()*100+1;//除数不能为0
                            double b=Double.parseDouble(df.format(b1));
                            T2.setText(a+""+ch[n]+""+b+"=");//输出式子

                            if(n==0)//加法
                            {
                                answer=a+b;
                                answer=Double.parseDouble(df.format(answer));//保留两位小数
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(String.valueOf(answer));
                                    bw.close();
                                }
                                catch(IOException t)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                            else if(n==1)//减法
                            {
                                answer=a-b;
                                answer=Double.parseDouble(df.format(answer));//保留两位小数
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(String.valueOf(answer));
                                    bw.close();
                                }
                                catch(IOException t)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                            else if(n==2) //乘法
                            {
                                answer=a*b;
                                answer=Double.parseDouble(df.format(answer));//保留两位小数
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(String.valueOf(answer));
                                    bw.close();
                                }
                                catch(IOException t)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                            else if(n==3)  //除法
                            {    

                                ans=Double.parseDouble(df.format(a/b));//保留两位小数
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(String.valueOf(ans));
                                    bw.close();
                                }
                                catch(IOException t)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                        }
                        else if(n==4)//含有真分数的运算
                        {
                            double fm=0;
                            double fz=0;
                            double MaxD;
                            String str1;//最简分式
                            boolean t = true;
                            while(t==true)//判断并输出真分数
                            {
                                c = new Random().nextInt(10);
                                d =new Random().nextInt(10);//获取式子的运算随机数
                                if(c<d)
                                    t=false;
                            }
                            t=true;
                            while(t==true)//判断并输出真分数
                            {
                                e =new Random().nextInt(10)+1;
                                f =new Random().nextInt(10);//获取式子的运算随机数
                                if(e<f)
                                    t=false;

                            }
                            n=new Random().nextInt(4);
                            T2.setText("("+c+"/"+d+")"+ch[n]+"("+e+"/"+f+")"+"=");
                            if(n==0)//加法
                            {
                                fm=d*f;
                                fz=(c*f)+(e*d);
                                //简化约分
                                MaxD=getMaxDivi(fz,fm);//最大公约数
                                fz=fz/MaxD;
                                fm=fm/MaxD;

                                //double不保留小数
                                //简化完毕
                                //标准答案
                                str1=(int)fz+"/"+(int)fm;//得出最简答案
                                ans=Double.parseDouble(df.format(fz/fm));
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(str1);
                                    bw.close();
                                }
                                catch(IOException t1)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                            else if(n==1)//减法
                            {
                                fm=d*f;
                                fz=(c*f)-(e*d);
                                MaxD=getMaxDivi(fz,fm);
                                fz=fz/MaxD;
                                fm=fm/MaxD;
                                if(fz<0||fm<0)
                                {
                                    fz=-(Math.abs(fz));
                                    fm=Math.abs(fm);

                                }
                                str1=(int)fz+"/"+(int)fm;//正确答案的String
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(str1);
                                    bw.close();
                                }
                                catch(IOException t1)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                            else if(n==2)//乘法
                            {
                                fz=c*e;
                                fm=d*f;
                                MaxD=getMaxDivi(fz,fm);
                                fz=fz/MaxD;
                                fm=fm/MaxD;

                                str1=(int)fz+"/"+(int)fm;//正确答案的String
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(str1);
                                    bw.close();
                                }
                                catch(IOException t1)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                            else if(n==3)//除法
                            {
                                fz=c*f;
                                fm=d*e;
                                MaxD=getMaxDivi(fz,fm);
                                fz=fz/MaxD;
                                fm=fm/MaxD;

                                str1=(int)fz+"/"+(int)fm;//正确答案的String
                                String dirName1="d:MyData";
                                try
                                {
                                    File dir=new File(dirName1);
                                    if(!dir.exists())
                                    {
                                        dir.mkdir();
                                    }
                                    File afile=new File(dir,"data.txt");
                                    afile.createNewFile();
                                    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                                    bw.write(str1);
                                    bw.close();
                                }
                                catch(IOException t1)
                                {
                                    T4.setText("IO exception thrown:"+t);
                                }
                            }
                        }
                        number--;
                        String ss=String.valueOf(number);
                        File dir=new File("d:number");
                        File afile=new File(dir,"data.txt");
                        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(afile)));
                        bw.write(String.valueOf(ss));
                        bw.close();
                    }
                    else
                    {
                        T4.setText("");
                    }
                }
                catch(IOException t)
                {
                    T4.setText("IO exception thrown:"+t);
                }
            }
        });
        B2.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                int n;
                int n1;
                String dirName="d:MyData";
                String filename="data.txt";
                String filename1="data1.txt";
                try{
                    File dir=new File(dirName);
                    File afile=new File(dir,filename);
                    BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(afile)));
                    String strRead=br.readLine();
                    if(strRead.equals(T3.getText()))
                    {

                        T4.setText("恭喜,你答对了!");
                    }
                    else
                    {

                        T4.setText("对不起,你答错了!正确答案为:"+strRead);
                    }

                }
                catch(IOException t)
                {
                    T4.setText("IO exception thrown:"+t);
                }

            }

        });
        add(L1);add(T1);add(B4);add(B1);add(L2);add(T2);add(T3);add(B2);add(L3);add(T4);
        this.setResizable(false);
        this.setVisible(true);
    }
    static double getMaxDivi(double a,double b)//求最大公约数,运用辗转相除法
    {
        double maxdivd=0;
        if(a==0||b==0)
        {
            maxdivd=1;
            return maxdivd;
        }
        else
        {
            if(a<b)
                getMaxDivi(b,a);
            boolean value=false;
            if(a==0)
            {
                maxdivd=1;
                value=true;
            }

            while(value==false)
            {
                int n=(int) (a/b);
                int m=(int) (a%b);
                if(m==0)
                {
                    maxdivd=b;
                    value=true;
                }
                else
                {
                    a=b;
                    b=m;
                }
            }
        }
        return maxdivd;
    }
}
时间: 2024-11-06 21:58:45

20150401 作业2 结对 四则运算的相关文章

20150401 作业2 结对 四则运算ver 1.0

Web項目下 Tomcat服務器的路徑 /WebContant/ 目錄下 SE2_2.jsp <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "htt

20150401 作业2 结对 四则运算(Doing)

import java.util.ArrayList; import java.util.Random; import java.util.Scanner; public class SE2_1 {// Software Engineering 軟件工程 作業2 public RN getAnswer(RN[] Operand, String[] AS) { ArrayList<String> A = new ArrayList<String>(); ArrayList<RN

作业2 结对 四则运算

开发环境:Eclipse 实现功能: 1.程序可以出带括号的正整数四则运算,支持分数,除法保留两位小数,如:(1/3+1)*2 = 2.67,特别注意:这里是2.67而非2.66 2.用户可以选择出题的个数(最多不能超过5个题目),答题结束可以显示用户答错的题目个数和答对的题目个数 3.用户在第一次答题时,需要用户输入用户名,用户下次启动后,程序需要记住用户前一次输入的用户名 4.程序可以设置皮肤功能,可以改变界面的颜色即可. 结伴同学: 姓名:钟鹏昇 博客:http://www.cnblogs

作业二——结对 四则运算

开发环境: VC++6.0队员:201306114407-吴哲永     20130611410-董大为功能:  1.用户可以选择出题的个数(最多不能超过5个题目),答题结束可以显示用户答错的题目个数和答对的题目个数 2.程序可以出单个整数阶乘的题目:如:4!=24 3.程序可以设置答题时间,时间设置为整数,单位为秒. 4.可以改变界面的颜色 5.程序可以出正整数四则运算,除法保留两位小数分工方面:这次我们结对并没有很明确分工,因为我们还是第一次合作,在很多方面都有不同风格,特别是在算法和传递便

结对作业——随机生成四则运算

结对作业 UI 第三组 朱池苇 PB16150206 刘鼎乾 PB16070837 Github 地址: 项目简介 这次软件工程结对项目为制作一个给小学生用的四则运算出题软件,然后我们抽到的是UI组,也就是负责人机交互--随机生成四则运算--使用Core组封装好的dll模块. 需求分析 对上述各属性参数(生成题目的数量,操作数的数量,题目及答案中的数值的范围--)进行设置 调用Core模块得到题目和运算结果,显示题目,接受输入,并能判断答案是否正确 增加"倒计时"功能,每个题目必须在2

第三次网上作业,结对编程

题目:编写一个能对0--10之间的整数进行四则运算的“软件”程序能接收用户输入的整数答案,并判断对错程序结束时,统计出答对.答错的题目数量.补充说明:0——10的整数是随机生成的用户可以用键盘输入来选择四则运算中的一种,比如输入1代表加法运算用户用键盘输入一个字符来结束程序的运行并显示统计结果,比如输入e程序结束并显示统计结果编程语言不限制,命令行输出和图像界面输出都可以.在此基础上,做增量开发.增量内容:1)处理用户的错误输入,比如输入字母或符号等,处理除法运算中分母为0的情况,处理结果为负数

软件工程第五次作业(结对作业)

软件工程第五次作业 题目 本次作业我与合作伙伴选择的是题目1:四则运算生成 能够自动生成四则运算练习题 可以定制题目数量 用户可以选择运算符 用户设置最大数(如十以内.百以内等) 用户选择是否有括号.是否有小数 用户选择输出方式(如输出到文件.打印机等) 最好能提供图形用户界面(根据自己能力选做,以完成上述功能为主) 角色选择 驾驶员 - 能够完成全部代码工作,程序基本实现全部要求功能,并将代码上传至coding.net或者GitHub代码托管系统中 - 能够对导航员在本次编程工作中起到的作用给

作业四——结对编程四则运算

1. 结对编程项目---四则运算 此次编程项目的结队伙伴是方春阳 学号:130201129 计科13-1 博客地址 http://www.cnblogs.com/fcy29/ 根据要求我们设计了以下程序: 主界面: 在该页面下,可以看到此四则运算的主要功能,可以自行选择数的范围,系统默认值为1-100之间,超出这个范围并未得以实现,输入要生成题目的数量,然后按要求选择在算式中是否有乘除.负数.括号及真分数等功能,选择完成后,选好生成方式,点击确定.就可在框中自动生成算式.单击退出按钮便可退出该程

作业四: 结对编程项目---四则运算

队友  史劭聪 import java.awt.BorderLayout; import java.awt.Container; import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; im