Java GUI界面之简易计算器的制作以及非GUI实现（中缀表达式，后缀表达式）

最近刚开始学习GUI界面的知识，就尝试做了一个计算器。

其实我主要做的是个界面，监听部分还是查询了资料。

package moder02;

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

@SuppressWarnings("serial")
public class Calculator extends JFrame implements ActionListener {
	
	private JTextField resultText = new JTextField("0");;
	
	private JPanel contentPane;
	
	private String[] M = {"MC", "MR", "M+", "M-", "MS"};
	
	private JButton m[] = new JButton[M.length];
	
	private String[] One = {"%", "sqrt", "x^2", "1/x", "CE", "C", "Del", "/", 
			
			"7", "8", "9", "*", "4", "5", "6", "-", "1", "2", "3", "+", "+/-", "0", ".","="};
	
	private JButton o[] = new JButton[One.length];
	
	private static boolean first;
	
	private static String operator = "=";
	
	private boolean operateValidFlag = true;
	
	private double resultNum = 0.0;
		
	public Calculator() {
		
		super("【Chase Calculator");			
		
                setBounds(500, 150, 375, 375);//设置大小和出现位置
        		
		setResizable(false);//设置窗口为不可缩放
		
		setBackground(Color.WHITE);
		
		setVisible(true);//设置为可见
		
		init();
			   
	}
	
	public void init() {
		
		contentPane = new JPanel(); //指定容器

		setContentPane(contentPane);//设置 contentPane 属性
		
		contentPane.setOpaque(false);//设置面板背景为透明

		contentPane.setLayout(null);//设置为绝对布局
		
		
		
		resultText.setHorizontalAlignment(JTextField.RIGHT);//设置文本框的文字为右对齐
		
		resultText.setBackground(Color.WHITE);//设置文本框背景颜色
		
		resultText.setBounds(0, 2, this.getWidth()-10, 50);//设置位置大小
		
		Font f = new Font("黑体", Font.BOLD, 30);
		
		resultText.setFont(f);//设置文本框中字体的大小
		
		resultText.setEditable(false);//设置文本框中的内容不被修改
		
		contentPane.add(resultText);//面板添加文本框
		
		
		
		//添加按钮
		for(int i = 0; i<M.length; i++) {
			
			m[i] = new JButton(M[i]);
			
			m[i].setSize(50, 30);//设置按钮大小
			
			m[i].setLocation(i*55+1, 53);//设置出现位置
			
			Font F = new Font("隶书", Font.CENTER_BASELINE, 10);//设置按钮里的字体
			
			m[i].setFont(F);
			
			m[i].setBackground(Color.cyan);//设置按钮颜色
						
			contentPane.add(m[i]);//面板添加按钮
		}
		
		
		
		//添加按钮
		for(int i = 0; i<One.length; i++) {
			
			o[i] = new JButton(One[i]);
			
	 	        o[i].setSize(80, 35 );
	 	    
	 	        o[i].setBackground(Color.WHITE);//设置按钮颜色
			
			int mark = i/4;
			
			o[i].setLocation(i*90-(mark*4*90)+1, 90+mark*40);
			
			contentPane.add(o[i]);
		}
		
		
		//添加监听
		for(int i = 0; i<M.length; i++) {
			
		        //m[i].addActionListener(this);
		}
		
		for(int i = 0; i<One.length; i++) {
			
			o[i].addActionListener(this);
			
		}
	}

	
	
	/*
	 * 事件处理
	 */
	public void actionPerformed(ActionEvent e) {
		
		String key = e.getActionCommand();
		
		if("0123456789.".indexOf(key) >= 0) {//按下数字的响应
			
			handleNumber(key);
		}
		
		else if("Del".equals(key)) {//按下Del键的响应
			
			int i = resultText.getText().length();
			
			if(i == 0) {
				
				resultText.setText("0");
				
			}else {	
				
			String s = resultText.getText().substring(0, i-1);
			
			resultText.setText(s);
							
			}	
				
		}
		
		else if("C".equals(key)) {//初始化计算机信息
			
			operateValidFlag = true;
			
			operator = "=";
			
			resultText.setText("0");
			
		}
		
		else if("CE".equals(key)) {//按下CE键响应
			
			resultText.setText("0");//即重置文本框为0
			
		}
		
		else if("+".equals(key)||"-".equals(key)||"*".equals(key)||"/".equals(key)||"=".equals(key)
				
				||"sqrt".equals(key)||"%".equals(key)||"1/x".equals(key)||"+/-".equals(key)) {//操作符处理
			
		handleOperator(key);
			
		}

	}

	/*
	 * 按下数字事件
	 */
	public void handleNumber(String s) {
		
		if(first) {
			
			  resultText.setText(s);
			  
		}else if ((s.equals(".")) && (resultText.getText().indexOf(".") < 0)) {
           
                          resultText.setText(resultText.getText() + ".");
            
        } else if (!s.equals(".")) {
            
            resultText.setText(resultText.getText() + s);
        }
       
        first = false;
	
	}
	
	
	
	/*
	 * 得到当前文本数字
	 */
	private double getNumber() {
		
	    double result = 0;
	    
	    try {
	    	
	        result = Double.valueOf(resultText.getText());
	        
	        } catch (NumberFormatException e) {
	    	
	    }
	    
	    return result;
	}
	
	
	/*
	 * 按下操作符事件
	 */
	 private void handleOperator(String key) {
		 
	        if (operator.equals("/")) {
	           
	            if (getNumber() == 0.0) {
	             
	                operateValidFlag = false;
	                
	                resultText.setText("除数不能为零");
	                
	            } else {
	            	
	                resultNum /= getNumber();
	            }
	        
	        }  else if (operator.equals("1/x")) { // 倒数运算
	           
	            if (resultNum == 0.0) {
	               
	                operateValidFlag = false;
	                
	                resultText.setText("零没有倒数"); // 操作不合法
	                
	            } else {
	            	
	                resultNum = 1 / resultNum;
	            }
	       
	        } else if (operator.equals("+")) {  // 加法运算
	          
	            resultNum += getNumber();
	            
	        } else if (operator.equals("-")) {// 减法运算
	            
	            resultNum -= getNumber();
	            
	        } else if (operator.equals("*")) {//乘法运算
	            
	            resultNum *= getNumber();
	            
	        } else if (operator.equals("sqrt")) {//平方根算法
	            
	            resultNum = Math.sqrt(resultNum);
	            
	        } else if (operator.equals("%")) {// 百分号运算，除以100
	            
	            resultNum = resultNum / 100;
	            
	        } else if (operator.equals("=")) { // 赋值运算
	           
	            resultNum = getNumber();
	        }
	        
	        else if (operator.equals("+/-")) {// 正数负数运算
	            
	            resultNum = resultNum * (-1);
	        }
	        
	        if (operateValidFlag) { // 双精度浮点数的运算
	           
	            long t1;
	            
	            double t2;
	            
	            t1 = (long) resultNum;
	            
	            t2 = resultNum - t1;
	            
	            if (t2 == 0) {
	            	
	                resultText.setText(String.valueOf(t1));
	                
	            } else {
	            	
	                resultText.setText(String.valueOf(resultNum));
	            }
	        }
	        
	        operator = key;// 运算符等于用户按的按钮
	        
	        first = true;
	        
	        operateValidFlag = true;
	    }
	

 
	public static void main(String[] args) {
		
		new Calculator ();
	}

}

计算器界面实现图片

 

非GUI实现（中缀表达式（栈实现），后缀表达式（栈实现））

中缀表达式

package com.rong.mycaculator;

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * 中缀表达式实现计算机（栈）
 */
public class MyCalculator {

    private MyStack numStack;

    private  MyStack operStack;

    private List<String> sourceExp;

    public MyCalculator() {

        numStack = new MyStack(10);
        operStack = new MyStack(10);
        sourceExp = new ArrayList<>();
    }


    public int calculate(String exp) {
        getExp(exp);
        inStack(sourceExp);
        return Integer.valueOf(numStack.peek());
    }


    public void inStack(List<String> list) {
        for(String str:sourceExp) {
            if(isOper(str)){
                if(operStack.isEmpty()) {
                    operStack.push(str);
                }else{
                    if(prority(str) <= prority(operStack.peek())) {
                        int num1 = Integer.valueOf(numStack.pop());
                        int num2 = Integer.valueOf(numStack.pop());
                        String oper = operStack.pop();
                        int result = cal(num1, num2, oper);
                        numStack.push(String.valueOf(result));
                        operStack.push(str);
                    }else {
                        operStack.push(str);
                    }
                }
            }else if(isNum(str)) {
                numStack.push(str);
            }
        }
        while(!operStack.isEmpty()){
            int num1 = Integer.valueOf(numStack.pop());
            int num2 = Integer.valueOf(numStack.pop());
            String oper = operStack.pop();
            int result = cal(num1, num2, oper);
            numStack.push(String.valueOf(result));
        }
    }

    /**
     * 加减运算
     * @param num1
     * @param num2
     * @param oper
     * @return
     */
    public int cal(int num1,int num2,String oper){
        int result = 0;
        if(oper.equals("+")){
            result = num2 + num1;
        }
        else if(oper.equals("-")) {
            result = num2 - num1;
        }
        else if(oper.equals("*")) {
            result = num2 * num1;
        }
        else if (oper.equals("/")) {
            result = num2 / num1;
        }
        return result;
    }
    /**
     *判断是否是数字
      * @param str
     */
    public boolean isNum(String str) {
        return str.matches("[0-9]+");
    }

    /**
     * 判断是否是操作符
     */
    public boolean isOper(String str) {
        return str.matches("[\\+\\-\\*\\/]");
    }

    /**
     * 比较操作符的优先级，乘除大于加减
     */
    public int prority(String oper) {
        switch (oper) {
            case"*":
            case"/":
                return 2;
            case"+":
            case"-":
                return 1;
            default:
                return 0;
        }
    }
    /**
     * 将原始表达式拆分
     * @param expression
     */
    private void getExp(String expression) {
        StringTokenizer st = new StringTokenizer(expression,"+-*/",true);
        while (st.hasMoreTokens()) {
            sourceExp.add(st.nextToken());
        }
    }
}









//栈
package com.rong.mycaculator;

public class MyStack {

    //用数组来实现栈
    private String[] stack;
    //top指向栈顶元素
    private int top;
    //指定栈的大小
    private int size;

    public MyStack(int size) {
        if(size < 0 ) {
            System.out.println("栈大小不能小于0");
            return;
        }
        this.size = size;
        stack = new String[size];
        top = -1;
    }

    /**
     * 进栈操作
     * @param num
     */
    public void push(String num){
        //判断是否栈满
        if(isFull()) {
            System.out.println("栈已满");
            return;
        }
        stack[++top] = num;

    }

    /**
     * 出栈操作
     * @return
     */
    public String pop() {
        if(isEmpty()) {
            return  "栈为空";
        }
       return stack[top--];
    }

    /**
     * 查看当前栈顶元素
     */
    public String peek(){
        return stack[top];
    }

    /**
     * 判断栈是否已满
     * @return
     */
    public boolean isFull(){
        return top == size-1;
    }

    /**
     * 判断栈是否为空
     * @return
     */
    public boolean isEmpty() {

        return top == -1;
    }
}

测试

public class Mytest {
    public static void main(String[] args) {
        //中缀表达式
        String exp = "2*3*2+4-5*1";
        MyCalculator myCalculator = new MyCalculator();
        System.out.println("===========计算结果===================");
        System.out.println(exp+"="+myCalculator.calculate(exp));
    }
}

 

//后缀表达式，这里使用MyStack类跟上面一样，如需测试别忘加入上面的MyStack类

package com.rong.mycaculator;

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * 中缀表达式转化为后缀表达式
 */
public class NewCalculator {

    private MyStack operStack;

    private List<String> postFixList;

    private List<String> sourceExp;

    public NewCalculator(){
        operStack = new MyStack(10);
        postFixList = new ArrayList<>();
        sourceExp = new ArrayList<>();
    }

    /**
     * 将中缀表达式转化为后缀表达式
     * @param expression
     * @return
     */
    public List<String> inFixConvertPostFix(String expression) {
        //分解字符串
        getExp(expression);
        for(String str:sourceExp){
            //如果是数字直接加入到集合里
            if(isNum(str)) {
                postFixList.add(str);

                //如果操作符，先看当前操作符栈是否为空，为空直接压入栈
            }else if(isOper(str)) {
                if(operStack.isEmpty()) {
                    operStack.push(str);

                    //如果操作符栈不为空，如果当前栈顶操作符是（直接压入栈
                } else {
                    //如果是（直接压入栈
                    if("(".equals(operStack.peek())){
                        operStack.push(str);
                        continue;
                    }
                    switch (str){
                        case"(":
                            operStack.push(str);
                            break;
                        case")":
                            String oper =operStack.pop();
                            while (!"(".equals(oper)) {
                                //将弹出地操作符添加到后缀表达式中
                                postFixList.add(oper);
                                oper = operStack.pop();
                            }
                            break;
                        case"+":
                        case"-":
                        case"*":
                        case"/":
                            while (!operStack.isEmpty() && prority(str) <= prority(operStack.peek())) {
                                postFixList.add(operStack.pop());
                            }
                            operStack.push(str);
                            break;
                        default:
                             break;
                    }
                }
            }
        }
        postFixList.add(operStack.pop());
        return  postFixList;
    }

    /**
     * 判断是否为数字
     * @param str
     * @return
     */
    public boolean isNum(String str){
        return str.matches("[0-9]+");
    }

    /**
     * 判断是否为操作符
     * @param str
     * @return
     */
    public boolean isOper(String str) {
        return str.matches("[\\+\\-\\*\\/\\(\\)]");
    }

    public int prority(String str) {
        switch (str) {
            case "(":
                return 1;
            case"+":
            case"-":
                return 2;
            case"*":
            case"/":
                return 3;
            default:
                return 0;
        }
    }

    /**
     * 先将字符串分解
     * @param exp
     */
    public void getExp(String exp) {
        StringTokenizer st = new StringTokenizer(exp,"+-*/()",true);
        while (st.hasMoreTokens()){
            sourceExp.add(st.nextToken());
        }

    }

    /**
     * 用后缀表达式进行计算
     * @return
     */
    public int calculator(List<String> strings){
        MyStack stack = new MyStack(10);
        strings.forEach(str->{
            if(isNum(str)){
                stack.push(str);
            }else if(isOper(str)) {
                int num1 = Integer.valueOf(stack.pop());
                int num2= Integer.valueOf(stack.pop());
                int result = cal(num1, num2, str);
                stack.push(result+"");
            }
        });
        return Integer.valueOf(stack.pop());
    }

    public int cal(int num1,int num2,String oper) {
        int result = 0;
        if(oper.equals("+")){
            result = num2 + num1;
        }
        else if(oper.equals("-")) {
            result = num2 - num1;
        }
        else if(oper.equals("*")) {
            result = num2 * num1;
        }
        else if (oper.equals("/")) {
            result = num2 / num1;
        }
        return result;
    }
}

测试

public class Mytest {
    public static void main(String[] args) {


        //后缀表达式
        String exp = "(1+2)*(4+5)";

        NewCalculator nc = new NewCalculator();
        List<String> strings = nc.inFixConvertPostFix(exp);
        System.out.println("================后缀表达式===============");
        strings.forEach(s->{
            System.out.print(s+"\t");
        });
        System.out.println();
        System.out.println("================计算结果================");
        int calculator = nc.calculator(strings);
        System.out.println(exp+"="+calculator);

    }
}