【Java】实现计算器

快速概览
1.励志成为大家的作业侠的小说明
2.实现计算器源码与相应注释

大家好呀，好久没发文了，一没发文就一天n个小朋友取关我😭😭😭（求求了，别取关了，因为我在为你们闭关修炼呀！！！) 我也想天天为大家分享有用的内容，但是奈何最佳作业多，考试多，最近两天才背了30页的word，前两天又背了30页的ppt,博主心里苦🤡🤡🤡，所以为了不让大家受到作业的折磨，就让作业来折磨我一个人吧,我要励志成为你们的作业侠，将大学生日常可能会做的作业(主要是需要写代码类的)我完成过的内容，都将在后续分析给大家哦!有喜欢的小伙伴可以关注我，因为有写作业的代码量实在很多，所以博主为了大家的方便，可能代码没发完整，或者你们cv了代码跑不起来，但是只要大家私聊我把你们qq邮箱发我，我都会将源码发你们的哦！😊😊😊😊😊😊

既然励志成为我可爱的粉丝们的作业侠，我来给大家画给重点
大家想要什么的源码直接私我然后+你们的qq邮箱即可，我看到之后，一定就会立即发你滴!
给大家看几个错误的要代码方法，这样大家会浪费很多宝贵时间哦，我不允许我的小粉丝们的宝贵时间被浪费！！！！:

----------------------------------------------------------------------------甚至有可爱的小粉丝想有尝，我怎么可能舍得我的小粉丝们花钱呢，我只会心疼粉丝❤️❤️❤️

现在给大家看看正确的询问方法

直接把你邮箱发我就好，然后当然还要告诉我你们需要的源码哦！！！，当然小伙伴们如果有任何问题，也欢迎大家留言说什么的问我，我看到一定尽全力为大家解答哦！！！

现在已经发布的源码有:
【Java】实现绘图板
【C++】图书管理系统

大家去看看需要或者有什么问题就可以私聊我嗷！！！

进入今天的正题，实现计算器

实现功能

1. 可以退位
2. 进行连续的简单的表达式运算等

实现方法:

1. awt
2. 利用栈将中缀表达式转化为后缀表达式
3. 利用栈对后缀表达式进行计算

实现效果如下：

通过使用AWT来完成计算器界面开发，其布局拆分思路如下：

(1) 使用顶层容器JFrame。

(2) 通过BorderLayout进行边框布局管理。

(3) 使用中间容器JPanel。

(4) 使用GridLayout网格布局。

(5) 设置按钮与文本框。

(6) 进行相应事件处理。

实现代码如下：含部分注释

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;
public class Caculater {
	
	public JFrame frame;
	public JTextField outField;
    private String b ="";
	public Caculater() {
		//布局代码
		frame=new JFrame();
		frame.setSize(400, 400);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setLayout(new BorderLayout());
		outField=new JTextField();
		outField.setFont(new Font("幼圆",Font.BOLD,60));
		frame.add(outField,BorderLayout.NORTH);
		JPanel panel =new JPanel();
		panel.setBackground(Color.CYAN);
		frame.add(panel,BorderLayout.CENTER);
		panel.setLayout(new GridLayout(5,4,5,5));
		String[] txt= {"C","%","x","=","7","8","9","/","4","5","6","*","1","2","3","-","0","**",".","+"};
		for(int i=0;i<20;i++) {
			JButton btn=new JButton(txt[i]);
			btn.setFont(new Font("幼圆",Font.BOLD,30));
			btn.addActionListener(setAction());;
			panel.add(btn);
		}
		frame.setVisible(true);
	}
	private ActionListener setAction() {
		ActionListener actionListener = new ActionListener() {
         //事件处理
			@Override
			public void actionPerformed(ActionEvent e) {
				String label = e.getActionCommand(); 
		        if ("C".equals(label)||"=".equals(label))
		        {
		            if("=".equals(label))
		            {
		                String s[]=calculate(b);
		                String result=calculateResult(s);
		                b=result+"";
		                outField.setText(b);
		            }
		            else
		            {
		                b="";
		                outField.setText("0");
		            }
		        }
		        else if("**".equals(label))
		        {
		            String m=calculatePow(b);
		            outField.setText(m);
		               b=m;
		        }
		        else if("x".equals(label)) {
		        	 handleBackspace();	
		      
		        }
		        else if(b.contains(".") && label.equals(".")) {
            		
            	}
		        else
		        {
		            b=b+label;
		            outField.setText(b);
		        }
				
			}
			//处理运算符优先级问题
			private String[] calculate(String str)
			{
				String s="";
				char a[]=new char[100];//模拟栈，进行运算符优先级处理
				String ans[]=new String[100];//存储转化后的后缀表达式
				int top=-1,j=0;
				for (int i=0;i<str.length();i++)
				{
					if ("0123456789.".indexOf(str.charAt(i))>=0)//处理用户输入的数字，例如用户输入250，则进行拼接后再加入后缀表达式
					{
						s="";
		                for (;i<str.length()&&"0123456789.".indexOf(str.charAt(i))>=0;i++)
		                {
		                	
		                    s=s+str.charAt(i);
		                }
		                i--;
		                ans[j]=s;
		                j++;
					}
					else if ("*%/".indexOf(str.charAt(i))>=0)//当前运算符为较高运算级的运算符
					{
						if (top==-1)//栈空，直接入栈
						{
							top++;
							a[top]=str.charAt(i);
						}
						else
						{
							if ("*%/".indexOf(a[top])>=0)//当前栈顶也为较高优先级的运算符，则直接将栈顶运算符d出，因为后面进来的运算符优先级和它同一级别，直接按顺序运算即可，并将当前运算符压栈
							{
								ans[j]=a[top]+"";
								j++;
							}
							else if ("+-".indexOf(a[top])>=0) // 当前运算符为较低级运算符，则压栈
							{
								top++;
							}
							a[top]=str.charAt(i);
						}
					}
					else if ("+-".indexOf(str.charAt(i))>=0)//当前运算符为较低级运算发
					{
						if (top==-1)//栈空，直接入栈
						{
							top++;
							a[top]=str.charAt(i);
						}
						else//无论当前栈顶运算符级别如何，都可以直接将目前栈顶运算符加入后缀表达式中，并将目前运算符直接作为栈顶
						{							
								ans[j]=a[top]+"";
								j++;
								a[top]=str.charAt(i);
						}
					}
				}
				for (;top!=-1;)//把剩余运算符全部加入后缀表达式中
				{
					ans[j]=a[top]+"";
					j++;
					top--;
				}
				return ans;
			}
			private void handleBackspace() {//回退一次

				b=b.substring(0,b.length()-1);
				outField.setText(b);
        		
        	}
		    public String calculatePow(String str)//运算平方
		    {
		        String result="";
		        double a=Double.parseDouble(str),b=0;
		        b=Math.pow(a, 2);
		        result=String.valueOf(b);
		        return result;
		    }
		    public String calculateResult(String str[])//进行后缀表达式的计算
		    {
		        String Result[]=new String[100];//进行运算的栈
		        int Top=-1;
		        for (int i=0;str[i]!=null;i++)//遍历后缀表达式数组
		        {
		        	
		            if ("+-*%/".indexOf(str[i])<0)//是数字，将其压入栈中
		            {
		                Top++;
		                Result[Top]=str[i];
		            }
		            if ("+-*%/".indexOf(str[i])>=0)//是表达式
		            {
		                double num1,num2,n;
		                num1=Double.parseDouble(Result[Top]);
		                Top--;
		                if(Top==-1) {//处理用户不合法输入，例如连续的运算符号
		                	String s = "输入不合法";
		                	return s;
		                }
		               num2=Double.parseDouble(Result[Top]);
		                Top--;
		                //进行相应的运算符号运算
		                if ("-".indexOf(str[i])>=0)
		                {
		                    n=num2-num1;
		                    Top++;
		                    Result[Top]=String.valueOf(n);
		                }
		                if ("+".indexOf(str[i])>=0)
		                {
		                    n=num1+num2;
		                    Top++;
		                    Result[Top]=String.valueOf(n);
		                }
		                if ("*".indexOf(str[i])>=0)
		                {
		                    n=num1*num2;
		                    Top++;
		                    Result[Top]=String.valueOf(n);
		                }
		                if ("/".indexOf(str[i])>=0)
		                {
		                    if (num1==0)
		                    {
		                        String s="不能除以0";
		                        return s;
		                    }
		                    else
		                    {
		                        n=num2/num1;
		                        Top++;
		                        Result[Top]=String.valueOf(n);
		                    }
		                }
		                if ("%".indexOf(str[i])>=0)
		                {
		                    if (num1==0)
		                    {
		                        String s="ERROR";
		                        return s;
		                    }
		                    else
		 
		                    {
		                        n=num2%num1;
		                        Top++;
		                        Result[Top]=String.valueOf(n);
		                    }
		                }
		            }
		        }
		        return Result[Top];
		    }
		   
			
	};
	return actionListener;
	}
	
	public static void main(String[] args) {
		Caculater ca=new Caculater();
	}
}