精华内容
下载资源
问答
  • 课程设计的一个程序 java 里面有详细的代码解释 相信都能看懂。。。。
  • 采用工厂方法(Factory Method)设计模式,设计并实现一个多用能计算器。要求如下: ① 画出类图,定义每个类的属性和方法,并分析类之间的关系。 ② 实现多用能计算器,分别实现数值型(标量、向量和矩阵)计算、非...
  • java数据结构算法

    千人学习 2019-11-22 10:12:46
    做一门精致,全面详细的 java数据结构与算法!!! 让天下没有难学的数据结构, 让天下没有难学的算法, 不吹不黑,我们的讲师及其敬业,可以看到课程视频,课件,代码的录制撰写,都是在深夜,如此用心,其心可鉴,他不掉头发,谁...
  • JAVA计算器课程设计

    2010-07-09 20:37:51
    Java课设摘 要 本课程设计将实现一个简单计算器。其类似于Windows附件中自带的...在课程设计中,系统开发平台为Windows 2000XP,程序设计设计语言采用Java,在程序设计中,采用了结构化与面向对象两种解决问题的方法。
  • Java计算器设计实现

    千次阅读 多人点赞 2019-06-01 19:28:05
    回顾及分享一下先前写过的一些Java代码:Java计算器的实现

    需求分析

    • 目的是实现一个基于Java的可以求解带括号加减乘除表达式带界面的计算器。
    • 需要知道的Java技术:Java Swing(Java图形界面设计)、Java集合(栈)、lambda表达式、Java基础等。

    设计思路

    1. 实现一个Java计算器界面类
    2. 实现一个Java计算带括号加减乘除表达式的类
    3. 实现主函数调用

    设计实现

    • Java计算器项目结构:
      计算器项目程序目录结构
      Calculator类为计算器界面设计、Calculate类为计算带括号加减乘除表达式的类,Main函数为项目程序入口。
    • Java计算器界面设计实现代码:
    package Calculator;
    
    import java.awt.BorderLayout;
    import java.awt.CardLayout;
    import java.awt.Dimension;
    import java.awt.GridLayout;
    import java.awt.TextField;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JMenu;
    import javax.swing.JMenuBar;
    import javax.swing.JMenuItem;
    import javax.swing.JPanel;
    import javax.swing.JTextField;
    
    public class Calculator extends JFrame{
    		
    	private double result=0;
    	private int count=0;
    	
    	public Calculator() {
    		this.setSize(330,399);		
    		this.setTitle("计算器");		
    		init();
    //		this.pack();
    		this.setVisible(true);
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		
    	}
    	
    	public void init() {//初始化界面
    		
    		this.setLayout(new BorderLayout()); //总体布局为边框式布局
    		
    		/*
    		 * 总体边框式布局north放置文本框
    		 */		
    		JTextField textField=new JTextField();
    		textField.disable();
    		textField.setPreferredSize(new Dimension(this.getWidth(),50));
    		this.add(textField,BorderLayout.NORTH);
    
    		/*	
    		 * 总体边框式布局center放置@panel(边框式布局)
    		 * @panel边框式布局north放置@panelN(网格布局)
    		 * @panel边框式布局center放置@panelC(卡片式布局)
    		 * @panelC卡片来切换@panel0(标准)和@panel1(科学)两种模式
    		 * @panel0,@panel1均为网格布局
    		 */					
    		JPanel panel=new JPanel();
    		panel.setLayout(new BorderLayout());
    		this.add(panel, BorderLayout.CENTER);
    		
    		JPanel panelN=new JPanel();
    		panelN.setLayout(new GridLayout(1,6));
    		JButton MC=new JButton("MC");
    		JButton MR=new JButton("MR");
    		JButton M0=new JButton("M+");
    		JButton M1=new JButton("M-");
    		JButton MS=new JButton("MS");
    		JButton M=new JButton("M");
    		panelN.add(MC);panelN.add(MR);panelN.add(M0);
    		panelN.add(M1);panelN.add(MS);panelN.add(M);
    		panel.add(panelN,BorderLayout.NORTH);
    		
    		CardLayout cardLayout=new CardLayout();
    		JPanel panelC=new JPanel();
    		panelC.setLayout(cardLayout);
    		
    		JPanel panel0=new JPanel();
    		panel0.setLayout(new GridLayout(6,4));
    		JButton[] standredButton=new JButton[24];
    		String str[]={"%","√","x²","1/x",
    				"CE","C","×","/",
    				"7","8","9","*",
    				"4","5","6","-",
    				"1","2","3","+",
    				"±","0",".","="	
    		};
    		for(int i=0;i<standredButton.length;i++) {
    			standredButton[i]=new JButton(str[i]);
    			String text=standredButton[i].getText();
    			standredButton[i].addActionListener(new ActionListener() {
    				
    				@Override
    				public void actionPerformed(ActionEvent e) {
    					// TODO Auto-generated method stub
    					if(text.equals("CE")||text.equals("C")) {
    						textField.setText("");
    					}
    					else if(text.equals("=")) {
    						String expression=textField.getText();
    						Calculate cal=new Calculate();
    						textField.setText(cal.evaluateExpression(expression)+"");
    					}
    					else if(text.equals("%")) {
    						
    					}
    					else if(text.equals("√")) {
    						result=Double.parseDouble(textField.getText());
    						result=Math.sqrt(result);
    						textField.setText(result+"");
    					}
    					else if(text.equals("x²")) {
    						result=Double.parseDouble(textField.getText());
    						result*=result;
    						textField.setText(result+"");
    					}
    					else if(text.equals("1/x")) {
    						result=Double.parseDouble(textField.getText());
    						result=1/result;
    						textField.setText(result+"");
    					}
    					else if(text.equals("±")) {
    						if(count==0) {
    							textField.setText(textField.getText()+"-");
    							count=1;
    						}
    						else {
    							textField.setText(textField.getText()+"+");
    							count=0;
    						}
    					}
    					else if(text.equals("×")) {
    						textField.setText(textField.getText().substring(0, textField.getText().length()-1));
    					}
    					else {
    						textField.setText(textField.getText()+text);
    					}
    									
    				}
    				
    			}
    			
    			);
    			panel0.add(standredButton[i]);
    		}
    		panelC.add(panel0);
    		
    		JPanel panel1=new JPanel();
    		panel1.setLayout(new GridLayout(7,5));
    		JButton scienceButton[]=new JButton[35];
    		String str1[]= {
    		"x²","x^y","sin","cos","tan",
    		"√","10^x","log","Exp","Mod",
    		"↑","CE","C","×","/",
    		"π","7","8","9","*",
    		"n!","4","5","6","-",
    		"±","1","2","3","+",
    		"(",")","0",".","="				
    		};
    		for(int i=0;i<str1.length;i++) {
    			scienceButton[i]=new JButton(str1[i]);
    			//scienceButton[i].addActionListener();
    			panel1.add(scienceButton[i]);
    		}
    		panelC.add(panel1);
    			
    		panel.add(panelC,BorderLayout.CENTER);
    		
    		/*
    		 * 菜单	
    		 */
    		JMenuBar menuBar=new JMenuBar();
    		this.setJMenuBar(menuBar);
    		JMenu modelMenu=new JMenu("模式");
    		menuBar.add(modelMenu);
    		JMenuItem standred=new JMenuItem("标准");		
    		standred.addActionListener(new ActionListener() {
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				// TODO Auto-generated method stub
    				cardLayout.first(panelC);
    			}		
    		});
    		modelMenu.add(standred);
    		JMenuItem science=new JMenuItem("科学");
    		science.addActionListener(new ActionListener() {
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				// TODO Auto-generated method stub
    				cardLayout.last(panelC);
    			}			
    		});
    		modelMenu.add(science);
    		
    	}
    /*
    	private class ButtonAction implements ActionListener{
    
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			// TODO Auto-generated method stub
    					
    		}		
    	}
    */
    }
    
    
    • Java计算带括号加减乘除表达式类的实现:
    package Calculator;
    
    import java.util.*;
    
    /*
    *使用此类直接调用evaluateExpression方法即可,传入需计算的表达式,返回计算结果
    */
    public class Calculate {
        //这个函数的作用就是使用空格分割字符串,以便后面使用分割函数使得将字符串分割成数组
        public String insetBlanks(String s) {
            String result = "";
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '(' || s.charAt(i) == ')' ||
                        s.charAt(i) == '+' || s.charAt(i) == '-'
                        || s.charAt(i) == '*' || s.charAt(i) == '/')
                    result += " " + s.charAt(i) + " ";
                else
                    result += s.charAt(i);
            }
            return result;
        }
    
        public double evaluateExpression(String expression) {
            Stack<Double> operandStack = new Stack<>();
            Stack<Character> operatorStack = new Stack<>();
            expression = insetBlanks(expression);
            String[] tokens = expression.split(" ");
            for (String token : tokens) {
                if (token.length() == 0)   //如果是空格的话就继续循环,什么也不操作
                    continue;
                //如果是加减的话,因为加减的优先级最低,因此这里的只要遇到加减号,无论操作符栈中的是什么运算符都要运算
                else if (token.charAt(0) == '+' || token.charAt(0) == '-') {
                    //当栈不是空的,并且栈中最上面的一个元素是加减乘除的人任意一个
                    while (!operatorStack.isEmpty()&&(operatorStack.peek() == '-' || operatorStack.peek() == '+' || operatorStack.peek() == '/' || operatorStack.peek() == '*')) {
                        processAnOperator(operandStack, operatorStack);   //开始运算
                    }
                    operatorStack.push(token.charAt(0));   //运算完之后将当前的运算符入栈
                }
                //当前运算符是乘除的时候,因为优先级高于加减,因此要判断最上面的是否是乘除,如果是乘除就运算,否则的话直接入栈
                else if (token.charAt(0) == '*' || token.charAt(0) == '/') {
                    while (!operatorStack.isEmpty()&&(operatorStack.peek() == '/' || operatorStack.peek() == '*')) {
                        processAnOperator(operandStack, operatorStack);
                    }
                    operatorStack.push(token.charAt(0));   //将当前操作符入栈
                }
                //如果是左括号的话直接入栈,什么也不用操作,trim()函数是用来去除空格的,由于上面的分割操作可能会令操作符带有空格
                else if (token.trim().charAt(0) == '(') {
                    operatorStack.push('(');
                }
                //如果是右括号的话,清除栈中的运算符直至左括号
                else if (token.trim().charAt(0) == ')') {
                    while (operatorStack.peek() != '(') {
                        processAnOperator(operandStack, operatorStack);    //开始运算
                    }
                    operatorStack.pop();   //这里的是运算完之后清除左括号
                }
                //这里如果是数字的话直接如数据的栈
                else {
                    operandStack.push(Double.parseDouble(token));   //将数字字符串转换成数字然后压入栈中
                }
            }
            //最后当栈中不是空的时候继续运算,知道栈中为空即可
            while (!operatorStack.isEmpty()) {
                processAnOperator(operandStack, operatorStack);
            }
            return operandStack.pop();    //此时数据栈中的数据就是运算的结果
        }
    
        //这个函数的作用就是处理栈中的两个数据,然后将栈中的两个数据运算之后将结果存储在栈中
        public void processAnOperator(Stack<Double> operandStack, Stack<Character> operatorStack) {
            char op = operatorStack.pop();  //弹出一个操作符
            Double op1 = operandStack.pop();  //从存储数据的栈中弹出连个两个数用来和操作符op运算
            Double op2 = operandStack.pop();
            if (op == '+')  //如果操作符为+就执行加运算
                operandStack.push(op1 + op2);
            else if (op == '-')
                operandStack.push(op2 - op1);   //因为这个是栈的结构,自然是上面的数字是后面的,因此用op2-op1
            else if (op == '*')
                operandStack.push(op1 * op2);
            else if (op == '/')
                operandStack.push(op2 / op1);
        }
    }
    
    
    • 主函数:
    package Calculator;
    
    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Calculator calculator=new Calculator();
    	}
    
    }
    
    

    设计实现展示

    Java实现的计算器

    • 可以随意缩小放大界面,界面部件会跟随界面大小自适应调整。

    其他功能

    • 目前实现了标准型计算,科学型计算更加复杂,实现了界面,没有计算功能,后续可能会继续开发,敬请期待。
    展开全文
  • 课程设计报告 需求分析 问题描述 设计一个一元稀疏多项式简单计算器 . 基本要求 一元稀疏多项式基本功能包括 输入并建立多项式 输出多项式 输出形式为整数序列 n, c1, e1 , c2, e2, ? , cn, en其中 n 是多项式的项数...
  • Java编写的山寨QQ,多人聊天+用户在线 21个目标文件 摘要:JAVA源码,媒体网络,山寨QQ,Java聊天程序 Java编写的山寨QQ,多人聊天+用户在线,程序分服务端和客户端,典型C/S结构, 当用户发送第一次请求的时候,验证...
  • 利用Android studio设计一个计算器

    万次阅读 多人点赞 2020-02-22 13:45:56
    利用Android studio设计一个计算器 计算器界面

    利用Android studio设计一个计算器

    计算器界面

    在这里插入图片描述

    项目结构

    在这里插入图片描述
    其中activity_main.xml文件为计算器的界面,shape_screen.xml为计算器显示器的图形,button1_presssed.xml为按键按压下的图形,button1_nomal.xml为按键未被按压下的图形,button1_shape.xml是为了凸显按键按下和弹起时呈现不同效果的文件。其余的文件类似。

    布局文件

    activity_main.xml如下:
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:background="#000000"
    tools:context="com.example.calculator.MainActivity">  
    
    
      <TextView  //计算器显示屏                                                            
        android:id="@+id/calculator_screen"
        android:layout_width="match_parent"
        android:layout_height="170dp"
        android:layout_marginLeft="10dp"
        android:layout_marginRight="10dp"
        android:layout_marginTop="10dp"
        android:background="@drawable/shape_screen"
        android:gravity="right|bottom"
        android:hint="0"
        android:paddingRight="5dp"
        android:textColor="#000000"
        android:textSize="50sp"/>
    
    
       //各按键
    
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginTop="10dp"
        android:layout_marginLeft="10dp"
        android:layout_marginRight="10dp"
        android:orientation="vertical"
        android:gravity="center_horizontal|center_vertical">
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center">
    
        <Button
            android:layout_width="80dp"
            android:layout_height="80dp"
            android:text="%"
            android:background="@drawable/button1_shape"
            android:textSize="40sp"
            android:id="@+id/button_percent"
            android:layout_marginLeft="10dp"
            android:layout_marginRight="5dp"
            android:layout_marginTop="10dp"
            android:layout_marginBottom="5dp"/>
        <Button
            android:layout_width="80dp"
            android:layout_height="80dp"
            android:text="÷"
            android:background="@drawable/button1_shape"
            android:textSize="45sp"
            android:id="@+id/button_divide"
            android:layout_marginLeft="5dp"
            android:layout_marginRight="5dp"
            android:layout_marginTop="10dp"
            android:layout_marginBottom="5dp"/>
        <Button
            android:layout_width="80dp"
            android:layout_height="80dp"
            android:background="@drawable/button1_shape"
            android:text="×"
            android:textSize="45sp"
            android:id="@+id/button_multiply"
            android:layout_marginLeft="5dp"
            android:layout_marginRight="5dp"
            android:layout_marginTop="10dp"
            android:layout_marginBottom="5dp"/>
        <Button
            android:layout_width="80dp"
            android:layout_height="80dp"
            android:text="C"
            android:background="@drawable/button2_shape"
            android:textSize="40sp"
            android:id="@+id/button_clear"
            android:layout_marginLeft="5dp"
            android:layout_marginRight="10dp"
            android:layout_marginTop="10dp"
            android:layout_marginBottom="5dp"/>
        </LinearLayout>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center">
    
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="7"
                android:textSize="40sp"
                android:background="@drawable/button3_shape"
                android:id="@+id/button_7"
                android:layout_marginLeft="10dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="8"
                android:background="@drawable/button3_shape"
                android:textSize="40sp"
                android:id="@+id/button_8"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="9"
                android:background="@drawable/button3_shape"
                android:textSize="40sp"
                android:id="@+id/button_9"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="+"
                android:background="@drawable/button2_shape"
                android:textSize="40sp"
                android:id="@+id/button_add"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="10dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
    
        </LinearLayout>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center">
    
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="4"
                android:textSize="40sp"
                android:background="@drawable/button3_shape"
                android:id="@+id/button_4"
                android:layout_marginLeft="10dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="5"
                android:background="@drawable/button3_shape"
                android:textSize="40sp"
                android:id="@+id/button_5"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="6"
                android:background="@drawable/button3_shape"
                android:textSize="40sp"
                android:id="@+id/button_6"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:text="-"
                android:background="@drawable/button2_shape"
                android:textSize="50sp"
                android:id="@+id/button_minus"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="10dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
    
        </LinearLayout>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center">
    
    
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:background="@drawable/button3_shape"
                android:text="1"
                android:textSize="40sp"
                android:id="@+id/button_1"
                android:layout_marginLeft="10dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:background="@drawable/button3_shape"
                android:text="2"
                android:textSize="40sp"
                android:id="@+id/button_2"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:background="@drawable/button3_shape"
                android:text="3"
                android:textSize="40sp"
                android:id="@+id/button_3"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:background="@drawable/button2_shape"
                android:text="√"
                android:textSize="40sp"
                android:id="@+id/button_radic"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="10dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="5dp"/>
    
    
        </LinearLayout>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center">
    
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:background="@drawable/button3_shape"
                android:text="0"
                android:textSize="40sp"
                android:id="@+id/button_0"
                android:layout_marginLeft="10dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="10dp"/>
            <Button
                android:layout_width="80dp"
                android:layout_height="80dp"
                android:background="@drawable/button3_shape"
                android:text="."
                android:textSize="45sp"
                android:id="@+id/button_dot"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="5dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="10dp"/>
    
    
            <Button
                android:layout_width="160dp"
                android:layout_height="80dp"
                android:background="@drawable/button4_shape"
                android:text="="
                android:textSize="45sp"
                android:id="@+id/button_equal"
                android:layout_marginLeft="5dp"
                android:layout_marginRight="10dp"
                android:layout_marginTop="5dp"
                android:layout_marginBottom="10dp"/>
    
           </LinearLayout>
        </LinearLayout>
    </LinearLayout>
    
    button1_nomal.xml如下:
     <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval"
    android:useLevel="false">
    
    <solid android:color="#c0c0c0"/>
    
    
    <size
        android:width="30dp"
        android:height="30dp">
    
    </size>
    
    <padding
        android:bottom="10dp"
        android:left="10dp"
        android:right="10dp"
        android:top="10dp">
    
    </padding>
    <stroke android:width="1dp"
        android:color="#000000">//描边
    
    </stroke>
    
    </shape>
    
    button1_pressed.xml如下:
    <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval"
    android:useLevel="false">
    
    <solid android:color="#ffffff"/>
    
    
    <size
        android:width="30dp"
        android:height="30dp">
    
    </size>
    
    <padding
        android:bottom="10dp"
        android:left="10dp"
        android:right="10dp"
        android:top="10dp">
    
    </padding>
    <stroke android:width="1dp"
        android:color="#000000">//描边
    
    </stroke>
    
    </shape>
    
    button1_shape.xml如下:
    <?xml version="1.0" encoding="utf-8"?>
    <selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true" android:drawable="@drawable/button1_pressed"/>
    <item android:drawable="@drawable/button1_nomal"/>
    </selector>
    

    代码文件

    MainActivity.java如下:
    package com.example.calculator;
    
    import android.support.v7.app.ActionBarActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.app.Activity;
    import android.widget.TextView;
    import android.widget.Toast;
    
     public class MainActivity extends Activity  {
       private TextView calculator_monitor;
         private Button   but_0,but_1,but_2,but_3,but_4,but_5,but_6,but_7,but_8,but_9,but_clear,but_divide,
            but_multiply,but_add,but_minus,but_radic,but_dot,but_equal,but_percent;
      double num1=0,num2=0;
      double result=0;//Calculation results
       int operation=0;//Operands
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        calculator_monitor=(TextView)findViewById(R.id.calculator_screen);
        but_0=(Button)findViewById(R.id.button_0);
        but_1=(Button)findViewById(R.id.button_1);
        but_2=(Button)findViewById(R.id.button_2);
        but_3=(Button)findViewById(R.id.button_3);
        but_4=(Button)findViewById(R.id.button_4);
        but_5=(Button)findViewById(R.id.button_5);
        but_6=(Button)findViewById(R.id.button_6);
        but_7=(Button)findViewById(R.id.button_7);
        but_8=(Button)findViewById(R.id.button_8);
        but_9=(Button)findViewById(R.id.button_9);
        but_add=(Button)findViewById(R.id.button_add);
        but_clear=(Button)findViewById(R.id.button_clear);
        but_divide=(Button)findViewById(R.id.button_divide);
        but_dot=(Button)findViewById(R.id.button_dot);
        but_equal=(Button)findViewById(R.id.button_equal);
        but_minus=(Button)findViewById(R.id.button_minus);
        but_multiply=(Button)findViewById(R.id.button_multiply);
        but_radic=(Button)findViewById(R.id.button_radic);
        but_percent=(Button)findViewById(R.id.button_percent);
    
    
        but_0.setOnClickListener(new MyOnClickListener());//加监视器
        but_1.setOnClickListener(new MyOnClickListener());
        but_2.setOnClickListener(new MyOnClickListener());
        but_3.setOnClickListener(new MyOnClickListener());
        but_4.setOnClickListener(new MyOnClickListener());
        but_5.setOnClickListener(new MyOnClickListener());
        but_6.setOnClickListener(new MyOnClickListener());
        but_7.setOnClickListener(new MyOnClickListener());
        but_8.setOnClickListener(new MyOnClickListener());
        but_9.setOnClickListener(new MyOnClickListener());
        but_clear.setOnClickListener(new MyOnClickListener());
        but_divide.setOnClickListener(new MyOnClickListener());
        but_minus.setOnClickListener(new MyOnClickListener());
        but_add.setOnClickListener(new MyOnClickListener());
        but_equal.setOnClickListener(new MyOnClickListener());
        but_multiply.setOnClickListener(new MyOnClickListener());
        but_dot.setOnClickListener(new MyOnClickListener());
        but_radic.setOnClickListener(new MyOnClickListener());
        but_percent.setOnClickListener(new MyOnClickListener());
    
    }
    class MyOnClickListener implements  View.OnClickListener{
        public void onClick(View v){//点击事件的处理方法
            switch (v.getId()){
                case R.id.button_clear:
                    calculator_monitor.setText(null);
                    break;
                case R.id.button_0:
                    String str0=calculator_monitor.getText().toString();//获取输入的内容并转换为string型
                    str0+="0";
                    calculator_monitor.setText(str0);
                    break;
                case R.id.button_1:
                    String str1=calculator_monitor.getText().toString();
                    str1+="1";
                    calculator_monitor.setText(str1);
                    break;
                case R.id.button_2:
                    String str2=calculator_monitor.getText().toString();
                    str2+="2";
                    calculator_monitor.setText(str2);
                    break;
                case R.id.button_3:
                    String str3=calculator_monitor.getText().toString();
                    str3+="3";
                    calculator_monitor.setText(str3);
                    break;
                case R.id.button_4:
                    String str4=calculator_monitor.getText().toString();
                    str4+="4";
                    calculator_monitor.setText(str4);
                    break;
                case R.id.button_5:
                    String str5=calculator_monitor.getText().toString();
                    str5+="5";
                    calculator_monitor.setText(str5);
                    break;
                case R.id.button_6:
                    String str6=calculator_monitor.getText().toString();
                    str6+="6";
                    calculator_monitor.setText(str6);
                    break;
                case R.id.button_7:
                    String str7=calculator_monitor.getText().toString();
                    str7+="7";
                    calculator_monitor.setText(str7);
                    break;
                case R.id.button_8:
                    String str8=calculator_monitor.getText().toString();
                    str8+="8";
                    calculator_monitor.setText(str8);
                    break;
                case R.id.button_9:
                    String str9=calculator_monitor.getText().toString();
                    str9+="9";
                    calculator_monitor.setText(str9);
                    break;
                case R.id.button_dot:
                    String strdot=calculator_monitor.getText().toString();
                    strdot+=".";
                    calculator_monitor.setText(strdot);
                    break;
                case R.id.button_add:
                    String stradd=calculator_monitor.getText().toString();
                    if(stradd.equals(null)){
                        return;
                    }
                    num1=Double.valueOf(stradd);
                    stradd+="+";
                    calculator_monitor.setText(null);
                    operation=1;
                    break;
                case R.id.button_minus:
                    String strminus=calculator_monitor.getText().toString();
                    if(strminus.equals(null)){
                        return;
                    }
                    num1=Double.valueOf(strminus);
                    strminus+="-";
                    calculator_monitor.setText(null);
                    operation=2;
                    break;
                case R.id.button_multiply:
                    String strmultiply=calculator_monitor.getText().toString();
                    if(strmultiply.equals(null)){
                        return;
                    }
                    num1=Double.valueOf(strmultiply);
                    strmultiply+="*";
                    calculator_monitor.setText(null);
                    operation=3;
                    break;
                case R.id.button_divide:
                    String strdivide=calculator_monitor.getText().toString();
                    if(strdivide.equals(null)){
                        return;
                    }
                    num1=Double.valueOf(strdivide);
                    strdivide+="/";
                    calculator_monitor.setText(null);
                    operation=4;
                    break;
                case R.id.button_percent:
                    String strpercent=calculator_monitor.getText().toString();
                    if(strpercent.equals(null)){
                        return;
                    }
                    num1=Double.valueOf(strpercent);
                    strpercent+="%";
                    operation=5;
                    break;
    
    
    
                case R.id.button_equal:
                    String strequ=calculator_monitor.getText().toString();
                    num2=Double.valueOf(strequ);
                    // calculator_monitor.setText(null);
                    switch (operation){
                        case 1:
                            result=num1+num2;
                            calculator_monitor.setText(String.valueOf(num1)+"+"+String.valueOf(num2)+"="+String.valueOf(result));
                            break;
                        case 2:
                            result=num1-num2;
                            calculator_monitor.setText(String.valueOf(num1)+"-"+String.valueOf(num2)+"="+String.valueOf(result));
                            break;
                        case 3:
                            result=num1*num2;
                            calculator_monitor.setText(String.valueOf(num1)+"×"+String.valueOf(num2)+"="+String.valueOf(result));
                            break;
                        case 4:
                            if(num2==0){
                                calculator_monitor.setText("被除数不能为0!");
    
    
                            }
                            else {
                                result = num1 / num2;
                                calculator_monitor.setText(String.valueOf(num1) + "÷" + String.valueOf(num2) + "=" + String.valueOf(result));
                            }
                            break;
                        case 5:
                            result=num1/100;
                            calculator_monitor.setText(String.valueOf(num1) + "%" +"="+String.valueOf(result));
                            break;
    
                        default:
                            result=0;
                            break;
                    }
            }
    
         }
      }
    }
    

    结果示例

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    点击下载可获得完整的工程文件

    展开全文
  • calculator 内容提要在本文构造实现了一个计算器擦亮 calculator 主要内容包括 calculator 的 功能需求分析 calculator 的基本设计思路和类的划分 calculator 的具体实现 关键字 Java计算器 calculator 引言设计实现...
  • Java实现简单计算器

    千次阅读 多人点赞 2020-02-14 10:54:14
    实训要求:(1)要使用 java 的 GUI 设计计算器界面。(2)通过界面按钮,可以实现整数或浮点数的四则运算,并能将结果显示在界面中。(3)计算可以有小数点,和正负整数的计算。(4)要有清零功能。 二 类设计 ...

    实训题 8:简单计算器

    一 项目说明

    在这里插入图片描述
    实训目的:掌握 Java GUI 开发中的布局管理和事件处理机制。
    实训要求:(1)要使用 java 的 GUI 设计出计算器界面。(2)通过界面按钮,可以实现整数或浮点数的四则运算,并能将结果显示在界面中。(3)计算可以有小数点,和正负整数的计算。(4)要有清零功能。

    二 类设计

    在这里插入图片描述
    中缀表达式的计算solution(String str)
    用来中算后缀表达式的值,并将结果返回。准备一个数字栈,一个运算符栈。大致的思路就是遇到,数字直接入数字栈,运算符看优先级进行处理,将要入运算符栈的运算符与栈顶的运算符进行比较,栈顶运算符优先级比较高的话,则把栈顶的运算符弹并且把数字栈的两个数字进行弹出,进行运算,并且把结果再次放到数字栈中,最后剩下的就是最终结果。如果运算符优先级比运算符栈顶的小,则把运算符进栈,最后把运算符都出栈。
    计算加减乘除余caculateResult(char optemp, double num1, double num2)
    通过传入的optemp(表达式符号)参数。是什么符号就进行什么样的运算
    判断符号的优先级getOperlevel(char c)
    先乘除后加减,通过0,1,2对运算符的优先级进行标记

    三 项目实现设计

    首先先设计一个GUI界面,先设置一个JFrame容器,容器中创建两个面板和若干按钮,先把按钮要显示的文字存入字符串数组,然后依次创建几个按钮。在设置一个文本框,用来接收用户输入的内容,centerPanel.setLayout(new GridLayout(4, 4, 12, 16));设置中间面板的布局为网格布局,并指定该容器的行数和列数以及组件之间的水平、垂直间距。centerPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));为面板创建一个框,框的头部为5像素,左为5像素,底部为5像素,右为5像素宽。再设置单行文本域的大小,字体,风格和字号,然后为各按钮设置监听器。定义一个StringBuffer类,用于保存触发产生的内容,在用txt.setText(r.toString());方法将内容输出在文本框中,clear按钮触发后,用r.delete(0,r.length());方法清空字符串中的内容并将结果显示在文本框中,“=”按钮是把触发器触发的数字保存StringBuffer里面,然后用该类的toString()方法返回StringBuffer缓冲区中的字符对象,用String类型的变量接收,该字符串接收到的就是一个中缀表达式,创建一个类,该类用于将输入的中缀表达式进行计算,把计算的结果返回给“=”按钮触发器中的result变量,把该变量转化为字符串输出在文本框中。

    四 运行与测试

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    五 分析与总结

    首先,我看到这个题的第一反应是这个界面的布局要用到网格布局,开始我是想直接在触发器里面实现相应的加减乘除功能的,发现如果要计算四则运算有点困难,单个的加减乘除还是挺容易的,后面写了一些代码后,果断删了重写,采用了数据结构中的中缀表达式的计算算法(要用到栈),不过那个时候用的语言是C语言,所以关于栈的书写就只能去百度了,之后我知道了栈和他的有关方法,自己也尝试这写了一段代码进行了测试,更加熟练的掌握了栈的用法。还顺便看了一下广大网友的代码和算法,发现都大同小异,我自己也在他们写的算法的基础上写了一段代码,新增加了实现小数四则运算的功能,其中判断运算符的优先级那段代码直接搬运了网上的代码。经过测试,发现精度有一点问题,运算的结果有时是正确的,有时是无限接近正确结果(小数点后面的小数位太多了),还有就是实现不了负数的运算,但可以实现浮点数的四则运算。以我现在的水平,这个bug暂时还解决不了。所以就没在修改了然后利用对象的调用把运算结果输出在文本框里面。有一段时间这个程序的界面老是显示不出来,控制台console那里老是闪一下就灭了,我也非常纳闷,之前我还可以显示出来的啊,现在怎么就这样的,百度了很久也没找到答案,后面去请教同学,才发现原来我的聊天窗口没有设置为可见frame.setVisible(true);。所以一般在设置容器的时候,就在他的后面写完他的所有属性,不要写完运行出错了,才发现没有写。`

    Calculater

    package com.itcase_eight;
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.text.DateFormat;
    import java.util.Date;
    
    /**
     * @author 罗志刚
     * @date 2020/12/16 22:09
     */
    public class Calculater {
        public static void createAndShowGUI() {
            Date date=new Date();
            DateFormat format=DateFormat.getDateInstance(DateFormat.SHORT);
            // 对计算器整体框架的建立start
            JFrame f = new JFrame("计算器");// 窗口
            JPanel centerPanel = new JPanel(); // 中间面板
            JPanel startPanel=new JPanel();
            // 初始化功能键
            JButton  left=new JButton("(");
            JLabel  data=new JLabel(format.format(date),JLabel.CENTER);
            data.setFont(new Font("Times New Roman",Font.BOLD,17));
            JButton clear=new JButton("Clear");
            JButton  right=new JButton(")");
            String button[] = { "7", "8", "9", "/", "4", "5", "6", "*", "1", "2", "3", "-", ".", "0", "=", "+"};
            JButton but0 = new JButton(button[0]);
            JButton but1 = new JButton(button[1]);
            JButton but2 = new JButton(button[2]);
            JButton but3 = new JButton(button[3]);
            JButton but4 = new JButton(button[4]);
            JButton but5 = new JButton(button[5]);
            JButton but6 = new JButton(button[6]);
            JButton but7 = new JButton(button[7]);
            JButton but8 = new JButton(button[8]);
            JButton but9 = new JButton(button[9]);
            JButton but10 = new JButton(button[10]);
            JButton but11 = new JButton(button[11]);
            JButton but12 = new JButton(button[12]);
            JButton but13 = new JButton(button[13]);
            JButton but14 = new JButton(button[14]);
            JButton but15 = new JButton(button[15]);
            // 单行输入文本框
            JTextField txt = new JTextField();
            // 使用网格布局方式
            centerPanel.setLayout(new GridLayout(5, 4, 12, 16)); // 左右上下间隔
            centerPanel.add(left);
            centerPanel.add(clear);
            centerPanel.add(right);
            centerPanel.add(data);
            centerPanel.add(but0);
            centerPanel.add(but1);
            centerPanel.add(but2);
            centerPanel.add(but3);
            centerPanel.add(but4);
            centerPanel.add(but5);
            centerPanel.add(but6);
            centerPanel.add(but7);
            centerPanel.add(but8);
            centerPanel.add(but9);
            centerPanel.add(but10);
            centerPanel.add(but11);
            centerPanel.add(but12);
            centerPanel.add(but13);
            centerPanel.add(but14);
            centerPanel.add(but15);
            centerPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
            // 设置容器大小
            txt.setPreferredSize(new Dimension(465, 40));
            // 设置字体,风格和字号
            txt.setFont(new Font("宋体", Font.PLAIN, 28));
            f.add(startPanel);
            f.add(txt, BorderLayout.NORTH); // 将单行文本框添加到窗口的 北部
            f.add(centerPanel, BorderLayout.SOUTH); // 将中间面板添加到窗口的南部
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 点X关闭窗口
            f.setLocation(400, 200); // 初始化时定位
            f.setSize(500, 300);
            // 展示JFrame窗口
            f.setVisible(true);
            f.setResizable(false); // 禁止拖曳改变窗口大小
            f.pack(); // 让窗口的大小自适应
            // 对计算器整体框架的建立end
            // 为按钮事件添加自定义监听器start
            StringBuffer r=new StringBuffer();
            but0.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("7");
                    txt.setText(r.toString());
                }
            });
            but1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("8");
                    txt.setText(r.toString());
                }
            });
            but2.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("9");
                    txt.setText(r.toString());
                }
            });
            but4.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("4");
                    txt.setText(r.toString());
                }
            });
            but5.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("5");
                    txt.setText(r.toString());
                }
            });
            but6.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("6");
                    txt.setText(r.toString());
                }
            });
            left.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("(");
                    txt.setText(r.toString());
                }
            });
            right.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append(")");
                    txt.setText(r.toString());
                }
            });
            but8.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("1");
                    txt.setText(r.toString());
                }
            });
            but9.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("2");
                    txt.setText(r.toString());
                }
            });
            but10.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("3");
                    txt.setText(r.toString());
                }
            });
            but13.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("0");
                    txt.setText(r.toString());
                }
            });
            but15.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("+");
                    txt.setText(r.toString());
                }
            });
            but3.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("/");
                    txt.setText(r.toString());
                }
            });
            but7.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("*");
                    txt.setText(r.toString());
                }
            });
            but12.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append(".");
                    txt.setText(r.toString());
                }
            });
            but11.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("-");
                    txt.setText(r.toString());
                }
            });
            clear.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.delete(0,r.length());   //清空字符串中的内容
                    txt.setText(r.toString());  //将结果显示在文本框中
                }
            });
            but14.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    r.append("=");
                    String str=r.toString();
                    txt.setText("");
                    double result= Computer.solution(str);
                    String string=String.valueOf(result);
                    r.delete(0,r.length());
                    r.append(string);
                    txt.setText(string);
                }
            });
        }
        public static void main(String[] args) {
            SwingUtilities.invokeLater(Calculater::createAndShowGUI);
        }
    }
    
    

    Computer类

    package com.itcase_eight;
    
    import java.util.Stack;
    
    /**
     * @author 罗志刚
     * @date 2020/12/16 22:05
     */
    public class Computer {
        public static double solution(String str) {
            Stack<Double> numStack = new Stack<>();
            Stack<Character> signalStack = new Stack<>();
            int index = 0;// 记录已经执行的符号数
            int len = str.length();
            while (index < len) {
                char c = str.charAt(index); // 取出这一步的符号
                if (c == '(') {
                    signalStack.push(c);// 若是左括号就进栈
                }
                // 否则要先判断优先级
                else if (c == '+' || c == '-' || c == '*' || c == '/') {
                    int currOperLevel = getOperlevel(c);// 当前符号的优先级
                    while (true) {
                        int stackOperLevel = 0;// 栈顶元素的优先级
                        if (!signalStack.isEmpty()) {
                            Object obj = signalStack.peek();
                            stackOperLevel = getOperlevel((char) obj);
                        }
                        // 若当前元素优先级大于栈顶元素的优先级则入栈
                        if (currOperLevel > stackOperLevel) {
                            signalStack.push(c);
                            break;// 直到让比自己优先级高的符号都出栈运算了再把自己进栈
                        } else {// 不能入栈就进行计算
                            try {
                                char optemp = '0';
                                double num1 = 0;
                                double num2 = 0;
                                if (!signalStack.isEmpty()) {
                                    optemp = (char) signalStack.pop();// 取出优先级大的那个符号
                                }
                                if (!numStack.isEmpty()) {
                                    num1 = (double) numStack.pop();
                                    num2 = (double) numStack.pop();// 取出数据栈中的两个数
                                }
                                numStack.push(caculateResult(optemp, num2, num1));// 将算出来的结果数据再次进入数据栈
                            } catch (Exception e) {
                                // TODO: handle exception
                                e.printStackTrace();
                            }
                        }
                    }
                } else if (c == ')') {// 右括号就返回栈顶元素,右括号是不进栈的
                    while (true) {
                        char theop = (char) signalStack.pop();
                        if (theop == '(') {
                            break;
                        } else {
                            try {
                                double num1 = (double) numStack.pop();
                                double num2 = (double) numStack.pop();
                                numStack.push(caculateResult(theop, num2, num1));// 运算括号内的内容
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                } else if (c >= '0' && c <= '9') {
                    int tempIndex = index + 1;
                    while (tempIndex < len) {
                        char temp = str.charAt(tempIndex);// 取字符串中处于当前字符的下一位
                        if ((temp >= '0' && temp <= '9') || temp == '.') {
                            tempIndex++;// 若为数字则继续向后取
                        } else {
                            break;// 证明数字去完
                        }
                    }
                    String numstr = str.substring(index, tempIndex);// 截取这个字符串则为两个符号之间的数字
                    try {
                        double numnum = Double.parseDouble(numstr);// 将数字转换成整型便于运算
                        numStack.push(numnum);
                        index = tempIndex - 1;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                index++;
            }
            // 检查符号栈是否为空
            while (true) {
                Object obj = null;
                if (signalStack.isEmpty() == false) {
                    obj = signalStack.pop();
                }
                if (obj == null) {
                    break;// 为空证明运算已结束
                } else {// 不为空就出栈运算
                    char opterTemp = (char) obj;
                    double num1 = (double) numStack.pop();
                    double num2 = (double) numStack.pop();
                    numStack.push(caculateResult(opterTemp, num2, num1));
                }
            }
            double result = 0;
            try {
                result = (double) numStack.pop();
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            return result;
        }
    
        //计算加减乘除余
        private static Double caculateResult(char optemp, double num1, double num2) {
    
            switch (optemp) {
                case '+':
                    return num1 + num2;
                case '-':
                    return num1 - num2;
                case '*':
                    return num1 * num2;
                case '/':
                    return num1 / num2;
            }
            return 0.0;
        }
    
        //返回符号优先级
        private static int getOperlevel(char c) {
    
            switch (c) {
                case '(':
                    return 0;
                case '+':
                case '-':
                    return 1;
                case '*':
                case '/':
                    return 2;
                default:
                    return 0;
            }
        }
    }
    
    
    
    展开全文
  • Java语言编写计算器

    万次阅读 多人点赞 2018-03-15 15:52:51
    本文讲述Java图形用户界面的编写,重点讲述一个简单计算器的实现。文中程序的运行环境为Windows10 ,编译环境为MyEclipse 8.5。一个简单的计算器主要实现一下功能和要求:一:输入,输出 ①输入:允许输入带有括号...

    本文讲述Java图形用户界面的编写,重点讲述一个简单计算器的实现。

    文中程序的运行环境为Windows10 ,编译环境为MyEclipse 8.5。

    一个简单的计算器主要实现一下功能和要求:

    一:输入,输出

         ①输入:允许输入带有括号的完整计算式(例 6*(3+5)-5÷2)

         ②输出:输出Double类型的结果

    二:功能

         ①:基本的加,减,乘,除,四则运算

         ②:平方运算

         ③:开方运算

    最终界面如下图:


    除了常规的数字按钮和运算符,还有两个常数e,π

    主要思想:

    一:输入,以及运算的实现

         要实现完整计算式的输入并运算,就得用到计算后缀表达式的算法,和将中缀表达式转换为后缀表达式的算法(这里不再赘述中缀表达式和后缀表达式,以及之后有关栈的知识也不再多说,有兴趣可以阅读数据结构中关于栈的相关章节),这里重点讲解以上两个算法。

         算法1(中缀表达式转后缀表达式):

         因为计算式要在计算器的文本编辑框中显示,所以计算式用字符串记录(定义为字符串)

         规则:从左向右遍历中缀表达式

                   ①:遇到数字字符,直接加入后缀表达式

                   ②:遇到高优先级运算符,若栈为空直接入栈,若栈不为空,则将当前运算符与栈顶元素比较

                          比较1(栈顶元素也为高优先级运算符):栈顶元素出栈加入后缀表达式,当前运算符入栈。这样的操作使得栈                                                                                     中不会出现连续的高优先级运算符

                          比较2(栈顶元素为'('左括号):将当前元素入栈

                          比较3(栈顶元素为低优先级运算符):将当前元素入栈

                   ③:遇到'('左括号,将左括号入栈

                   ④:遇到')'右括号,将栈顶元素顺序出栈,直到栈顶元素为左括号,此时删去栈顶的左括号

                   ⑤:遇到低优先级运算符,若栈为空直接入栈,若栈不为空,则将当前运算符与栈顶元素比较

                          比较1(栈顶元素也为低优先级运算符):栈顶元素出栈加入后缀表达式,当前运算符入栈。这样的操作使得栈中                                                                                   不会出现连续的低优先级运算符

                          比较2(栈顶元素为'('左括号):将当前运算符入栈

                          比较③(栈顶元素为高优先级运算符):栈顶元素出栈加入后缀表达式,当前运算符入栈

    程序段如下(代码段中的注释根据上述讲解过程书写,可以根据步骤阅读)

    代码段中用到的某些函数注释:

                     indexof():String.indexof()方法搜索在该字符串上是否出现了作为参数传递的字符串,若找到字符串,则返回字符                                     串首字母的位置(0代表第一个位置),在下面的代码段中,为了判断字符类型用到了该方法。

                     String.valueof():将double类型的浮点数转换为字符串

                     Double.parseDouble():将字符串转化为double类型的浮点数

    private String[] yunsuan(String str)
    	{
    		String s="";//用于承接多位数的字符串
    		char a[]=new char[100];//静态的栈
    		String jieguo[]=new String[100];//后缀表达式字符串数组,为了将多位数存储为独立的字符串
    		int top=-1,j=0;//静态指针top,控制变量j
    		for (int i=0;i<str.length();i++)//遍历中缀表达式
    		{
    			if ("0123456789.".indexOf(str.charAt(i))>=0)//indexof函数见上方注释,遇到数字字符的情况
    			{
    				s="";//作为承接的字符串,每次开始都要清空
                                    for (;i<str.length()&&"0123456789.".indexOf(str.charAt(i))>=0;i++)//将多位数存储在一个字符串中
                                    {
                                         s=s+str.charAt(i);
                                    }
                                    i--;
                                    jieguo[j]=s;//数字字符直接加入后缀表达式
                                    j++;
    			}
    			else if ("(".indexOf(str.charAt(i))>=0)//遇到左括号
    			{
    				top++;
    				a[top]=str.charAt(i);//左括号入栈
    			}
    			else if (")".indexOf(str.charAt(i))>=0)//遇到右括号
    			{
    				for (;;)//栈顶元素循环出栈,直到找到左括号为止
    				{
    					if (a[top]!='(')//栈顶元素不是左括号
    					{
    						jieguo[j]=a[top]+"";//栈顶元素出栈
    						j++;
    						top--;
    					}
    					else//找到栈顶元素是左括号
    					{
    						top--;//删除栈顶的左括号
    						break;//循环结束
    					}
    				}
    			}
    			else if ("*%÷".indexOf(str.charAt(i))>=0)//遇到高优先级运算符
    			{
    				if (top==-1)//若栈为空直接入栈
    				{
    					top++;
    					a[top]=str.charAt(i);
    				}
    				else//栈不为空
    				{
    					if ("*%÷".indexOf(a[top])>=0)//栈顶元素也为高优先级运算符
    					{
    						jieguo[j]=a[top]+"";//栈顶元素出栈进入后缀表达式
    						j++;
    						a[top]=str.charAt(i);//当前运算符入栈
    					}
    					else if ("(".indexOf(a[top])>=0)//栈顶元素为左括号,当前运算符入栈
    					{
    						top++;
    						a[top]=str.charAt(i);
    					}
    					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//栈不为空
    				{
    					if ("%*÷".indexOf(a[top])>=0)//栈顶元素为高优先级运算符
    					{
    						jieguo[j]=a[top]+"";//栈顶元素出栈加入后缀表达式
    						j++;
    						a[top]=str.charAt(i);//当前运算符入栈
    					}
    					else if ("(".indexOf(a[top])>=0)//栈顶元素为左括号
    					{
    						top++;
    						a[top]=str.charAt(i);//当前运算符入栈
    					}
    					else if ("+-".indexOf(a[top])>=0)//栈顶元素也为低优先级运算符
    					{
    						jieguo[j]=a[top]+"";//栈顶元素出栈进入后缀表达式
    						j++;
    						a[top]=str.charAt(i);//当前元素入栈
    					}
    				}
    			}
    		}
    		for (;top!=-1;)//遍历结束后将栈中剩余元素依次出栈进入后缀表达式
    		{
    			jieguo[j]=a[top]+"";
    			j++;
    			top--;
    		}
    		return jieguo;
    	}
    

         算法2:计算后缀表达式

                     计算后缀表达式依然借助栈来实现

                     运算规则:遍历后缀表达式

                     ①:遇到数字字符,直接入栈

                     ②:遇到运算符,顺序出栈两个元素(数字),进行运算,将运算结果入栈

                     循环以上步骤最终栈中剩下的那个数字就是最终答案

         程序段如下:
     public String Result(String str[])
        {
            String Result[]=new String[100];//顺序存储的栈,数据类型为字符串
            int Top=-1;//静态指针Top
            for (int i=0;str[i]!=null;i++)//遍历后缀表达式
            {
                if ("+-*%÷".indexOf(str[i])<0)//遇到数字字符进栈
                {
                    Top++;
                    Result[Top]=str[i];
                }
                if ("+-*%÷".indexOf(str[i])>=0)//遇到运算符
                {
                    double x,y,n;
                    x=Double.parseDouble(Result[Top]);//顺序出栈两个数字字符串,并转换为double类型的数字
                    Top--;
                    y=Double.parseDouble(Result[Top]);//顺序出栈两个数字字符串,并转换为double类型的数字
                    Top--;
                    if ("-".indexOf(str[i])>=0)//一下步骤根据运算符来进行运算
                    {
                        n=y-x;
                        Top++;
                        Result[Top]=String.valueOf(n);//将运算结果重新入栈
                    }
                    if ("+".indexOf(str[i])>=0)
                    {
                        n=y+x;
                        Top++;
                        Result[Top]=String.valueOf(n);
                    }
                    if ("*".indexOf(str[i])>=0)
                    {
                        n=y*x;
                        Top++;
                        Result[Top]=String.valueOf(n);
                    }
                    if ("÷".indexOf(str[i])>=0)
                    {
                        if (x==0)//不允许被除数为0
                        {
                            String s="ERROR";
                            return s;
                        }
                        else
                        {
                            n=y/x;
                            Top++;
                            Result[Top]=String.valueOf(n);
                        }
                    }
                    if ("%".indexOf(str[i])>=0)
                    {
                        if (x==0)//不允许被除数为0
                        {
                            String s="ERROR";
                            return s;
                        }
                        else
                        {
                            n=y%x;
                            Top++;
                            Result[Top]=String.valueOf(n);
                        }
                    }
                }
            }
            return Result[Top];//返回最终结果
        }
         算法3:开方运算
          程序段如下(调用了Math.sqrt()函数实现)
    public String yunsuan2(String str)
        {
            String result="";
            double a=Double.parseDouble(str),b=0;
            b=Math.sqrt(a);
            result=String.valueOf(b);
            return result;
        }
         算法4:平方运算
          程序段如下(调用了Math.pow()函数实现)
    public String yunsuan3(String str)
        {
            String result="";
            double a=Double.parseDouble(str),b=0;
            b=Math.pow(a, 2);
            result=String.valueOf(b);
            return result;
        }

    界面设计:

    一:框架

     本计算器是基于Swing组建的图形用户界面,采用JFrame框架作为主窗口

           

    public class Calculator extends JFrame implements ActionListener
    类名Calculator(计算器),继承JFrame框架,实现事件监听器接口

    二:文本行,按钮

    整个计算器界面,可以随意发挥,我编写的界面最终的样子在文章开头有图片

    计算器类中,定义的成员有:

        ①private String[] KEYS={"7","8","9","*","4","5","6","-","1","2","3","+","0","e","π","÷","c","%",".","=","(",")","sqr","x*x"};
        ② private JButton keys[]=new JButton[KEYS.length];
        ③private JTextField resultText = new JTextField("0.0");
        ④private String b="";

    ①:按钮标签字符串

    ②:定义按钮数组

    ③:定义文本行

    ④:用于存放计算式

    构造方法代码段如下(计算器的整体界面完成)

    public Calculator()
        {
            super("计算器");
            this.setLayout(null);//未采用任何类型的布局,后面的文本框和按钮显示位置都是自己计算好的位置
            resultText.setBounds(20, 5, 255, 40);//设置文本框大小
            resultText.setHorizontalAlignment(JTextField.RIGHT);//文本框内容右对齐
            resultText.setEditable(false);//文本框不允许修改结果
            this.add(resultText);//新建文本框
            int x=20,y=55;
            for (int i=0;i<KEYS.length;i++)//放置按钮
            {
                keys[i] = new JButton();
                keys[i].setText(KEYS[i]);
                keys[i].setBounds(x, y, 60, 40);
            if(x<215)
                {
                    x+=65;
                }
            else
                {
                    x = 20;
                    y+=45;
                }
                this.add(keys[i]);
            }
            for (int i = 0; i <KEYS.length; i++) //每个按钮都注册事件监听器
            {
                keys[i].addActionListener(this);
            }
            this.setResizable(false);
            this.setBounds(500, 200, 300, 400);
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);
            this.setVisible(true);
        }

    事件处理(以下代码用同一个字符串来记录计算式和结果,保证了计算式可以连续计算)

    public void actionPerformed(ActionEvent e)//处理事件
        {
            String label = e.getActionCommand(); //获得事件源的标签
            if (label=="c"||label=="=")//按钮C清空文本框,消除前面所有的输入和结果
            {
                if(label=="=")//按钮=得出最终结果,调用计算方法
                {
                    String s[]=yunsuan(this.b);
                    String result=Result(s);
                    this.b=result+"";
                    resultText.setText(this.b);//更新文本框,当前结果在字符串b中,并未删除,下一次输入是接着这个结果的,这样可以实现连续运算
                }
                else
                {
                    this.b="";
                    resultText.setText("0");//更新文本域的显示,显示初始值
                }
            }
            else if (label=="sqr")//sqr 按钮计算开方
            {
                String n=yunsuan2(this.b);
                resultText.setText(n);
                this.b=n;
            }
            else if(label=="x*x")//x*x按钮实现某个数的平方
            {
                String m=yunsuan3(this.b);
                resultText.setText(m);
                this.b=m;
            }
            else if(label=="e"||label=="π")
            {
                if (label=="e")//常数e
                {
                    String m=String.valueOf(2.71828);
                    this.b=this.b+m;
                    resultText.setText(this.b);
                }
                if (label=="π")//常数π
                {
                    String m=String.valueOf(3.14159265);
                    this.b=this.b+m;
                    resultText.setText(this.b);
                }
            }
            else
            {
                this.b=this.b+label;
                resultText.setText(this.b);
            }
        }

    计算器已经完成,完整代码如下:

    import javax.swing.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    public class Calculator extends JFrame implements ActionListener
    {
        private String[] KEYS={"7","8","9","*","4","5","6","-","1","2","3","+","0","e","π","÷","c","%",".","=","(",")","sqr","x*x"};
        private JButton keys[]=new JButton[KEYS.length];
        private JTextField resultText = new JTextField("0.0");
        private String b="";
        public Calculator()
        {
            super("计算器");
            this.setLayout(null);
            resultText.setBounds(20, 5, 255, 40);
            resultText.setHorizontalAlignment(JTextField.RIGHT);
            resultText.setEditable(false);
            this.add(resultText);
            int x=20,y=55;
            for (int i=0;i<KEYS.length;i++)
            {
                keys[i] = new JButton();
                keys[i].setText(KEYS[i]);
                keys[i].setBounds(x, y, 60, 40);
            if(x<215)
                {
                    x+=65;
                }
            else
                {
                    x = 20;
                    y+=45;
                }
                this.add(keys[i]);
            }
            for (int i = 0; i <KEYS.length; i++) 
            {
                keys[i].addActionListener(this);
            }
            this.setResizable(false);
            this.setBounds(500, 200, 300, 400);
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);
            this.setVisible(true);
        }
        public void actionPerformed(ActionEvent e)
        {
            String label = e.getActionCommand(); 
            if (label=="c"||label=="=")
            {
                if(label=="=")
                {
                    String s[]=yunsuan(this.b);
                    String result=Result(s);
                    this.b=result+"";
                    resultText.setText(this.b);
                }
                else
                {
                    this.b="";
                    resultText.setText("0");
                }
            }
            else if (label=="sqr")
            {
                String n=yunsuan2(this.b);
                resultText.setText(n);
                this.b=n;
            }
            else if(label=="x*x")
            {
                String m=yunsuan3(this.b);
                resultText.setText(m);
                this.b=m;
            }
            else if(label=="e"||label=="π")
            {
                if (label=="e")
                {
                    String m=String.valueOf(2.71828);
                    this.b=this.b+m;
                    resultText.setText(this.b);
                }
                if (label=="π")
                {
                    String m=String.valueOf(3.14159265);
                    this.b=this.b+m;
                    resultText.setText(this.b);
                }
            }
            else
            {
                this.b=this.b+label;
                resultText.setText(this.b);
            }
        }
        private String[] yunsuan(String str)
    	{
    		String s="";
    		char a[]=new char[100];
    		String jieguo[]=new String[100];
    		int top=-1,j=0;
    		for (int i=0;i<str.length();i++)
    		{
    			if ("0123456789.".indexOf(str.charAt(i))>=0)
    			{
    				s="";
                    for (;i<str.length()&&"0123456789.".indexOf(str.charAt(i))>=0;i++)
                    {
                        s=s+str.charAt(i);
                    }
                    i--;
                    jieguo[j]=s;
                    j++;
    			}
    			else if ("(".indexOf(str.charAt(i))>=0)
    			{
    				top++;
    				a[top]=str.charAt(i);
    			}
    			else if (")".indexOf(str.charAt(i))>=0)
    			{
    				for (;;)
    				{
    					if (a[top]!='(')
    					{
    						jieguo[j]=a[top]+"";
    						j++;
    						top--;
    					}
    					else
    					{
    						top--;
    						break;
    					}
    				}
    			}
    			else if ("*%÷".indexOf(str.charAt(i))>=0)
    			{
    				if (top==-1)
    				{
    					top++;
    					a[top]=str.charAt(i);
    				}
    				else
    				{
    					if ("*%÷".indexOf(a[top])>=0)
    					{
    						jieguo[j]=a[top]+"";
    						j++;
    						a[top]=str.charAt(i);
    					}
    					else if ("(".indexOf(a[top])>=0)
    					{
    						top++;
    						a[top]=str.charAt(i);
    					}
    					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
    				{
    					if ("%*÷".indexOf(a[top])>=0)
    					{
    						jieguo[j]=a[top]+"";
    						j++;
    						a[top]=str.charAt(i);
    					}
    					else if ("(".indexOf(a[top])>=0)
    					{
    						top++;
    						a[top]=str.charAt(i);
    					}
    					else if ("+-".indexOf(a[top])>=0)
    					{
    						jieguo[j]=a[top]+"";
    						j++;
    						a[top]=str.charAt(i);
    					}
    				}
    			}
    		}
    		for (;top!=-1;)
    		{
    			jieguo[j]=a[top]+"";
    			j++;
    			top--;
    		}
    		return jieguo;
    	}
        public String yunsuan2(String str)
        {
            String result="";
            double a=Double.parseDouble(str),b=0;
            b=Math.sqrt(a);
            result=String.valueOf(b);
            return result;
        }
        public String yunsuan3(String str)
        {
            String result="";
            double a=Double.parseDouble(str),b=0;
            b=Math.pow(a, 2);
            result=String.valueOf(b);
            return result;
        }
        public String Result(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 x,y,n;
                    x=Double.parseDouble(Result[Top]);
                    Top--;
                    y=Double.parseDouble(Result[Top]);
                    Top--;
                    if ("-".indexOf(str[i])>=0)
                    {
                        n=y-x;
                        Top++;
                        Result[Top]=String.valueOf(n);
                    }
                    if ("+".indexOf(str[i])>=0)
                    {
                        n=y+x;
                        Top++;
                        Result[Top]=String.valueOf(n);
                    }
                    if ("*".indexOf(str[i])>=0)
                    {
                        n=y*x;
                        Top++;
                        Result[Top]=String.valueOf(n);
                    }
                    if ("÷".indexOf(str[i])>=0)
                    {
                        if (x==0)
                        {
                            String s="ERROR";
                            return s;
                        }
                        else
                        {
                            n=y/x;
                            Top++;
                            Result[Top]=String.valueOf(n);
                        }
                    }
                    if ("%".indexOf(str[i])>=0)
                    {
                        if (x==0)
                        {
                            String s="ERROR";
                            return s;
                        }
                        else
    
                        {
                            n=y%x;
                            Top++;
                            Result[Top]=String.valueOf(n);
                        }
                    }
                }
            }
            return Result[Top];
        }
        public static void main(String arg[])
        {
            Calculator a=new Calculator();
        }
    }
    
    

    该计算器功能有限,只限于日常生活的使用,可以改进的方向很多

    一:实现带符号数的运算,例如:-6-6

    二:实现复数运算

    三:实现多次方的运算

    四:实现一元一次方程的运算

    五:实现一元二次方程的运算

    以上改进方向只是一小部分,对于有一些编程基础的人,可以尝试一下,对于大神这就是小儿科了。

    欢迎读者评论,共同交流,共同进步。

    展开全文
  • java编写的计算器,可以实现基本计算器和科学计算器之间的切换~实现了基本数据结构,包括栈和队列,实现中缀表达式转后缀表达式以及后缀表达式的求值~ 解压之后的文件夹中有打包之后的jar文件和可执行exe文件,另外...
  • Java制作简易的计算器

    2021-06-03 19:08:09
    import java.util.Scanner; public class Demo04 { public static void main(String[] args) { //制作一个计算器,可以简单的使用加减乘除,并用Scanner进行用户交互且循环输出 ///思路: //1、先定义加法,写...
  • Java入门——计算器(界面篇)

    千次阅读 2019-06-21 17:07:57
    学了一段时间,终于开始尝试写自己的计算器了。 分成两部分来完成,一是界面的实现;而是核心功能的实现。今天先来第一部分,界面。 目录 概要设计 简要说明 文件结构 代码介绍 面板的设计代码 界面代码 ...
  • Java工厂设计模式(简单计算器实现)

    千次阅读 2019-04-08 15:09:29
    总体的目录结构如下 1.基础工厂类 public interface BaseFactory { } 2.拓展工厂类 public class OperationFactoryimplements BaseFactory{ /** * 工厂类的本质是帮助判断对应的实例,将这种判断放在工厂当中,...
  • java计算器源码+文档

    2009-10-22 22:27:28
    数据库课程设计计算器——主要实现四则混和运算,简单科学计算,数制间转换,获取系统时间,另有帮助选项并设有热键 类Calculator为程序主体部分,包括GUI的设计,各功能键的响应处理,各种异常的处理及帮助信息的...
  • 欢迎来到<IT_WEH_coder>的博客。...系统分析与设计2.1设计目的2.2功能需求2.3系统运行结构图2.4系统功能代码设计2.4.1包和类的说明2.4.2简易计算器的源代码清单3.系统调试3.1编写源程序界面3..
  • 数据结构课程设计之使用栈实现简单运算(包含四则运算和平方)
  • 把内容提取分割,使用了Double类,使用了递归方法 ...import java.util.ArrayList; import java.util.Scanner; public class Calculator { public static void main(String[] args) { Scanner sc = new ...
  • 数据结构课程设计 计算器的实现代码,java语言
  • java计算器实验报告

    千次阅读 2015-04-30 09:48:00
    1.熟悉java图形用户界面的设计原理和程序结构 2.能设计复核问题要求的图形用户界面程序 3.熟悉javaawt和swing的组合 4.掌握常用组建的事件借口 5.会应用awt和swing组件进行应用程序设计 二、实验条件 1.PC机一...
  • 话不多说,用java中Switch结构可以编写一个简单的计算器,代码如图所示; package com.wcj.method; ​ import java.util.Scanner; ​ 目录 用java编写一个简单的计算器 public class Calculator { public ...
  • 堆栈实现的java计算器

    2010-04-13 14:33:45
    堆栈实现的计算器-数据结构课程设计,应用字符优先级
  • java写的一个计算器程序,对用户输入的表达式求值。
  • java计算器(基于Javafx)

    千次阅读 2018-05-16 21:33:14
    Swing被Javafx取代,还是很多人用,我们学校老师也在用swing...今日有空先写个界面,完全仿照Windows里的Calculator等我把数据结构复习一遍再把event加上。import javafx.application.Application; import javafx.g...
  • JAVA大作业计算器,支持括号,异常处理
  • 有6个题目,分别是:一元多项式计算器、数据压缩与解压(用FX画二叉树)、手机模拟通讯录(有FX界面)、24点游戏(有FX界面)、教学计划编制、交通管理系统。
  • Java 设计极简计算器

    2019-10-03 14:59:02
    Java 简易计算器 最近Java作业是设计一个简易计算器 要求是利用Jframe和Jpanel设计计算器同时实现其基本功能 代码主要分成三块 构造函数 主要用于生成按钮等组件以及排版 ...
  • 设计一个一元稀疏多项式简单计算器。其基本功能包括: (1) 输入并建立多项式; (2) 输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,......,cn,en,其中 n 是 多项式的项数,ci,ei分别是第 i 项的系数和...
  • JavaGUI怎么设计计算器界面】

    千次阅读 2019-11-14 19:33:39
    import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;... * GUI设计进阶+事件处理 * 时间:2019.11.13 * 完成人:梁达林 */ public class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,652
精华内容 4,660
关键字:

java计算器结构设计

java 订阅