急求java计算器 课程设计报告

最新问答

• 哈皮小暖

  Java课程设计报告
  题 目： 计算器
  院（系）：xxx学院
  年级专业： xxx班
  姓名： xxx
  指导： xx
  开始时间： 200x-xx-xx
  完成时间： 200x-xx-xx
  目 录
  1． 摘 要
  2． 概要设计
  3． 详细设计
  4． 测试分析
  5． 参考文献
  一、摘 要
  本计算器可以进行简单的四则运算（加、减、乘、除）但仅限于十进制下，还可以进行（八进制，十进制，十六进制）之间的相互转换，八进制最多可以输入19位数，十进制最多可以输入18位数，十六进制最多可以输入14位数,backspace表示退格, clear表示初始化，在window下直接运行（Jsp2003.bat）即可，界面为灰白对称。
  二、概要设计
  （1） 自定义类说明
  **********************************************************
  * 类名: This_number_too_big *
  * 作用: 自定义的异常类，用来处理计算结果溢出 *
  * 继承的父类: Exception类 *
  * 实现的接口: 没有 *
  **********************************************************
  class This_number_too_big extends Exception
  {
  }//自定义的一个结果溢出异常类
  **********************************************************
  * 类名: Jsp2003 *
  * 作用: 主类。 *
  * 继承的父类: Frame类 *
  * 实现的接口: ItemListener类,ActionListener类 *
  **********************************************************
  class Jsp2003 extends Frame implements ItemListener,ActionListener
  {
  public int number=0,length=18;
  //number是用来记录输入的数字个数，
  //length是用来设置在不同进制下允许输入的最多数字位数，默认为十进制 public char mark='n';
  //设置运算符号为没有即为‘n’，它的值是‘+’‘-’‘*’‘/’
  public double data=0;
  //设置运算为零
  public char ch;
  //用来临时存放所按按钮的第一个字符
  public boolean Refresh=false;
  //设置lab是否要在输入的时候刷新，初始为否
  主要方法说明：
  ------------------------------------------------------------------------------------------------
  //用来处理按了运算符后的计算-
  public void js() throws This_number_too_big //指定由method抛出异常
  {if (mark=='n') //没有运算符
  {mark=ch; //，则设置运算符为刚刚输入的字符，
  data=Double.parseDouble(lab.getText());//则设置运算为lab的值
  Refresh=true;//则设置下一次输入的时候要刷新lab
  }
  else //如果采用的是连续运算（即没有使用‘=’号）则运行下面的语句
  {switch (mark) //根据运算符计算结果，并把结果保存到data
  { case '+': data+=Double.parseDouble(lab.getText()); break;
  case '-': data-=Double.parseDouble(lab.getText()); break;
  case '*': data*=Double.parseDouble(lab.getText()); break;
  case '/': data/=Double.parseDouble(lab.getText()); break;}
  lab.setText(Double.toString(data)); //显示运算结果
  mark=ch;//设置运算符为刚刚按下的运算符
  Refresh=true;//则设置下一次输入的时候要刷新lab
  number=lab.getText().length();//设置输入的字符个数
  // System.out.println(lab.getText());//用来调试用的
  if (data>Double.MAX_VALUE)
  //如果data超过double类型的最大值则抛出自定义的一个异常类
  {throw new This_number_too_big(); }
  }
  }//end js() method
  ----------------------------------------------------------------------------------------------------
  public void enter()//处理输入字符
  {if(Refresh==true)
  //如果已经设置了 运算符则在下一次输入的时候要把以前lab的内容清除掉
  {lab.setText("0"); number=0; Refresh=false;}
  if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)
  //如果lab的内容为0则，lab的内容将被所输入的字符代替，
  //否则直接在lab的内容后面加上所输入的字符
  {lab.setText(Character.toString(ch)); number++;}
  else
  if(number{number++;lab.setText(lab.getText()+ch);}
  }//end enter() method
  --------------------------------------------------------------------------------------------------------
  //八进制或十六进制转换成十进制I
  public String goto_10(String s,long l)
  //参数s： 是要转换的字符串，由于输入的控制，保证了字符串的合法性；
  //参数l： 使用来设置是将8进制还是16进制转换成10进制，它的有效值为8或16；
  { String str=s; //用来转换的字符串
  long j=l; //表示进制
  long lg=0,jing=1;//lg用来记录权乘和，jing用来记录位权
  char cha;//临时记录要转换的字符
  for(int i=1;i<=str.length();i++)
  { cha=str.charAt(str.length()-i);
  switch(cha)
  { case '1': lg=lg+1*jing;break;
  case '2': lg=lg+2*jing;break;
  case '3': lg=lg+3*jing;break;
  case '4': lg=lg+4*jing;break;
  case '5': lg=lg+5*jing;break;
  case '6': lg=lg+6*jing;break;
  case '7': lg=lg+7*jing;break;
  case '8': lg=lg+8*jing;break;
  case '9': lg=lg+9*jing;break;
  case 'A': lg=lg+10*jing;break;
  case 'B': lg=lg+11*jing;break;
  case 'C': lg=lg+12*jing;break;
  case 'D': lg=lg+13*jing;break;
  case 'E': lg=lg+14*jing;break;
  case 'F': lg=lg+15*jing;break;}
  jing*=j; //位权升一级，为下次使用做好准备
  }
  return Long.toString(lg);
  }//end String goto_10() method
  }
  （2）程序流程图
  
  三、详细设计
  import java.awt.*;
  import java.awt.event.*;
  class This_number_too_big extends Exception
  {}//自定义的一个结果溢出异常类
  class Jsp2003 extends Frame implements ItemListener,ActionListener {
  public Jsp2003() {
  addWindowListener(new WindowAdapter() {
  public void windowClosing(WindowEvent e) {
  dispose();
  System.exit(0);
  }
  });
  }
  static Jsp2003 mainFrame = new Jsp2003();
  static Label lab=new Label("0");
  static Panel pnl1=new Panel(new GridLayout(4,3,3,3));
  static Panel pnl2=new Panel(new GridLayout(4,1,3,3));
  static Panel pnl3=new Panel(new GridLayout(1,2,3,3));
  static Panel pnl4=new Panel(new GridLayout(6,1,3,3));
  static Button bt9=new Button("9");
  static Button bt8=new Button("8");
  static Button bt7=new Button("7");
  static Button bt6=new Button("6");
  static Button bt5=new Button("5");
  static Button bt4=new Button("4");
  static Button bt3=new Button("3");
  static Button bt2=new Button("2");
  static Button bt1=new Button("1");
  static Button bt0=new Button("0");
  static Button btdot=new Button(".");
  static Button btequ=new Button("=");
  static Button btadd=new Button("+");
  static Button btsub=new Button("-");
  static Button btmul=new Button("*");
  static Button btdev=new Button("/");
  static Button btA=new Button("A");
  static Button btB=new Button("B");
  static Button btC=new Button("C");
  static Button btD=new Button("D");
  static Button btE=new Button("E");
  static Button btF=new Button("F");
  static Checkbox ckb8=new Checkbox("八进制");
  static Checkbox ckb10=new Checkbox("十进制");
  static Checkbox ckb16=new Checkbox("十六进制");
  static Button btc=new Button("clear");
  static Button btt=new Button("backspace");
  public int number=0,length=18;
  //number是用来记录输入的数字个数，length是用来设置在不同进制下允许输入的最多数字位数，默认为十进制
  public char mark='n'; //设置运算符号为没有即为‘n’，它的值是‘+’‘-’‘*’‘/’
  public double data=0; //设置运算为零
  public char ch; //用来临时存放所按按钮的第一个字符
  public boolean Refresh=false;//设置lab是否要在输入的时候刷新，初始为否
  public static void main(String args[]) {
  System.out.println("Starting Jsp2003...");
  lab.setAlignment(Label.RIGHT);
  lab.setBackground(Color.lightGray);
  lab.setForeground(Color.BLUE);
  lab.setFont(new Font("Serief",Font.BOLD,18));
  lab.setBounds(14,33,216,40);
  mainFrame.add(lab);
  CheckboxGroup grp=new CheckboxGroup();
  ckb8.setCheckboxGroup(grp);
  ckb10.setCheckboxGroup(grp);
  ckb16.setCheckboxGroup(grp);
  ckb8.setBounds(14,75,55,25);
  ckb10.setBounds(69,75,55,25);
  ckb16.setBounds(124,75,65,25);
  ckb8.setState(false);
  ckb10.setState(true);
  ckb16.setState(false);
  mainFrame.add(ckb8);
  mainFrame.add(ckb10);
  mainFrame.add(ckb16);
  pnl1.setBounds(14,140,120,150);
  pnl2.setBounds(144,140,40,150);
  pnl3.setBounds(14,100,170,36);
  pnl4.setBounds(190,100,40,190);
  pnl1.add(bt7);
  pnl1.add(bt8);
  pnl1.add(bt9);
  pnl1.add(bt4);
  pnl1.add(bt5);
  pnl1.add(bt6);
  pnl1.add(bt1);
  pnl1.add(bt2);
  pnl1.add(bt3);
  pnl1.add(bt0);
  pnl1.add(btdot);
  pnl1.add(btequ);
  pnl2.add(btadd);
  pnl2.add(btsub);
  pnl2.add(btmul);
  pnl2.add(btdev);
  pnl3.add(btt);
  pnl3.add(btc);
  pnl4.add(btA);
  pnl4.add(btB);
  pnl4.add(btC);
  pnl4.add(btD);
  pnl4.add(btE);
  pnl4.add(btF);
  btA.enable(false);
  btB.enable(false);
  btC.enable(false)；
  btD.enable(false);
  btE.enable(false);
  btF.enable(false);
  mainFrame.add(pnl1);
  mainFrame.add(pnl2);
  mainFrame.add(pnl3);
  mainFrame.add(pnl4);
  mainFrame.setResizable(false);
  mainFrame.setLayout(null);
  mainFrame.setSize(240,300 );
  mainFrame.setTitle("计算器");
  mainFrame.setVisible(true);
  ckb8.addItemListener(mainFrame);
  ckb10.addItemListener(mainFrame);
  ckb16.addItemListener(mainFrame);
  //把聆听者向各个组键注册
  bt1.addActionListener(mainFrame);
  bt2.addActionListener(mainFrame);
  bt3.addActionListener(mainFrame);
  bt4.addActionListener(mainFrame);
  bt5.addActionListener(mainFrame);
  bt6.addActionListener(mainFrame);
  bt7.addActionListener(mainFrame);
  bt8.addActionListener(mainFrame);
  bt9.addActionListener(mainFrame);
  bt0.addActionListener(mainFrame);
  btadd.addActionListener(mainFrame);
  btsub.addActionListener(mainFrame);
  btmul.addActionListener(mainFrame);
  btdev.addActionListener(mainFrame);
  btt.addActionListener(mainFrame);
  btc.addActionListener(mainFrame);
  btdot.addActionListener(mainFrame);
  btequ.addActionListener(mainFrame);
  btA.addActionListener(mainFrame);
  btB.addActionListener(mainFrame);
  btC.addActionListener(mainFrame);
  btD.addActionListener(mainFrame);
  btE.addActionListener(mainFrame);
  btF.addActionListener(mainFrame);
  }// end main() mothed
  //---------------------------------------------
  //checkbox 的处理
  public void itemStateChanged(ItemEvent e)
  { mark='n';
  Refresh=false;
  //规定当进制转换时以前输入的运算符失效
  if (ckb8.getState()==true)
  { btA.enable(false);
  btB.enable(false);
  btC.enable(false);
  btD.enable(false);
  btE.enable(false);
  btF.enable(false);
  bt9.enable(false);
  bt8.enable(false);
  btdot.enable(false);
  btadd.enable(false);
  btmul.enable(false);
  btsub.enable(false);
  btdev.enable(false);
  btequ.enable(false);
  //在八进制的情况下对有些按件的管理
  if(length==18) { lab.setText(goto10_8(lab.getText()));
  number=lab.getText().length();
  }
  if(length==14) { lab.setText(goto_10(lab.getText(),16L));
  lab.setText(goto10_8(lab.getText()));
  number=lab.getText().length();
  }
  //将其他进制转换成八进制
  length=19;
  //在八进制下允许输入数字个数最多为19位
  }
  if(ckb10.getState()==true)
  { btA.enable(false);
  btB.enable(false);
  btC.enable(false);
  btD.enable(false);
  btE.enable(false);
  btF.enable(false);
  bt9.enable(true);
  bt8.enable(true);
  btdot.enable(true);
  btadd.enable(true);
  btmul.enable(true);
  btsub.enable(true);
  btdev.enable(true);
  btequ.enable(true);
  //在十进制的情况下对有些按件的管理
  if(length==19) { lab.setText(goto_10(lab.getText(),8L));
  number=lab.getText().length();}
  if(length==14) { lab.setText(goto_10(lab.getText(),16L));
  number=lab.getText().length();}
  //进制转换成十进制
  length=18;
  //在十进制下允许输入数字个数最多为18位
  }
  if(ckb16.getState()==true)
  { btA.enable(true);
  btB.enable(true);
  btC.enable(true);
  btD.enable(true);
  btE.enable(true);
  btF.enable(true);
  bt9.enable(true);
  bt8.enable(true);
  btdot.enable(false);
  btadd.enable(false);
  btmul.enable(false);
  btsub.enable(false);
  btdev.enable(false);
  btequ.enable(false);
  //在十六进制的情况下对有些按件的管理
  if(length==18) { lab.setText(goto10_16(lab.getText()));
  number=lab.getText().length();}
  if(length==19) { lab.setText(goto_10(lab.getText(),8L));
  lab.setText(goto10_16(lab.getText()));
  number=lab.getText().length();}
  //将其他进制转换成十六进制
  length=14;
  //在十六进制下允许输入数字个数最多为14位
  }
  }//end itemStateChanged(ItemEvent e) method
  //------------------------------------------------------------
  //按钮的处理
  public void actionPerformed(ActionEvent m)
  {
  Button btn=(Button) m.getSource();
  ch=btn.getLabel().charAt(0);
  switch (ch)
  { case 'c': {lab.setText("0"); number=0; mark='n'; Refresh=false;}break;//初始化
  case '1': enter(); break;
  case '2': enter(); break;
  case '3': enter(); break;
  case '4': enter(); break;
  case '5': enter(); break;
  case '6': enter(); break;
  case '7': enter(); break;
  case '8': enter(); break;
  case '9': enter(); break;
  case '0': {if(Refresh==true) { lab.setText("0"); number=0; Refresh=false; }
  if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)
  break;
  if(number{number++;lab.setText(lab.getText()+ch);} else break;
  } break;
  case 'A': enter(); break;
  case 'B': enter(); break;
  case 'C': enter(); break;
  case 'D': enter(); break;
  case 'E': enter(); break;
  case 'F': enter(); break;
  case '.': {if(Refresh==true) {lab.setText("0"); number=0; Refresh=false;}
  if(lab.getText().indexOf('.')== -1)
  {number++;lab.setText(lab.getText()+ch);}
  else
  break;
  }
  break;
  case 'b': {if(number==0) break;
  else
  {if(--number==0) {lab.setText("0"); number=0;}
  else
  {if (number!=1) lab.setText(lab.getText().substring(0,number));
  else
  lab.setText(Character.toString(lab.getText().charAt(0)));}
  }
  }break;
  case '+': try
  { js();}
  catch(This_number_too_big e)
  {lab.setText("0"); number=0; mark='n';
  Refresh=false; System.out.println("The number is too big");} break;
  //如果出现异常则初始化效果如同clear键
  case '-': try
  { js();}
  catch(This_number_too_big e)
  {lab.setText("0"); number=0; mark='n';
  Refresh=false; System.out.println("The number is too big");} break;
  //如果出现异常则初始化效果如同clear键
  case '*': try
  { js();}
  catch(This_number_too_big e)
  {lab.setText("0"); number=0; mark='n';
  Refresh=false; System.out.println("The number is too big");} break;
  //如果出现异常则初始化效果如同clear键
  case '/': try
  { js();}
  catch(This_number_too_big e)
  {lab.setText("0"); number=0; mark='n';
  Refresh=false; System.out.println("The number is too big");} break;
  //如果出现异常则初始化效果如同clear键
  case '=': try
  { js();}
  catch(This_number_too_big e)
  {lab.setText("0"); number=0; mark='n';
  Refresh=false; System.out.println("The number is too big");} break;
  //如果出现异常则初始化效果如同clear键
  }
  }//end actionPerformed(ActionEvent e) method
  //八进制或十六进制转换成十进制I
  //-------------------------------------Infinity
  public String goto_10(String s,long l)
  //参数s： 是要转换的字符串，由于输入的控制，保证了字符串的合法性；
  //参数l： 使用来设置是将8进制还是16进制转换成10进制，它的有效值为8或16；
  {
  String str=s; //用来转换的字符串
  long j=l; //表示进制
  long lg=0,jing=1;//lg用来记录权乘和，jing用来记录位权
  char cha;//临时记录要转换的字符
  for(int i=1;i<=str.length();i++)
  {
  cha=str.charAt(str.length()-i);
  switch(cha)
  {
  case '1': lg=lg+1*jing;break;
  case '2': lg=lg+2*jing;break;
  case '3': lg=lg+3*jing;break;
  case '4': lg=lg+4*jing;break;
  case '5': lg=lg+5*jing;break;
  case '6': lg=lg+6*jing;break;
  case '7': lg=lg+7*jing;break;
  case '8': lg=lg+8*jing;break;
  case '9': lg=lg+9*jing;break;
  case 'A': lg=lg+10*jing;break;
  case 'B': lg=lg+11*jing;break;
  case 'C': lg=lg+12*jing;break;
  case 'D': lg=lg+13*jing;break;
  case 'E': lg=lg+14*jing;break;
  case 'F': lg=lg+15*jing;break;}
  jing*=j; //位权升一级，为下次使用做好准备
  }
  return Long.toString(lg);
  }//end String goto_10() method
  //十进制转换成十六进制
  //-------------------------------------
  public String goto10_16(String s)
  //参数s： 是要转换的字符串，由于输入的控制，保证了字符串的合法性；
  { String str=s; //用来转换的字符串
  String st=new String();//用来记录16进制值的字符串
  long ch; //每次取余有的值
  int k; //将每次取余有的值转换成整形，用来选择转换的16进制字符
  long lg;//用来转换的10进制数
  if(str.charAt(0)=='-') //如果有负号则出去负号
  str=str.substring(1,str.length()-1);
  if(str.indexOf('E')!= -1)//如果是科学计数值则出去小数点和E后面的数
  str=str.charAt(0)+str.substring(2,str.indexOf('E'));
  if (str.indexOf('.')!= -1)//如果有小数点则出去小数点及小数点后面的内容
  str=str.substring(0,str.indexOf('.'));
  lg=Long.parseLong(str);//将简化的字符串转化为长整形给lg
  while (lg>=16)
  { ch=lg%16;
  k=(int)ch;
  switch (k)
  {case 10: st="A"+st;break;
  case 11: st="B"+st;break;
  case 12: st="C"+st;break;
  case 13: st="D"+st;break;
  case 14: st="E"+st;break;
  case 15: st="F"+st;break;
  default: st=Long.toString(ch)+st;
  }
  lg=lg/16;
  }
  k=(int)lg;
  switch (k)
  {case 10: st="A"+st;break;
  case 11: st="B"+st;break;
  case 12: st="C"+st;break;
  case 13: st="D"+st;break;
  case 14: st="E"+st;break;
  case 15: st="F"+st;break;
  default: st=Long.toString(lg)+st;
  }
  return st;
  }//end goto10_16() method
  //-----------------------------------------------
  //十进制转换成八进制?
  public String goto10_8(String s)
  //参数s： 是要转换的字符串，由于输入的控制，保证了字符串的合法性；
  { String str=s;
  String st=new String();
  long j=8,ch;
  long lg;
  if(str.charAt(0)=='-') //如果有负号则出去负号
  str=str.substring(1,str.length()-1);
  if(str.indexOf('E')!= -1)//如果是科学计数值则出去小数点和E后面的数
  str=str.charAt(0)+str.substring(2,str.indexOf('E'));
  if (str.indexOf('.')!= -1)//如果有小数点则出去小数点及小数点后面的内容
  str=str.substring(0,str.indexOf('.'));
  lg=Long.parseLong(str);
  while (lg>=j)
  { ch=lg%j;
  st=Long.toString(ch)+st;
  lg=lg/j;
  }
  st=Long.toString(lg)+st;
  return st;
  }//end goto10_8() method
  //--------------------------------
  //输入字符
  public void enter()
  {if(Refresh==true)
  //如果已经设置了 运算符则在下一次输入的时候要把以前lab的内容清除掉
  {lab.setText("0"); number=0; Refresh=false;}
  if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)
  //如果lab的内容为0则，lab的内容将被所输入的字符代替，否则直接在lab的内容后面加上所输入的字符
  {lab.setText(Character.toString(ch)); number++;}
  else
  if(number{number++;lab.setText(lab.getText()+ch);}
  }//end enter() method
  //-------------------------------------
  //用来处理按了运算符后的计算-
  public void js() throws This_number_too_big //指定由method抛出异常
  {if (mark=='n') //没有运算符
  {mark=ch; //，则设置运算符为刚刚输入的字符，
  data=Double.parseDouble(lab.getText());//则设置运算为lab的值
  Refresh=true;//则设置下一次输入的时候要刷新lab
  }
  else //如果采用的是连续运算（即没有使用‘=’号）则运行下面的语句
  {switch (mark) //根据运算符计算结果，并把结果保存到data
  { case '+': data+=Double.parseDouble(lab.getText()); break;
  case '-': data-=Double.parseDouble(lab.getText()); break;
  case '*': data*=Double.parseDouble(lab.getText()); break;
  case '/': data/=Double.parseDouble(lab.getText()); break;}
  lab.setText(Double.toString(data)); //显示运算结果
  mark=ch;//设置运算符为刚刚按下的运算符
  Refresh=true;//则设置下一次输入的时候要刷新lab
  number=lab.getText().length();//设置输入的字符个数
  // System.out.println(lab.getText());//用来调试用的
  if (data>Double.MAX_VALUE)
  //如果data超过double类型的最大值则抛出自定义的一个异常类
  {throw new This_number_too_big(); }
  }
  }//end js() method
  //---------------------------
  //
  public void answer() throws This_number_too_big //指定由method抛出异常
  {if (mark=='n')
  {}
  else
  {switch (mark)
  {case '+': data+=Double.parseDouble(lab.getText()); break;
  case '-': data-=Double.parseDouble(lab.getText()); break;
  case '*': data*=Double.parseDouble(lab.getText()); break;
  case '/': data/=Double.parseDouble(lab.getText()); break;}
  lab.setText(Double.toString(data));
  mark='n';}
  if (data>Double.MAX_VALUE) //如果data超过double类型的最大值则抛出自定义的一个异常类
  {throw new This_number_too_big();}
  Refresh=false;
  number=lab.getText().length();
  }//end answer() method
  //---------------------------
  }//end class Jsp2003
  4． 测试分析
  （1）程序运行情况:
  程序正常的响应按钮，输入的数值长度受变量length的限定，进行混合四则运算的时候，结果如果不是很大，可以正常显示，但如果结果很大，就可能采用科学记数方式，这样带来了进制转换时的麻烦，需要特殊的处理科学记数里的E ，当结果太大的时候，有可能超出可能表示的最大值，（结果溢出），这个时候就要对结果进行必要的异常处理，我在输出结果的方法内设置if 语句，如果结果大于某一个值就抛出一个This_number_too_big 类型的类，再使用try-catch，捕捉输出结果的方法抛出的异常对象。然后进行，重制归零的处理。
  （2）程序异常处理:
  当结果超出Double.MAX_VALUE时，将抛出一个This_number_too_big 类的异常对象，这个是我自定义的一个异常类它继承自Exception 类，然后使用try-catch去捕捉这个异常，异常的处理如下：
  try
  { js();}
  catch(This_number_too_big e)
  {
  lab.setText("0");
  number=0;
  mark='n';
  Refresh=false;
  System.out.println("The number is too big");
  } //如果出现异常则初始化效果如同clear键
  五、参考文献
  

  浏览 235赞 136时间 2023-07-13
• 自飘自落

  俺暂时没时间，不然帮你写一个，应该很简单啊，自己会swing，再会一点点java编程就可以搞定了。

  浏览 352赞 105时间 2022-02-06