devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用Java制作简单的计算器

作者：花生_TL007 | 2024-03-20 18:43:01

赞

踩

用Java制作简单的计算器

本篇文章主要是提供思路，当然文章末尾也又提供了源代码。

代码也是写了几天，重要的理解，不是直接复制粘贴就交作业了。

转载请注明出处，尊重作者劳动成果。

目录

界面的设计：

事件的响应：

计算：

详细代码如下：

 总结：

要制作一个简单的计算器，首先就是对于界面的设计，然后就是其功能的实现。

对于事件的实现大概就分下面几个步骤。

  1. 确定事件源和监听源
  2. 实现监听器的接口
  3. 将事件源注册到监听器

然后就一起进入代码的编写吧，我是分成了几个发放来编写功能，最后有最终的代码，可以直接运行，这要注意的是，直接粘贴的话，类名和文件名要一样哦。

界面的设计：

他最上面是要有一个文本框，中间要有很多的按钮，我这里大的框架是采用BorderLayout类布局管理器，其中他的NORTH（容器顶部）是添加了一个FlowLayout类布局管理器，FlowLayout里面是一个文本框，CENTER（容器的中间）是添加了一个GirdLayout类布局管理器，形成网格状的按钮，WEST（容器的左侧）,EAST（容器的右侧）,SOUTH（容器底部），这些是通过添加一个空白的标签来占位置的，让界面更加好看一点。

  1. 	//创建显示器面板，采用默认的流布局
  2. 	final JPanel viewPanel =new JPanel();
  3. 	//创建显示器
  4. 	final JTextField textField=new JTextField();
  5. 	//创建按钮面板
  6. 	final JPanel buttonPanel=new JPanel();
  7. 	//创建网络布局管理器对象
  8. 	final GridLayout gridLayout=new GridLayout(0,4);
  9. 	//按钮里面的内容
  10. 	String [][]names= {
  11. 			{"**","ln","lg","clear"},
  12. 			{"sin","cos","tan","X"},
  13. 			{"PI","//","%","/"},
  14. 			{"7","8","9","*"},
  15. 			{"4","5","6","-"},
  16. 			{"1","2","3","+"},
  17. 			{"_/``","0",".","="}};
  18.  
  19. 	//创建按钮对象
  20. 	JButton[][] buttons=new JButton[names.length][4];
  21. 	//创建左侧的占位标签
  22. 	final JLabel leftLabel=new JLabel();
  23. 	//创建右侧的占位标签
  24. 	final JLabel rightLabel=new JLabel();
  25. 	//创建下侧的占位标签
  26. 	final JLabel bottomLabel=new JLabel();
  1. //初始化组件
  2. 	public void initModule() {
  3. 		//初始化显示器相关数据
  4. 		textField.setEditable(false);//设置显示器不可编辑
  5. 		textField.setHorizontalAlignment(SwingConstants.RIGHT);
  6. 		textField.setColumns(35);//调节文本框的宽度
  7. 		textField.setPreferredSize(new Dimension(500,40));
  8. 	
  9. 		//初始化面板按钮
  10. 		gridLayout.setVgap(10);//设置组件的水平间距
  11. 		gridLayout.setHgap(10);//设置组件的垂直间距
  12. 		//初始化按钮对象
  13. 		for(int row=0;row<names.length;row++) {
  14. 			for(int col=0;col<names[row].length;col++) {
  15. 				buttons[row][col]=new JButton(names[row][col]);//创建按钮
  16. 			}
  17. 		}
  18. 		
  19. 		//设置左侧标签的宽度
  20. 		leftLabel.setPreferredSize(new Dimension(10,0));
  21. 		//设置右侧标签的宽度
  22. 		rightLabel.setPreferredSize(new Dimension(10,0));
  23. 		//设置底部标签的宽度,组件的有高度，可以没宽度，和两边相反
  24. 		bottomLabel.setPreferredSize(new Dimension(0,10));
  25. 	}
  1. //初始化面板
  2. 	public void initPanel() {
  3. 		//初始化组件
  4. 		initModule();
  5. 		
  6. 		viewPanel.add(textField);
  7. 		viewPanel.setPreferredSize(new Dimension(100,80));
  8. 		this.getContentPane().add(viewPanel,BorderLayout.NORTH);
  9. 		
  10. 		
  11. 		buttonPanel.setLayout(gridLayout);//按钮面板采用网络布局
  12. 		this.getContentPane().add(buttonPanel,BorderLayout.CENTER);//将按钮面板添加到窗体中间
  13. 		//把按钮添加到按钮面板中，虽然可以和初始化按钮写一起，但是便于理解还是把他们分开写了
  14. 		for(int row=0;row<names.length;row++) {
  15. 			for(int col=0;col<names[row].length;col++) {
  16. 				buttonPanel.add(buttons[row][col]);
  17. 			}
  18. 		}
  19. 		this.getContentPane().add(leftLabel,BorderLayout.WEST);
  20. 		this.getContentPane().add(rightLabel,BorderLayout.EAST);
  21. 		this.getContentPane().add(bottomLabel,BorderLayout.SOUTH);
  22. 	}
  1.     //初始化窗体
  2. 	public void initFrame() {
  3. 		//设置窗体的标题
  4. 		this.setTitle("计算器");
  5. 		//设置窗体大小不可改变
  6. 		this.setResizable(false);
  7. 		//设置界面置顶(就是页面不会别其他页面覆盖，界面始终在最上面)
  8.         this.setAlwaysOnTop(true);
  9.         //设置窗体的位置和大小，位置应该失效了，因为设置了居中
  10. 		//this.setBounds(300,150,400,500);
  11.         //那还是改成setSize吧,设置窗体的大小就行了
  12.         this.setSize(400,500);
  13. 		//居中
  14. 		this.setLocationRelativeTo(null);
  15. 		//设置窗体关闭按钮的动作作为退出
  16. 		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  17. 		//将显示器面板添加到窗体顶部
  18. 		this.getContentPane().add(viewPanel,BorderLayout.NORTH);
  19. 	}

遇到的问题：

问题1：上层的文本框的大小的宽度设置不了，然后一直没有变化。

解决：通过修改setColumns();调节成功了，这个我还不知道原理，有知道的希望大家可以告诉我呢，之前一直在修改setPreferredSize();然后没反应，修改流布局管理器也只是把空白的地方变多了。

问题2：底部宽度bottomLabel.setPreferredSize(new Dimension(10,0));用这个修改没反应。

解决：这个当然不会有反应，添加加底部的宽是10，高是0，结果当然不会显示，之前偷懒直接复制左右侧的导致没显示，所以应该是bottomLabel.setPreferredSize(new Dimension(0,10));才对。

事件的响应：

Java | swing 如何清空JTextField中的内容_如何清空jtextfield的数据_黄佳俊、的博客-CSDN博客情况描述：在一个JTextField中输入了数据，用一个按钮来清空里面的数据，要如何实现啊！首先要说的是：没有这个方法，clear，能设置JTextField内容为空但是可以这样巧妙地做到：使用jTextField.setText("");把内容替换为空字符串，来实现清空JTextField中的内容...https://blog.csdn.net/weixin_48419914/article/details/121470250解决java添加/点击JButton后键盘监听无效的问题_QASWINE的博客-CSDN博客问题：在点击JButton后，原来可以用的键盘操作用不了了原因：点击JButton，焦点在按钮上，原来的有键盘监听器的组件（JFrame、-JPanel）失去焦点解决方法：如果键盘监听器在frame上，添加 frame.requestFocus()，使他重获焦点。下面是一个例子： button.addActionListener(new ActionListener() { ...https://blog.csdn.net/qq_33831360/article/details/103280448Java 键盘事件无效的几种原因_mapcontrol.addkeylistener(_imonkeyi的博客-CSDN博客..https://blog.csdn.net/imonkeyi/article/details/86177348

 具体的方法就看方法内部的调用吧，有应该都有写方法的作用的，接下来就是确定事件源和监听源，我是打算通过键盘输入一些字符和通过鼠标点击按钮来实现。

1.确定事件源和监听源

事件源：JButton[][] buttons=new JButton[names.length][4];按钮，和自己本身框架

监听源：ActionListener，KeyListener

2.实现监听器的接口

  1. //重写鼠标点击事件
  2. 	@Override
  3. 	public void actionPerformed(ActionEvent e) {
  4. 		// TODO Auto-generated method stub
  5. 		JButton button =(JButton)e.getSource();//获得触发此次动作事件的按钮对象
  6. 		String buttonName =e.getActionCommand();//获得触发此次动作事件的按钮的标签文本
  7. 		
  8. 	
  9. 		if(buttonName.equals("X")) {
  10. 			//没有字符串之后就不能删除了
  11. 			if(sb.length()!=0) {
  12. 				sb.deleteCharAt(sb.length()-1);
  13. 				//textField.setText(output);//删除之后还需要立即显示一次，不然没有反应
  14. 			}
  15. 		}else if(buttonName.equals("R")){
  16. 			//就是把[0,length)的内容删除即可
  17. 			sb.delete(0, sb.length());
  18. 			//删除之后还需要立即显示一次，不然没有反应
  19. 			//textField.setText(output);
  20. 		}else if(buttonName.equals("=")) {
  21. 			//计算结果
  22. 			result();
  23. 		}else {
  24. 			sb.append(buttonName);
  25. 			//textField.setText(output);
  26. 		}
  27. 		//反正每次响应事件之后都要更新，干脆直接放在最后
  28. 		outPut();
  29. 		//要重新使框架获得焦点，这要写呢，不写就按下按钮之后键盘就没反应了
  30. 		if(buttonName.equals("=")) {
  31. 			//就是把[0,length)的内容删除即可
  32. 			sb.delete(0, sb.length());//结果出来之后就是重新输入计算下一个
  33. 		}
  34. 		this.requestFocus();
  35. 	}
  1.             @Override
  2.         	public void keyTyped(KeyEvent e) {
  3.         		// TODO Auto-generated method stub
  4.         		
  5.         	}
  6.         	//按着按键不松时调用
  7.         	@Override
  8.         	public void keyPressed(KeyEvent e) {
  9.         		// TODO Auto-generated method stub
  10.         	}
  11.         	//按键松开后执行
  12.         	@Override
  13.         	public void keyReleased(KeyEvent e) {
  14.         		// TODO Auto-generated method stub
  15.         		//System.out.println("我被调用了啦");
  16.         		int code = e.getKeyCode();
  17.         		//输出每次按下的键盘按钮对应的code
  18.         		//System.out.println(code);
  19.         		//用键盘添加数字
  20.         		//单纯输入数字，shift键没有被按下，不然就加减乘除无法被响应了
  21.         		if(code>=48 && code<=57 && !e.isShiftDown()) {
  22.         			sb.append((char)code);
  23.         			//outPut();
  24.         		}else if(code==56 && e.isShiftDown()) {
  25.         			sb.append("*");
  26.         			//outPut();
  27.         		}else if(code==47 && !e.isShiftDown()) {
  28.         			sb.append("/");
  29.         		}else if(code==8) {//Backspace键
  30.         			//删除最后的一个字符
  31.         			sb.deleteCharAt(sb.length()-1);
  32.         		}else if(code==53 && e.isShiftDown()) {
  33.         			sb.append("%");
  34.         		}else if(code==61 && e.isShiftDown()) {
  35.         			sb.append("+");
  36.         		}else if(code==61 && !e.isShiftDown()) {//"="
  37.         			//计算结果
  38.         			result();
  39.         		}else if(code==45 && !e.isShiftDown()) {
  40.         			sb.append("-");
  41.         		}else if(code==46 && !e.isShiftDown()) {
  42.         			sb.append(".");
  43.         		}else if(code==10) {//Enter键
  44.         			//计算结果
  45.         			result();
  46.         		}
  47.         		//每次键盘输入之后都要更新，所以干脆就直接放判断最后
  48.         		outPut();
  49.         		//"="和"Enter"键
  50.         		if(code==61 && !e.isShiftDown()||code==10) {
  51.         			//就是把[0,length)的内容删除即可
  52.         			sb.delete(0, sb.length());//结果出来之后就是重新输入计算下一个
  53.         		}
  54.         	}
  55.         }
  56.

3.将事件源注册到监听器

  1. public void buttonAction() {
  2. 		//按钮绑定动作事件,和自己绑定，自己实现的监听的方法
  3. 		for(int row=0;row<names.length;row++) {
  4. 			for(int col=0;col<names[row].length;col++) {
  5. 				(buttons[row][col]).addActionListener(this);
  6. 			}
  7. 		}	
  8. 		//给整个界面添加键盘监听事件
  9.         this.addKeyListener(new KeyListener() {
  10.         	
  11.         	@Override
  12.         	public void keyTyped(KeyEvent e) {
  13.         		// TODO Auto-generated method stub
  14.         		
  15.         	}
  16.         	//按着按键不松时调用
  17.         	@Override
  18.         	public void keyPressed(KeyEvent e) {
  19.         		// TODO Auto-generated method stub
  20.         	}
  21.         	//按键松开后执行
  22.         	@Override
  23.         	public void keyReleased(KeyEvent e) {
  24.         		// TODO Auto-generated method stub
  25.         		//System.out.println("我被调用了啦");
  26.         		int code = e.getKeyCode();
  27.         		//输出每次按下的键盘按钮对应的code
  28.         		//System.out.println(code);
  29.         		//用键盘添加数字
  30.         		//单纯输入数字，shift键没有被按下，不然就加减乘除无法被响应了
  31.         		if(code>=48 && code<=57 && !e.isShiftDown()) {
  32.         			sb.append((char)code);
  33.         			//outPut();
  34.         		}else if(code==56 && e.isShiftDown()) {
  35.         			sb.append("*");
  36.         			//outPut();
  37.         		}else if(code==47 && !e.isShiftDown()) {
  38.         			sb.append("/");
  39.         		}else if(code==8) {//Backspace键
  40.         			//删除最后的一个字符
  41.         			sb.deleteCharAt(sb.length()-1);
  42.         		}else if(code==53 && e.isShiftDown()) {
  43.         			sb.append("%");
  44.         		}else if(code==61 && e.isShiftDown()) {
  45.         			sb.append("+");
  46.         		}else if(code==61 && !e.isShiftDown()) {//"="
  47.         			//计算结果
  48.         			result();
  49.         		}else if(code==45 && !e.isShiftDown()) {
  50.         			sb.append("-");
  51.         		}else if(code==46 && !e.isShiftDown()) {
  52.         			sb.append(".");
  53.         		}else if(code==10) {//Enter键
  54.         			//计算结果
  55.         			result();
  56.         		}
  57.         		//每次键盘输入之后都要更新，所以干脆就直接放判断最后
  58.         		outPut();
  59.         		//"="和"Enter"键
  60.         		if(code==61 && !e.isShiftDown()||code==10) {
  61.         			//就是把[0,length)的内容删除即可
  62.         			sb.delete(0, sb.length());//结果出来之后就是重新输入计算下一个
  63.         		}
  64.         	}
  65.         });
  66. 	}public void buttonAction() {
  67. 		//按钮绑定动作事件,和自己绑定，自己实现的监听的方法
  68. 		for(int row=0;row<names.length;row++) {
  69. 			for(int col=0;col<names[row].length;col++) {
  70. 				(buttons[row][col]).addActionListener(this);
  71. 			}
  72. 		}	
  73. 		//给整个界面添加键盘监听事件
  74.         this.addKeyListener(new KeyListener() {
  75.         	
  76.         	@Override
  77.         	public void keyTyped(KeyEvent e) {
  78.         		// TODO Auto-generated method stub
  79.         		
  80.         	}
  81.         	//按着按键不松时调用
  82.         	@Override
  83.         	public void keyPressed(KeyEvent e) {
  84.         		// TODO Auto-generated method stub
  85.         	}
  86.         	//按键松开后执行
  87.         	@Override
  88.         	public void keyReleased(KeyEvent e) {
  89.         		// TODO Auto-generated method stub
  90.         		//System.out.println("我被调用了啦");
  91.         		int code = e.getKeyCode();
  92.         		//输出每次按下的键盘按钮对应的code
  93.         		//System.out.println(code);
  94.         		//用键盘添加数字
  95.         		//单纯输入数字，shift键没有被按下，不然就加减乘除无法被响应了
  96.         		if(code>=48 && code<=57 && !e.isShiftDown()) {
  97.         			sb.append((char)code);
  98.         			//outPut();
  99.         		}else if(code==56 && e.isShiftDown()) {
  100.         			sb.append("*");
  101.         			//outPut();
  102.         		}else if(code==47 && !e.isShiftDown()) {
  103.         			sb.append("/");
  104.         		}else if(code==8) {//Backspace键
  105.         			//删除最后的一个字符
  106.         			sb.deleteCharAt(sb.length()-1);
  107.         		}else if(code==53 && e.isShiftDown()) {
  108.         			sb.append("%");
  109.         		}else if(code==61 && e.isShiftDown()) {
  110.         			sb.append("+");
  111.         		}else if(code==61 && !e.isShiftDown()) {//"="
  112.         			//计算结果
  113.         			result();
  114.         		}else if(code==45 && !e.isShiftDown()) {
  115.         			sb.append("-");
  116.         		}else if(code==46 && !e.isShiftDown()) {
  117.         			sb.append(".");
  118.         		}else if(code==10) {//Enter键
  119.         			//计算结果
  120.         			result();
  121.         		}
  122.         		//每次键盘输入之后都要更新，所以干脆就直接放判断最后
  123.         		outPut();
  124.         		//"="和"Enter"键
  125.         		if(code==61 && !e.isShiftDown()||code==10) {
  126.         			//就是把[0,length)的内容删除即可
  127.         			sb.delete(0, sb.length());//结果出来之后就是重新输入计算下一个
  128.         		}
  129.         	}
  130.         });
  131. 	}

问题3：因为没有响应之后都要有对应的应答，有时候要输出，但是输入的按钮有些是含义多个字符的字符串，在计算和删除的时候删除的是单个的字符不是整个的字符串，比如sin输入的是“sin”删除只能删除最后的'n’。

解决：我这里是用到了HashMap来解决，在程序里面是单个的字符，输出是输出字符表示的字符串，这样删除计算等操作都方便了。

问题4：键盘输入对于*，+等的字符无法得到。

解决：我是通过 e.getKeyCode();来得到键盘输入的code，但是对于*和8是同一个code，都是56，不同的是shift键是否按下，之前是想写在 keyPressed里面来响应，但是感觉也实现不来，后面就是看到了e.isShiftDown();来判断shift键是否按下，也确实抱着试一试的态度，结果发现还真可以，就加上了e.isShiftDown();的判断。就解决了'*'和'8'有相同code的情况。

  1. 	//按钮里面的内容
  2. 	String [][]names= {
  3. 			{"**","ln","lg","clear"},
  4. 			{"sin","cos","tan","X"},
  5. 			{"PI","//","%","/"},
  6. 			{"7","8","9","*"},
  7. 			{"4","5","6","-"},
  8. 			{"1","2","3","+"},
  9. 			{"_/``","0",".","="}};
  10. 	//程序里面的内容
  11. 	String [][]target= {
  12. 			{"A","N","G","R"},
  13. 			{"S","C","T","X"},
  14. 			{"P","B","%","/"},
  15. 			{"7","8","9","*"},
  16. 			{"4","5","6","-"},
  17. 			{"1","2","3","+"},
  18. 			{"D","0",".","="}};    
  19.     //用来对应文本框的输出，还是选择用HashMap来存储
  20. 	Map<String ,String>map=new HashMap<String,String>();
  21.     //通过哈希表实现输出字符串和里面的字符串的不同标识
  22. 	public void Stringbind() {
  23. 		
  24. 		//map.put(getWarningString(), getName())
  25. 		for(int row=0;row<names.length;row++) {
  26. 			for(int col=0;col<names[row].length;col++) {
  27. 				map.put(target[row][col], names[row][col]);
  28. 				//System.out.println("执行成功");
  29. 			}
  30. 		}
  31. 		//用来判断值有没有填写进去
  32. 		//System.out.println(map.size());
  33. 	}

问题5：在查找的时候输出的是null，不是目标的字符串。

解决：这我找了挺久的，最后还看了HashMap里面的元素有多少，发现是存进去的，问题出现在字符串“A”和'A'不是一样的东西，所以哈希表没找到。

输出是通过一个函数来实现

  1.     //用来更新文本框输出的字符串
  2. 	StringBuffer sb=new StringBuffer();
  3. 	//用来对应文本框的输出，还是选择用HashMap来存储
  4. 	Map<String ,String>map=new HashMap<String,String>();
  5. 	//输出的字符串放这个里面，每次使用都需要清零哈
  6. 	String output="";
  7.     //记录每次将输出的字符串
  8. 	public void outPut() {
  9. 		output="";
  10. 		for(int i=0;i<sb.length();i++) {
  11. 		//这我可能知道原因了，字符串"A"和'A'不一样
  12. 			output= output+map.get(String.valueOf(sb.charAt(i)));
  13. 		}
  14. 		//每次更新都要输出，我直接写到方法里面算了
  15. 		textField.setText(output);
  16. 	}

问题6：键盘的输入失灵。

解决：要通过聚焦，才能实现，调用this.setFocusable(true);

问题7：开始输入可以通过键盘输出，但是在按下面板中的按钮之后键盘无法输入。

解决：在每次按下按钮之后重新聚焦this.requestFocus();要重新使框架获得焦点，这要写呢，不写就按下按钮之后键盘就没反应了。

最后就是计算器功能实现的部分了，比较好实现的就是除‘=’号的按钮，直接添加到字符串里面，在最后打印就行。我这里采用的是StringBuffer因为要添加和更新什么的。

删除按钮和清空按钮分别就是删除字符串最后一个字符和删除字符串所有的字符。

  1. //删除最后一个字符
  2. if(sb.length()!=0) {
  3. 	sb.deleteCharAt(sb.length()-1);
  4. 	//textField.setText(output);//删除之后还需要立即显示一次，不然没有反应
  5. }
  6. //删除所有的字符，确定是范围是[0,length)
  7. sb.delete(0, sb.length());

问题8：按下按钮之后没有显示删除。

解决：这个是因为没有显示，在程序中已经删除了，但是呢，用户看到是还没删除的样子，所以还是要更新一下输出。

计算：

java 实现字符串算式的计算_段593405572的博客-CSDN博客输入一个字符串（包括数字、小数点，加减乘除百分比），模拟计算器进行运算。 思路：按运算符优先级依次运算百分比、乘除、加减。遍历字符串，将运算符前或前后的数字字符转为double进行计算，计算后的结果替换原字符串中的子算式。 import java.util.Scanner;public class Main{public static double f(String s){double p = 0;//百分比计算for(int i = 0; i &...https://blog.csdn.net/d593405572/article/details/106713937

Java中角度和弧度的转换，三角函数，反三角函数_java角度转弧度-CSDN博客Java中角度和弧度的转换，三角函数，反三角函数https://blog.csdn.net/senxu_/article/details/126025606

接下来就是最后的计算环节了。

首先确定计算的优先级，我这里没有引入括号了，所以把lg,ln,sin,cos,tan,开根号都是和右边的操作数看成一个整体的。

字符串的运算就是通过运算符来分割，通过寻找到他的运算数，进行运算，把运算结果的字符串和运算前的字符串进行替换即可。

  1.     //计算每次的结果
  2. 	public void result() {
  3. 		
  4. 		//对应关系
  5. 		//**--->A  ln--->N  lg--->G  sin--->S   cos--->C
  6. 		//tan--->T  PI--->P  //--->B  /``--->D
  7. 		//计算是按照优先级来的
  8. 		//PI不算运算，直接填进去吧
  9. 		//也不行，本来就是用一个符号来表示，这突然变成一长串数字，那还是运算的时候展开吧
  10. 		//展开PI
  11. 		try {
  12. 			pi();
  13. 			//ln,lg,sin,cos,tan,开根号的运算
  14. 			special();
  15. 			//乘方运算
  16. 			power();
  17. 			//乘除，整除，求余运算
  18. 			multiplyDivide();
  19. 			//加减计算
  20. 			addAndSubtract();
  21. 		}catch(Exception e) {
  22. 			//弹出警告的弹窗
  23. 			warning();
  24. 		}finally {
  25. 			System.out.println("今天又是元气满满的一天");
  26. 		}
  27. 	}

 PI就是一个替换，把PI在计算的时候换成Math.PI就行了，因为我用哈希表的初衷就是希望在程序中字符串是用一个的字符表示，所以PI我是在计算的时候才进行展开。

  1.     //展开PI
  2. 	public void pi() {
  3. 		for(int i=0;i<sb.length();i++) {
  4. 			if(sb.charAt(i)=='P') {
  5. 				double res=Math.PI;
  6. 				String resString=res+"";
  7. 				//更新字符串
  8. 				sb=sb.replace(i, i+1, resString);
  9. 				i=resString.length()-1;
  10. 				continue;
  11. 			}
  12. 		}
  13. 	}

 这些我不是用什么名字，就用这个表示了，这些的特点就是只需要一个操作数即可。

所以只需要往右边找操作数，统计操作数的长度，把找到的数进行相应的修改和替换。

问题9：sin和tan不好用，用PI直接报错了。

解决：这个弧度制好像是越界了，我又没加括号，那还是Math.toRadians(num)输入角度制转成弧度制来运算吧。

  1. //ln,lg,sin,cos,tan,开根号的运算
  2. 	public void special() {
  3. 		//都是用右边一个操作数的运算
  4. 		for(int i=0;i<sb.length();i++) {
  5. 			if(sb.charAt(i)=='N'||sb.charAt(i)=='G'||
  6. 					sb.charAt(i)=='S'||sb.charAt(i)=='C'||
  7. 					sb.charAt(i)=='T'||sb.charAt(i)=='D') {
  8. 				double num=0;
  9. 				int len=0;//记录字符串长度，之后还要进行字符串的替换呢
  10. 				//只需要应该一边的数字即可
  11. 				for(int j=i+1;j<sb.length();j++) {
  12. 					//是j不是i,咋又错在这里了
  13. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  14. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  15. 							sb.charAt(j)=='+'||sb.charAt(j)=='-'||
  16. 							sb.charAt(j)=='A'||
  17. 							sb.charAt(j)=='N'||sb.charAt(j)=='G'||
  18. 							sb.charAt(j)=='S'||sb.charAt(j)=='C'||
  19. 							sb.charAt(j)=='T'||sb.charAt(j)=='D') {
  20. 						String s1=sb.substring(i+1,j);
  21. 						num=Double.parseDouble(s1);
  22. 						len=s1.length();
  23. 						break;
  24. 					}
  25. 					//找到最右边咯，中间没有运算符那也要停止了
  26. 					if(j==sb.length()-1) {
  27. 						//这边是到j+1哈，找错误找了半天
  28. 						//如果右边是一位的数字，就会导致运算是数是空
  29. 						//如果右边是多位的数字，那么最右边的数不会参与运算，所以需要[i+1,j+1)
  30. 						String s1=sb.substring(i+1,j+1);
  31. 						num=Double.parseDouble(s1);
  32. 						len=s1.length();
  33. 						break;
  34. 					}
  35. 				}
  36. 				//进行运算
  37. 				//ln运算
  38. 				if(sb.charAt(i)=='N') {
  39. 					double res=Math.log(num);
  40. 					String resString=res+"";
  41. 					//更新字符串
  42. 					sb=sb.replace(i, i+len+1, resString);
  43. 					i=resString.length()-1;
  44. 					continue;
  45. 				}
  46. 				//lg运算
  47. 				if(sb.charAt(i)=='G') {
  48. 					//换底公式
  49. 					double res=Math.log(num)/Math.log(10);
  50. 					String resString=res+"";
  51. 					//更新字符串
  52. 					sb=sb.replace(i, i+len+1, resString);
  53. 					i=resString.length()-1;
  54. 					continue;
  55. 				}
  56. 				//sin运算
  57. 				if(sb.charAt(i)=='S') {
  58. 					//还是采用角度制吧，弧度制取值用PI越界了，如果要除的话要加入括号的机制
  59. 					//偷懒一下就用角度值吧，不用加入括号
  60. 					double res=Math.sin(Math.toRadians(num));
  61. 					String resString=res+"";
  62. 					//更新字符串
  63. 					sb=sb.replace(i, i+len+1, resString);
  64. 					i=resString.length()-1;
  65. 					continue;
  66. 				}
  67. 				//cos运算
  68. 				if(sb.charAt(i)=='C') {
  69. 					//还是采用角度制吧，弧度制取值用PI越界了，如果要除的话要加入括号的机制
  70. 					//偷懒一下就用角度值吧，不用加入括号
  71. 					double res=Math.cos(Math.toRadians(num));
  72. 					String resString=res+"";
  73. 					//更新字符串
  74. 					sb=sb.replace(i, i+len+1, resString);
  75. 					i=resString.length()-1;
  76. 					continue;
  77. 				}
  78. 				//tan运算
  79. 				if(sb.charAt(i)=='T') {
  80. 					//还是采用角度制吧，弧度制取值用PI越界了，如果要除的话要加入括号的机制
  81. 					//偷懒一下就用角度值吧，不用加入括号
  82. 					double res=Math.tan(Math.toRadians(num));
  83. 					String resString=res+"";
  84. 					//更新字符串
  85. 					sb=sb.replace(i, i+len+1, resString);
  86. 					i=resString.length()-1;
  87. 					continue;
  88. 				}
  89. 				//开根号运算
  90. 				if(sb.charAt(i)=='D') {
  91. 					double res=Math.sqrt(num);
  92. 					String resString=res+"";
  93. 					//更新字符串
  94. 					sb=sb.replace(i, i+len+1, resString);
  95. 					i=resString.length()-1;
  96. 					continue;
  97. 				}
  98. 			}
  99. 		}
  100. 	}

接下来就是两个操作数的啦。以乘方为例。

往左边和右边寻找操作数，左边的话需要考虑优先级低的操作字符以及字符串越界的情况，但是右边不仅是需要考虑这个还需要考虑本身这个字符。

就是往左边判断是(sb.charAt(j)=='*'||sb.charAt(j)=='/'||sb.charAt(j)=='%'||sb.charAt(j)=='B'||sb.charAt(j)=='+'||sb.charAt(j)=='-')，而右边判断是(sb.charAt(j)=='*'||sb.charAt(j)=='/'||sb.charAt(j)=='%'||sb.charAt(j)=='B'||sb.charAt(j)=='+'||sb.charAt(j)=='-'||sb.charAt(j)=='A')，这也要理解吧，因为字符串吧遍历是从左往右，右边还有这个‘A’没有判断，但是左边已经判断结束了。

  1.     //乘方运算
  2. 	public void power(){
  3. 		for(int i=0;i<sb.length();i++) {
  4. 			if(sb.charAt(i)=='A') {
  5. 				double num1=0,num2=0;
  6. 				int len1=0,len2=0;//记录字符串长度，之后还要进行字符串的替换呢
  7. 				for(int j=i-1;j>=0;j--) {
  8. 					//得到第一个操作数,遇到加减乘除就停止了，相当于分隔了操作数
  9. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  10. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  11. 							sb.charAt(j)=='+'||sb.charAt(j)=='-') {
  12. 						String s1=sb.substring(j+1,i);
  13. 						num1=Double.parseDouble(s1);
  14. 						len1=s1.length();
  15. 						break;
  16. 					}
  17. 					//找到边界了，只能停止了咯
  18. 					if(j==0) {
  19. 						String s1=sb.substring(j,i);
  20. 						num1=Double.parseDouble(s1);
  21. 						len1=s1.length();
  22. 						break;
  23. 					}
  24. 				}
  25. 				//往右边找第二个操作数,第二个操作数的话遇到乘除也需要提前终止，第一个不需要
  26. 				//因为如果第一个操作数有乘除这种符号，就已经提前终止了，只有第二个操作数才需要考虑
  27. 				for(int j=i+1;j<sb.length();j++) {
  28. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  29. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  30. 							sb.charAt(j)=='+'||sb.charAt(j)=='-'||sb.charAt(j)=='A') {
  31. 						String s1=sb.substring(i+1,j);
  32. 						num2=Double.parseDouble(s1);
  33. 						len2=s1.length();
  34. 						break;
  35. 					}
  36. 					//找到最右边咯，中间没有运算符那也要停止了
  37. 					if(j==sb.length()-1) {
  38. 						//这边是到j+1哈，找错误找了半天
  39. 						//如果右边是一位的数字，就会导致运算是数是空
  40. 						//如果右边是多位的数字，那么最右边的数不会参与运算，所以需要[i+1,j+1)
  41. 						String s1=sb.substring(i+1,j+1);
  42. 						num2=Double.parseDouble(s1);
  43. 						len2=s1.length();
  44. 						break;
  45. 					}
  46. 				}
  47. 				//进行运算
  48. 				double res=Math.pow(num1, num2);
  49. 				String resString=res+"";
  50. 				//更新字符串
  51. 				sb=sb.replace(i-len1, i+len2+1, resString);
  52. 				i=i-len1-1+resString.length();
  53. 				continue;
  54. 			}
  55. 		}
  56. 	}

加减乘除就和这个一样了。

问题10：会出现多个异常抛出的情况。

解答：循环里面操作数的判断，里面是sb.charAt(j)写成了sb.charAt(i)；第二种就是在第二个操作数边界判断的时候String s1=sb.substring(i+1,j+1);写成了String s1=sb.substring(i+1,j);这也是直接复制前面的结果，因为之前停止是遇到运算符停止的，所以边界判断不需要考虑到j+1,但是这已经到底了，指针指向的就是数，如果右边是一位的数字，就会导致运算是数是空，如果右边是多位的数字，那么最右边的数不会参与运算，所以需要[i+1,j+1)。

运算解决了，就是对异常的处理，之前的代码就有显示我加入了抛出异常的地方，如果错误是会出现一个弹窗。我还用finally来检验程序的健壮性。本来是对除数为0的情况加上了一个判断，因为是浮点数所以为0的判断条件设置成Math.abs(num2)<=1e-6，但是他没反应了，我干脆就直接不判断了这也算是异常，直接抛出弹出弹窗就行了。这还是方便一点。

注：这里有一个bug，因为操作数我最开始是设置成0，就导致如果只有一个数的时候也可以运算，比如“*1”是可以运行的，因为num1等于0，这个大家感兴趣可以自己完善一下哈。

  1. 	//警告标签，放在弹窗里面
  2. 	final JLabel warningLabel=new JLabel();
  3.  
  4.     //警告，输入不合法的时候弹出
  5. 	public void warning() {
  6. 		JDialog jDialog=new JDialog();//创建弹窗对象
  7. 		jDialog.setTitle("警告");//设置弹窗标题，和Frame差不多，可能还要通过标签来提示
  8. 		jDialog.setSize(500,600);//设置弹窗的大小
  9. 		jDialog.setAlwaysOnTop(true);//让弹窗置顶
  10. 		jDialog.setLocationRelativeTo(null);//让弹窗居中
  11. 		jDialog.setModal(true);//弹窗不关闭则无法操作下面的界面
  12. 		
  13. 		//设置字体的类型，加粗，和大小
  14. 		warningLabel.setFont(new Font("Microsoft YaHei",Font.BOLD,30));
  15. 		//输出警告提示符
  16. 		warningLabel.setText("就是你小子在搞乱的是吧!!!");
  17. 		//标签的位置和大小
  18. 		warningLabel.setBounds(60,180,500,100);
  19. 		
  20. 		//这个也要取消布局管理器才行
  21. 		jDialog.getContentPane().setLayout(null);
  22. 		//往弹窗中添加标签
  23. 		jDialog.getContentPane().add(warningLabel);
  24. 		jDialog.setVisible(true);//让弹窗显示出来
  25. 		
  26. 	}

 警告的弹窗和内容都是自己设计的，弹窗就和框架一样，里面也是一个面板，我取消了布局，通过x,y坐标的方法进行移动。弹窗弹出如下所示。

问题11:在打印按钮的时候出现数组越界

因为整个数组不是矩阵,所以内存循环和外循环不是同一个边界值,内层循环的界限是用外层循环对应一维数组的长度作为边界值.

详细代码如下：

  1.  
  2.  
  3. import java.awt.*;
  4. import java.awt.event.*;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7. import javax.swing.*;
  8.  
  9.  
  10. public class CalculatorFrame extends JFrame implements ActionListener{
  11. 	//主方法
  12. 	public static void main(String[] args) {
  13. 		CalculatorFrame cf=new CalculatorFrame();
  14. 	}
  15. 	//创建显示器面板，采用默认的流布局
  16. 	final JPanel viewPanel =new JPanel();
  17. 	//创建显示器
  18. 	final JTextField textField=new JTextField();
  19. 	//创建按钮面板
  20. 	final JPanel buttonPanel=new JPanel();
  21. 	//创建网络布局管理器对象
  22. 	final GridLayout gridLayout=new GridLayout(0,4);
  23. 	//按钮里面的内容
  24. 	String [][]names= {
  25. 			{"**","ln","lg","clear"},
  26. 			{"sin","cos","tan","X"},
  27. 			{"PI","//","%","/"},
  28. 			{"7","8","9","*"},
  29. 			{"4","5","6","-"},
  30. 			{"1","2","3","+"},
  31. 			{"_/``","0",".","="}};
  32. 	//程序里面的内容
  33. 	String [][]target= {
  34. 			{"A","N","G","R"},
  35. 			{"S","C","T","X"},
  36. 			{"P","B","%","/"},
  37. 			{"7","8","9","*"},
  38. 			{"4","5","6","-"},
  39. 			{"1","2","3","+"},
  40. 			{"D","0",".","="}};
  41. 	//创建按钮对象
  42. 	JButton[][] buttons=new JButton[names.length][4];
  43. 	//创建左侧的占位标签
  44. 	final JLabel leftLabel=new JLabel();
  45. 	//创建右侧的占位标签
  46. 	final JLabel rightLabel=new JLabel();
  47. 	//创建下侧的占位标签
  48. 	final JLabel bottomLabel=new JLabel();
  49. 	//存储计算结果
  50. 	double result=0;
  51. 	//用来更新文本框输出的字符串
  52. 	StringBuffer sb=new StringBuffer();
  53. 	//用来对应文本框的输出，还是选择用HashMap来存储
  54. 	Map<String ,String>map=new HashMap<String,String>();
  55. 	//输出的字符串放这个里面，每次使用都需要清零哈
  56. 	String output="";
  57. 	//警告标签，放在弹窗里面
  58. 	final JLabel warningLabel=new JLabel();
  59. 	
  60. 	public CalculatorFrame(){
  61. 		//初始化窗体
  62. 		initFrame();
  63. 		//初始化面板
  64. 		initPanel();
  65. 		//初始化哈希表里面的数据
  66. 		Stringbind();
  67. 		//绑定事件.键盘绑定也放在里面
  68. 		buttonAction();
  69. 		//窗体可见，放最后吧，不然里面的东西不会显示呢
  70. 		this.setVisible(true);
  71. 	}
  72. 	//初始化窗体
  73. 	public void initFrame() {
  74. 		//设置窗体的标题
  75. 		this.setTitle("计算器");
  76. 		//设置窗体大小不可改变
  77. 		this.setResizable(false);
  78. 		//设置界面置顶(就是页面不会别其他页面覆盖，界面始终在最上面)
  79.         this.setAlwaysOnTop(true);
  80.         //设置窗体的位置和大小，位置应该失效了，因为设置了居中
  81. 		//this.setBounds(300,150,400,500);
  82.         //那还是改成setSize吧,设置窗体的大小就行了
  83.         this.setSize(400,500);
  84. 		//居中
  85. 		this.setLocationRelativeTo(null);
  86. 		//设置窗体关闭按钮的动作作为退出
  87. 		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  88. 		//将显示器面板添加到窗体顶部
  89. 		this.getContentPane().add(viewPanel,BorderLayout.NORTH);
  90. 		//添加屏幕焦点，没有这个用键盘输入没反应埃
  91. 		this.setFocusable(true);
  92. 	}
  93. 	//初始化面板
  94. 	public void initPanel() {
  95. 		//初始化组件
  96. 		initModule();
  97. 		
  98. 		viewPanel.add(textField);
  99. 		viewPanel.setPreferredSize(new Dimension(100,80));
  100. 		this.getContentPane().add(viewPanel,BorderLayout.NORTH);
  101. 		
  102. 		
  103. 		buttonPanel.setLayout(gridLayout);//按钮面板采用网络布局
  104. 		this.getContentPane().add(buttonPanel,BorderLayout.CENTER);//将按钮面板添加到窗体中间
  105. 		//把按钮添加到按钮面板中，虽然可以和初始化按钮写一起，但是便于理解还是把他们分开写了
  106. 		for(int row=0;row<names.length;row++) {
  107. 			for(int col=0;col<names[row].length;col++) {
  108. 				buttonPanel.add(buttons[row][col]);
  109. 			}
  110. 		}
  111. 		this.getContentPane().add(leftLabel,BorderLayout.WEST);
  112. 		this.getContentPane().add(rightLabel,BorderLayout.EAST);
  113. 		this.getContentPane().add(bottomLabel,BorderLayout.SOUTH);
  114. 	}
  115. 	
  116. 	//初始化组件
  117. 	public void initModule() {
  118. 		//初始化显示器相关数据
  119. 		textField.setEditable(false);//设置显示器不可编辑
  120. 		textField.setHorizontalAlignment(SwingConstants.RIGHT);
  121. 		textField.setColumns(35);//调节文本框的宽度
  122. 		textField.setPreferredSize(new Dimension(500,40));
  123. 	
  124. 		//初始化面板按钮
  125. 		gridLayout.setVgap(10);//设置组件的水平间距
  126. 		gridLayout.setHgap(10);//设置组件的垂直间距
  127. 		//初始化按钮对象
  128. 		for(int row=0;row<names.length;row++) {
  129. 			for(int col=0;col<names[row].length;col++) {
  130. 				buttons[row][col]=new JButton(names[row][col]);//创建按钮
  131. 			}
  132. 		}
  133. 		//静态的初始化设置一些，把多个单词的给标识起来
  134. 		/*buttons[0][0].setActionCommand("A");//"**"
  135. 		buttons[0][1].setActionCommand("N");//"ln"
  136. 		buttons[0][2].setActionCommand("G");//"lg"
  137. 		buttons[0][3].setActionCommand("R");//clear
  138. 		buttons[1][0].setActionCommand("S");//sin
  139. 		buttons[1][1].setActionCommand("C");//cos
  140. 		buttons[1][2].setActionCommand("T");//tan
  141. 		buttons[2][0].setActionCommand("P");//PT
  142. 		buttons[2][1].setActionCommand("B");//"//"
  143. 		buttons[6][0].setActionCommand("D");//"+/-"
  144. 		*/
  145. 		//还是用循环全部绑定吧，自己一个一个绑代码灵活性不高
  146. 		for(int row=0;row<names.length;row++) {
  147. 			for(int col=0;col<names[row].length;col++) {
  148. 				buttons[row][col].setActionCommand(target[row][col]);
  149. 			}
  150. 		}
  151. 		
  152. 		//设置左侧标签的宽度
  153. 		leftLabel.setPreferredSize(new Dimension(10,0));
  154. 		//设置右侧标签的宽度
  155. 		rightLabel.setPreferredSize(new Dimension(10,0));
  156. 		//设置底部标签的宽度,组件的有高度，可以没宽度，和两边相反
  157. 		bottomLabel.setPreferredSize(new Dimension(0,10));
  158. 	}
  159. 	//通过哈希表实现输出字符串和里面的字符串的不同标识
  160. 	public void Stringbind() {
  161. 		
  162. 		//map.put(getWarningString(), getName())
  163. 		for(int row=0;row<names.length;row++) {
  164. 			for(int col=0;col<names[row].length;col++) {
  165. 				map.put(target[row][col], names[row][col]);
  166. 				//System.out.println("执行成功");
  167. 			}
  168. 		}
  169. 		//用来判断值有没有填写进去
  170. 		//System.out.println(map.size());
  171. 	}
  172. 	
  173. 	public void buttonAction() {
  174. 		//按钮绑定动作事件,和自己绑定，自己实现的监听的方法
  175. 		for(int row=0;row<names.length;row++) {
  176. 			for(int col=0;col<names[row].length;col++) {
  177. 				(buttons[row][col]).addActionListener(this);
  178. 			}
  179. 		}	
  180. 		//给整个界面添加键盘监听事件
  181.         this.addKeyListener(new KeyListener() {
  182.         	
  183.         	@Override
  184.         	public void keyTyped(KeyEvent e) {
  185.         		// TODO Auto-generated method stub
  186.         		
  187.         	}
  188.         	//按着按键不松时调用
  189.         	@Override
  190.         	public void keyPressed(KeyEvent e) {
  191.         		// TODO Auto-generated method stub
  192.         	}
  193.         	//按键松开后执行
  194.         	@Override
  195.         	public void keyReleased(KeyEvent e) {
  196.         		// TODO Auto-generated method stub
  197.         		//System.out.println("我被调用了啦");
  198.         		int code = e.getKeyCode();
  199.         		//输出每次按下的键盘按钮对应的code
  200.         		//System.out.println(code);
  201.         		//用键盘添加数字
  202.         		//单纯输入数字，shift键没有被按下，不然就加减乘除无法被响应了
  203.         		if(code>=48 && code<=57 && !e.isShiftDown()) {
  204.         			sb.append((char)code);
  205.         			//outPut();
  206.         		}else if(code==56 && e.isShiftDown()) {
  207.         			sb.append("*");
  208.         			//outPut();
  209.         		}else if(code==47 && !e.isShiftDown()) {
  210.         			sb.append("/");
  211.         		}else if(code==8) {//Backspace键
  212.         			//删除最后的一个字符
  213.         			sb.deleteCharAt(sb.length()-1);
  214.         		}else if(code==53 && e.isShiftDown()) {
  215.         			sb.append("%");
  216.         		}else if(code==61 && e.isShiftDown()) {
  217.         			sb.append("+");
  218.         		}else if(code==61 && !e.isShiftDown()) {//"="
  219.         			//计算结果
  220.         			result();
  221.         		}else if(code==45 && !e.isShiftDown()) {
  222.         			sb.append("-");
  223.         		}else if(code==46 && !e.isShiftDown()) {
  224.         			sb.append(".");
  225.         		}else if(code==10) {//Enter键
  226.         			//计算结果
  227.         			result();
  228.         		}
  229.         		//每次键盘输入之后都要更新，所以干脆就直接放判断最后
  230.         		outPut();
  231.         		//"="和"Enter"键
  232.         		if(code==61 && !e.isShiftDown()||code==10) {
  233.         			//就是把[0,length)的内容删除即可
  234.         			sb.delete(0, sb.length());//结果出来之后就是重新输入计算下一个
  235.         		}
  236.         	}
  237.         });
  238. 	}
  239. 	//重写鼠标点击事件
  240. 	@Override
  241. 	public void actionPerformed(ActionEvent e) {
  242. 		// TODO Auto-generated method stub
  243. 		JButton button =(JButton)e.getSource();//获得触发此次动作事件的按钮对象
  244. 		String buttonName =e.getActionCommand();//获得触发此次动作事件的按钮的标签文本
  245. 		
  246. 	
  247. 		if(buttonName.equals("X")) {
  248. 			//没有字符串之后就不能删除了
  249. 			if(sb.length()!=0) {
  250. 				sb.deleteCharAt(sb.length()-1);
  251. 				//textField.setText(output);//删除之后还需要立即显示一次，不然没有反应
  252. 			}
  253. 		}else if(buttonName.equals("R")){
  254. 			//就是把[0,length)的内容删除即可
  255. 			sb.delete(0, sb.length());
  256. 			//删除之后还需要立即显示一次，不然没有反应
  257. 			//textField.setText(output);
  258. 		}else if(buttonName.equals("=")) {
  259. 			//计算结果
  260. 			result();
  261. 		}else {
  262. 			sb.append(buttonName);
  263. 			//textField.setText(output);
  264. 		}
  265. 		//反正每次响应事件之后都要更新，干脆直接放在最后
  266. 		outPut();
  267. 		//要重新使框架获得焦点，这要写呢，不写就按下按钮之后键盘就没反应了
  268. 		if(buttonName.equals("=")) {
  269. 			//就是把[0,length)的内容删除即可
  270. 			sb.delete(0, sb.length());//结果出来之后就是重新输入计算下一个
  271. 		}
  272. 		this.requestFocus();
  273. 	}
  274. 	//记录每次将输出的字符串
  275. 	public void outPut() {
  276. 		output="";
  277. 		for(int i=0;i<sb.length();i++) {
  278. 		//这我可能知道原因了，字符串"A"和'A'不一样
  279. 			output= output+map.get(String.valueOf(sb.charAt(i)));
  280. 		}
  281. 		//每次更新都要输出，我直接写到方法里面算了
  282. 		textField.setText(output);
  283. 	}
  284. 	//计算每次的结果
  285. 	public void result() {
  286. 		
  287. 		//对应关系
  288. 		//**--->A  ln--->N  lg--->G  sin--->S   cos--->C
  289. 		//tan--->T  PI--->P  //--->B  /``--->D
  290. 		//计算是按照优先级来的
  291. 		//PI不算运算，直接填进去吧
  292. 		//也不行，本来就是用一个符号来表示，这突然变成一长串数字，那还是运算的时候展开吧
  293. 		//展开PI
  294. 		try {
  295. 			pi();
  296. 			//ln,lg,sin,cos,tan,开根号的运算
  297. 			special();
  298. 			//乘方运算
  299. 			power();
  300. 			//乘除，整除，求余运算
  301. 			multiplyDivide();
  302. 			//加减计算
  303. 			addAndSubtract();
  304. 		}catch(Exception e) {
  305. 			//弹出警告的弹窗
  306. 			warning();
  307. 		}finally {
  308. 			System.out.println("今天又是元气满满的一天");
  309. 		}
  310. 	}
  311. 	//展开PI
  312. 	public void pi() {
  313. 		for(int i=0;i<sb.length();i++) {
  314. 			if(sb.charAt(i)=='P') {
  315. 				double res=Math.PI;
  316. 				String resString=res+"";
  317. 				//更新字符串
  318. 				sb=sb.replace(i, i+1, resString);
  319. 				i=resString.length()-1;
  320. 				continue;
  321. 			}
  322. 		}
  323. 	}
  324. 	//ln,lg,sin,cos,tan,开根号的运算
  325. 	public void special() {
  326. 		//都是用右边一个操作数的运算
  327. 		for(int i=0;i<sb.length();i++) {
  328. 			if(sb.charAt(i)=='N'||sb.charAt(i)=='G'||
  329. 					sb.charAt(i)=='S'||sb.charAt(i)=='C'||
  330. 					sb.charAt(i)=='T'||sb.charAt(i)=='D') {
  331. 				double num=0;
  332. 				int len=0;//记录字符串长度，之后还要进行字符串的替换呢
  333. 				//只需要应该一边的数字即可
  334. 				for(int j=i+1;j<sb.length();j++) {
  335. 					//是j不是i,咋又错在这里了
  336. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  337. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  338. 							sb.charAt(j)=='+'||sb.charAt(j)=='-'||
  339. 							sb.charAt(j)=='A'||
  340. 							sb.charAt(j)=='N'||sb.charAt(j)=='G'||
  341. 							sb.charAt(j)=='S'||sb.charAt(j)=='C'||
  342. 							sb.charAt(j)=='T'||sb.charAt(j)=='D') {
  343. 						String s1=sb.substring(i+1,j);
  344. 						num=Double.parseDouble(s1);
  345. 						len=s1.length();
  346. 						break;
  347. 					}
  348. 					//找到最右边咯，中间没有运算符那也要停止了
  349. 					if(j==sb.length()-1) {
  350. 						//这边是到j+1哈，找错误找了半天
  351. 						//如果右边是一位的数字，就会导致运算是数是空
  352. 						//如果右边是多位的数字，那么最右边的数不会参与运算，所以需要[i+1,j+1)
  353. 						String s1=sb.substring(i+1,j+1);
  354. 						num=Double.parseDouble(s1);
  355. 						len=s1.length();
  356. 						break;
  357. 					}
  358. 				}
  359. 				//进行运算
  360. 				//ln运算
  361. 				if(sb.charAt(i)=='N') {
  362. 					double res=Math.log(num);
  363. 					String resString=res+"";
  364. 					//更新字符串
  365. 					sb=sb.replace(i, i+len+1, resString);
  366. 					i=resString.length()-1;
  367. 					continue;
  368. 				}
  369. 				//lg运算
  370. 				if(sb.charAt(i)=='G') {
  371. 					//换底公式
  372. 					double res=Math.log(num)/Math.log(10);
  373. 					String resString=res+"";
  374. 					//更新字符串
  375. 					sb=sb.replace(i, i+len+1, resString);
  376. 					i=resString.length()-1;
  377. 					continue;
  378. 				}
  379. 				//sin运算
  380. 				if(sb.charAt(i)=='S') {
  381. 					//还是采用角度制吧，弧度制取值用PI越界了，如果要除的话要加入括号的机制
  382. 					//偷懒一下就用角度值吧，不用加入括号
  383. 					double res=Math.sin(Math.toRadians(num));
  384. 					String resString=res+"";
  385. 					//更新字符串
  386. 					sb=sb.replace(i, i+len+1, resString);
  387. 					i=resString.length()-1;
  388. 					continue;
  389. 				}
  390. 				//cos运算
  391. 				if(sb.charAt(i)=='C') {
  392. 					//还是采用角度制吧，弧度制取值用PI越界了，如果要除的话要加入括号的机制
  393. 					//偷懒一下就用角度值吧，不用加入括号
  394. 					double res=Math.cos(Math.toRadians(num));
  395. 					String resString=res+"";
  396. 					//更新字符串
  397. 					sb=sb.replace(i, i+len+1, resString);
  398. 					i=resString.length()-1;
  399. 					continue;
  400. 				}
  401. 				//tan运算
  402. 				if(sb.charAt(i)=='T') {
  403. 					//还是采用角度制吧，弧度制取值用PI越界了，如果要除的话要加入括号的机制
  404. 					//偷懒一下就用角度值吧，不用加入括号
  405. 					double res=Math.tan(Math.toRadians(num));
  406. 					String resString=res+"";
  407. 					//更新字符串
  408. 					sb=sb.replace(i, i+len+1, resString);
  409. 					i=resString.length()-1;
  410. 					continue;
  411. 				}
  412. 				//开根号运算
  413. 				if(sb.charAt(i)=='D') {
  414. 					double res=Math.sqrt(num);
  415. 					String resString=res+"";
  416. 					//更新字符串
  417. 					sb=sb.replace(i, i+len+1, resString);
  418. 					i=resString.length()-1;
  419. 					continue;
  420. 				}
  421. 			}
  422. 		}
  423. 	}
  424. 	//乘方运算
  425. 	public void power(){
  426. 		for(int i=0;i<sb.length();i++) {
  427. 			if(sb.charAt(i)=='A') {
  428. 				double num1=0,num2=0;
  429. 				int len1=0,len2=0;//记录字符串长度，之后还要进行字符串的替换呢
  430. 				for(int j=i-1;j>=0;j--) {
  431. 					//得到第一个操作数,遇到加减乘除就停止了，相当于分隔了操作数
  432. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  433. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  434. 							sb.charAt(j)=='+'||sb.charAt(j)=='-') {
  435. 						String s1=sb.substring(j+1,i);
  436. 						num1=Double.parseDouble(s1);
  437. 						len1=s1.length();
  438. 						break;
  439. 					}
  440. 					//找到边界了，只能停止了咯
  441. 					if(j==0) {
  442. 						String s1=sb.substring(j,i);
  443. 						num1=Double.parseDouble(s1);
  444. 						len1=s1.length();
  445. 						break;
  446. 					}
  447. 				}
  448. 				//往右边找第二个操作数,第二个操作数的话遇到乘除也需要提前终止，第一个不需要
  449. 				//因为如果第一个操作数有乘除这种符号，就已经提前终止了，只有第二个操作数才需要考虑
  450. 				for(int j=i+1;j<sb.length();j++) {
  451. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  452. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  453. 							sb.charAt(j)=='+'||sb.charAt(j)=='-'||sb.charAt(j)=='A') {
  454. 						String s1=sb.substring(i+1,j);
  455. 						num2=Double.parseDouble(s1);
  456. 						len2=s1.length();
  457. 						break;
  458. 					}
  459. 					//找到最右边咯，中间没有运算符那也要停止了
  460. 					if(j==sb.length()-1) {
  461. 						//这边是到j+1哈，找错误找了半天
  462. 						//如果右边是一位的数字，就会导致运算是数是空
  463. 						//如果右边是多位的数字，那么最右边的数不会参与运算，所以需要[i+1,j+1)
  464. 						String s1=sb.substring(i+1,j+1);
  465. 						num2=Double.parseDouble(s1);
  466. 						len2=s1.length();
  467. 						break;
  468. 					}
  469. 				}
  470. 				//进行运算
  471. 				double res=Math.pow(num1, num2);
  472. 				String resString=res+"";
  473. 				//更新字符串
  474. 				sb=sb.replace(i-len1, i+len2+1, resString);
  475. 				i=i-len1-1+resString.length();
  476. 				continue;
  477. 			}
  478. 		}
  479. 	}
  480. 	//乘除，整除，求余运算
  481. 	public void multiplyDivide() {
  482. 		for(int i=0;i<sb.length();i++) {
  483. 			if(sb.charAt(i)=='*'||sb.charAt(i)=='/'||
  484. 					sb.charAt(i)=='%'||sb.charAt(i)=='B') {
  485. 				double num1=0,num2=0;
  486. 				int len1=0,len2=0;//记录字符串长度，之后还要进行字符串的替换呢
  487. 				for(int j=i-1;j>=0;j--) {
  488. 					//得到第一个操作数,遇到加减就停止了，相当于分隔了操作数
  489. 					if(sb.charAt(j)=='+'||sb.charAt(j)=='-') {
  490. 						String s1=sb.substring(j+1,i);
  491. 						num1=Double.parseDouble(s1);
  492. 						len1=s1.length();
  493. 						break;
  494. 					}
  495. 					//找到边界了，只能停止了咯
  496. 					if(j==0) {
  497. 						String s1=sb.substring(j,i);
  498. 						num1=Double.parseDouble(s1);
  499. 						len1=s1.length();
  500. 						break;
  501. 					}
  502. 				}
  503. 				//往右边找第二个操作数,第二个操作数的话遇到乘除也需要提前终止，第一个不需要
  504. 				//因为如果第一个操作数有乘除这种符号，就已经提前终止了，只有第二个操作数才需要考虑
  505. 				for(int j=i+1;j<sb.length();j++) {
  506. 					if(sb.charAt(j)=='*'||sb.charAt(j)=='/'||
  507. 							sb.charAt(j)=='%'||sb.charAt(j)=='B'||
  508. 							sb.charAt(j)=='+'||sb.charAt(j)=='-') {
  509. 						String s1=sb.substring(i+1,j);
  510. 						num2=Double.parseDouble(s1);
  511. 						len2=s1.length();
  512. 						break;
  513. 					}
  514. 					//找到最右边咯，中间没有运算符那也要停止了
  515. 					if(j==sb.length()-1) {
  516. 						//这边是到j+1哈，找错误找了半天
  517. 						//如果右边是一位的数字，就会导致运算是数是空
  518. 						//如果右边是多位的数字，那么最右边的数不会参与运算，所以需要[i+1,j+1)
  519. 						String s1=sb.substring(i+1,j+1);
  520. 						num2=Double.parseDouble(s1);
  521. 						len2=s1.length();
  522. 						break;
  523. 					}
  524. 				}
  525. 				//进行运算
  526. 				if(sb.charAt(i)=='*') {
  527. 					double res=num1*num2;
  528. 					String resString=res+"";
  529. 					//更新字符串
  530. 					sb=sb.replace(i-len1, i+len2+1, resString);
  531. 					i=i-len1-1+resString.length();
  532. 					continue;
  533. 				}
  534. 				if(sb.charAt(i)=='/') {
  535. 					//除数不能为0,有异常抛出的弹窗了，就去掉这个了
  536. 					/*if(Math.abs(num2)<=1e-6) {
  537. 						System.out.println("输出警告");
  538. 						continue;
  539. 					}*/
  540. 					double res=num1/num2;
  541. 					String resString=res+"";
  542. 					//更新字符串
  543. 					sb=sb.replace(i-len1, i+len2+1, resString);
  544. 					i=i-len1-1+resString.length();
  545. 					continue;
  546. 				}
  547. 				if(sb.charAt(i)=='%') {
  548. 					//整数才能求余,第二个操作数也不能为0
  549. 					/*if(Math.abs(num2)<=1e-6) {
  550. 						System.out.println("输出警告");
  551. 						continue;
  552. 					}*/
  553. 					//是求余%
  554. 					double res=(int)num1%(int)num2;
  555. 					String resString=res+"";
  556. 					//更新字符串
  557. 					sb=sb.replace(i-len1, i+len2+1, resString);
  558. 					i=i-len1-1+resString.length();
  559. 					continue;
  560. 				}
  561. 				if(sb.charAt(i)=='B') {
  562. 					//整数的运算
  563. 					//除数不能为0
  564. 					/*if(Math.abs(num2)<=1e-6) {
  565. 						System.out.println("输出警告");
  566. 						continue;
  567. 					}*/
  568. 					double res=(int)num1/(int)num2;
  569. 					String resString=res+"";
  570. 					//更新字符串
  571. 					sb=sb.replace(i-len1, i+len2+1, resString);
  572. 					i=i-len1-1+resString.length();
  573. 					continue;
  574. 				}
  575. 			}
  576. 		}
  577. 	}
  578. 	//加减运算
  579. 	public void addAndSubtract() {
  580. 		for(int i=0;i<sb.length();i++) {
  581. 			if(sb.charAt(i)=='+'||sb.charAt(i)=='-') {
  582. 				//运算符两边的操作数
  583. 				double num1=0,num2=0;
  584. 				//记录两个操作数的字符串长度
  585. 				int len1=0,len2=0;
  586. 				//寻找第一个操作数
  587. 				for(int j=i-1;j>=0;j--) {
  588. 					if(j==0) {
  589. 						String s1=sb.substring(j,i);
  590. 						//得到第一个操作数
  591. 						num1=Double.parseDouble(s1);
  592. 						len1=s1.length();
  593. 						break;
  594. 					}
  595. 				}
  596. 				for(int j=i+1;j<sb.length();j++) {
  597. 					if(sb.charAt(j)=='+'||sb.charAt(j)=='-') {
  598. 						String s1=sb.substring(i+1,j);
  599. 						//得到第二个操作数
  600. 						num2=Double.parseDouble(s1);
  601. 						len2=s1.length();
  602. 						break;
  603. 					}
  604. 					if(j==sb.length()-1) {
  605. 						String s1=sb.substring(i+1,j+1);
  606. 						num2=Double.parseDouble(s1);
  607. 						len2=s1.length();
  608. 						break;
  609. 					}
  610. 				}
  611. 				//进行加运算
  612. 				if(sb.charAt(i)=='+') {
  613. 					double res=num1+num2;
  614. 					//String s2=sb.substring(i-len1,i+len2+1);
  615. 					//String s3=res+ "";
  616. 					//sb=sb.replace(s2, s3);
  617. 					String resString=res+"";
  618. 					//更新字符串
  619. 					sb=sb.replace(i-len1, i+len2+1, resString);
  620. 					
  621. 					i=i-len1-1+resString.length();
  622. 					continue;
  623. 				}
  624. 				//进行减运算
  625. 				if(sb.charAt(i)=='-') {
  626. 					double res=num1-num2;
  627. 					String resString=res+"";
  628. 					//更新字符串
  629. 					sb=sb.replace(i-len1, i+len2+1, resString);
  630. 					i=i-len1-1+resString.length();
  631. 					continue;
  632. 				}
  633. 			}
  634. 		}
  635. 	}
  636. 	//警告，输入不合法的时候弹出
  637. 	public void warning() {
  638. 		JDialog jDialog=new JDialog();//创建弹窗对象
  639. 		jDialog.setTitle("警告");//设置弹窗标题，和Frame差不多，可能还要通过标签来提示
  640. 		jDialog.setSize(500,600);//设置弹窗的大小
  641. 		jDialog.setAlwaysOnTop(true);//让弹窗置顶
  642. 		jDialog.setLocationRelativeTo(null);//让弹窗居中
  643. 		jDialog.setModal(true);//弹窗不关闭则无法操作下面的界面
  644. 		
  645. 		//设置字体的类型，加粗，和大小
  646. 		warningLabel.setFont(new Font("Microsoft YaHei",Font.BOLD,30));
  647. 		//输出警告提示符
  648. 		warningLabel.setText("就是你小子在搞乱的是吧!!!");
  649. 		//标签的位置和大小
  650. 		warningLabel.setBounds(60,180,500,100);
  651. 		
  652. 		//这个也要取消布局管理器才行
  653. 		jDialog.getContentPane().setLayout(null);
  654. 		//往弹窗中添加标签
  655. 		jDialog.getContentPane().add(warningLabel);
  656. 		jDialog.setVisible(true);//让弹窗显示出来
  657. 		
  658. 	}
  659. }

 总结：

这写下来还是写了挺长的时间了，目前还是比较满意的，因为是刚学JAVA语言，所以有很多地方都没太弄懂，有错误的地方，希望大家能够指正。对于计算器的功能编写其实还是能够添加很多功能也可以把Math.E添加进去，进行其他运算，大家可以根据自己的需求进行编写。写这个我的感受就是就是把我学的东西都用到了哈希表，异常抛出，控件都用上了，我对于他有一个比较清晰的认识，他要实现什么功能，虽然看着简单，但是卡在了很多地方，还有到处找资料来分析他的原因，尽管是有点简陋，我还加入了一些自己的东西，按下Backspace键和Enter键也有对应的响应，这也是努力的结果，希望未来越来越好吧。

6月14日，给按钮添加颜色

这个的话看自己想怎么弄，如果有规律的话可以尝试用循环，不然就需要一个个的调整，建议这个添加到initModule方法里面，这个是我专门用来设计组件信息的方法。（下面是一个示范的案例）

buttons[0][0].setBackground(Color.red);//给第一个按钮添加红色背景的按钮

6月15日，调节按钮中字体的大小。

在创建按钮的时候，给字体统一设置。对原始程序中的修改如下。

  1.  //初始化按钮对象
  2.  for(int row=0;row<names.length;row++) {
  3.      for(int col=0;col<names[row].length;col++) {
  4.         buttons[row][col]=new JButton(names[row][col]);//创建按钮
  5.         //设置字体的类型，是否加粗和字体的大小
  6.         buttons[row][col].setFont(new Font("Microsoft YaHei",Font.BOLD,20));
  7.       }
  8.  }

 

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号