JAVA——简单科学计算器设计

package Calculator_JCoder;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.text.DecimalFormat;
import javax.swing.*;
import java.util.*;
import java.math.*;

public class Calculator extends JFrame implements ActionListener {
    static Font F = new Font("宋体",Font.BOLD,25);
    static Font _F = new Font("宋体",Font.BOLD,40);
    static DecimalFormat DF = new DecimalFormat("0.0000000000");
    static String IN = "";
    static JTextField Text_Res = new JTextField("0");
    static JTextField Text_Now = new JTextField("");
    static JButton Keys[] = new JButton[21];
    static String KeysName[] = {
            "7", "8", "9", "4", "5", "6", "1", "2",
            "3", "0", ".", "+", "-", "*", "/", "=",
            "CE", "(", ")", "^", "C"
    };

    static int CMP(char a){
        if(a == ‘#‘){return 0;}
        if(a == ‘(‘){return 1;}
        if(a == ‘+‘ || a == ‘-‘){return 3;}
        if(a == ‘*‘ || a == ‘/‘){return 4;}
        if(a == ‘^‘){return 5;}
        if(a == ‘)‘){return 6;}
        return -1;
    }

    static String Change(String in){
        in += "#";
        int L = in.length();
        String t = "";
        String NPR = "";
        Stack<Character> S = new Stack();
        for(int i = 0;i < L;i ++){
            if(in.charAt(i) >= ‘0‘ && in.charAt(i) <= ‘9‘){t += in.charAt(i);}
            else if(in.charAt(i) == ‘.‘){t += in.charAt(i);}
            else if(in.charAt(i) == ‘#‘){
                if(t.length() != 0){NPR += t + " ";}
                t = "";
            }
            else if(in.charAt(i) == ‘+‘ || in.charAt(i) == ‘-‘ || in.charAt(i) == ‘*‘ || in.charAt(i) == ‘/‘ || in.charAt(i) == ‘^‘){
                if(t.length() != 0){NPR += t + " ";}
                t = "";
                if(S.size() == 0){
                    S.push(in.charAt(i));
                }
                else if(CMP(S.peek()) < CMP(in.charAt(i))){
                    S.push(in.charAt(i));
                }
                else if(CMP(S.peek()) >= CMP(in.charAt(i))){
                    NPR += S.peek() + " ";
                    S.pop();
                    S.push(in.charAt(i));
                }
            }
            else if(in.charAt(i) == ‘(‘){
                if(t.length() != 0){NPR += t + " ";}
                t = "";
                S.push(in.charAt(i));
            }
            else if(in.charAt(i) == ‘)‘){
                if(t.length() != 0){NPR += t + " ";}
                t = "";
                while(S.peek() != ‘(‘){
                    NPR += S.peek() + " ";
                    S.pop();
                }
                S.pop();
            }
        }
        while(S.size() != 0){
            NPR += S.peek() + " ";
            S.pop();
        }
        //System.out.println(NPR);
        return NPR;
    }

    static double Solve(double a,double b,char c){
        double out = 0.0;
        if(c == ‘+‘){
            out = a + b;
        }
        else if(c == ‘-‘){
            out = a - b;
        }
        else if(c == ‘*‘){
            out = a * b;
        }
        else if(c == ‘/‘){
            out = a / b;
        }
        else if(c == ‘^‘){
            out = Math.pow(a,b);
        }
        return out;
    }

    static double Cal(String now){
        String Sp[] = now.split("\\ ");
        Stack<Double> S = new Stack();
        for(int i = 0;i < Sp.length;i ++){
            if(Sp[i].length() == 0){continue;}
            if(Sp[i].charAt(0) <= ‘9‘ && Sp[i].charAt(0) >= ‘0‘){
                S.push(Double.valueOf(Sp[i]));
            }
            else{
                double b = S.peek();S.pop();
                double a = S.peek();S.pop();
                double c = Solve(a,b,Sp[i].charAt(0));
                S.push(c);
            }
        }
        double ans = S.peek();
        return ans;
    }

    static String SetS(int x){
        if(x == 1){return "+";}
        if(x == 2){return "-";}
        if(x == 3){return "*";}
        if(x == 4){return "/";}
        return "0";
    }

    public void init() {
        JPanel KeysP = new JPanel();
        KeysP.setLayout(null);
        KeysP.setSize(500,500);
        for(int i = 0;i <= 20;i ++){
            Keys[i] = new JButton(KeysName[i]);
            KeysP.add(Keys[i]);
            Keys[i].setFont(F);
        }
        Keys[0].setBounds(20,20,60,60);
        Keys[1].setBounds(85,20,60,60);
        Keys[2].setBounds(150,20,60,60);
        Keys[3].setBounds(20,85,60,60);
        Keys[4].setBounds(85,85,60,60);
        Keys[5].setBounds(150,85,60,60);
        Keys[6].setBounds(20,150,60,60);
        Keys[7].setBounds(85,150,60,60);
        Keys[8].setBounds(150,150,60,60);
        Keys[9].setBounds(20,215,125,60);
        Keys[10].setBounds(150,215,60,60);
        Keys[11].setBounds(215,20,60,60);
        Keys[12].setBounds(280,20,60,60);
        Keys[13].setBounds(215,85,60,60);
        Keys[14].setBounds(280,85,60,60);
        Keys[15].setBounds(215,150,125,60);
        Keys[16].setBounds(215,215,125,60);
        Keys[17].setBounds(345,20,60,60);
        Keys[18].setBounds(345,85,60,60);
        Keys[19].setBounds(345,150,60,60);
        Keys[20].setBounds(345,215,60,60);    

        Text_Res.setHorizontalAlignment(JTextField.RIGHT);
        Text_Now.setHorizontalAlignment(JTextField.RIGHT);
        Text_Res.setEditable(false);
        Text_Now.setEditable(false);
        Text_Res.setBackground(Color.WHITE);
        Text_Now.setBackground(Color.WHITE);
        JPanel TextP = new JPanel();
        TextP.setLayout(null);
        TextP.setSize(500,100);
        TextP.add(Text_Res);
        Text_Res.setBounds(20, 60, 385, 60);
        TextP.add(Text_Now);
        Text_Now.setBounds(20, 20, 385, 40);
        Text_Res.setFont(_F);
        Text_Now.setFont(F);

        JPanel BigP = new JPanel();
        BigP.setSize(800,600);
        BigP.setLayout(null);
        BigP.add(KeysP);
        BigP.add(TextP);
        KeysP.setBounds(0, 120, 600, 600);
        TextP.setBounds(0, 0, 500, 200);
        getContentPane().setLayout(null);
        getContentPane().add(BigP);

        for (int i = 0; i <= 20; i ++) {
            Keys[i].addActionListener(this);
        }

    }

    public void actionPerformed(ActionEvent e) {
        String Get = e.getActionCommand();
        if("0123456789.+-*/^()".indexOf(Get) >= 0){
            IN = IN + Get;
            Text_Now.setText(IN);
        }
        else if("=".indexOf(Get) >= 0){
            double show = Cal(Change(IN));
            //System.out.println(show);
            //System.out.println(show);
            String t1 = String.valueOf(show);
            String t2 = String.valueOf(DF.format(show));
            Text_Res.setText(t1);
            IN = t2;
        }
        else if("CE".compareTo(Get) == 0){
            int L = IN.length();
            if(L != 0){IN = IN.substring(0,L - 1);}
            Text_Now.setText(IN);
        }
        else if("C".compareTo(Get) == 0){
            IN = "";
            Text_Now.setText(IN);
            Text_Res.setText("0");
        }
    }

    public Calculator(){
        super();
        init();
        this.setTitle("Calculator By-J_Coder");
        this.setResizable(false);
        this.setLocation(100,100);
        this.setSize(440,450);
    }

    public static void main(String[] args) {
        Calculator window = new Calculator();
        window.setVisible(true);
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

原文地址:https://www.cnblogs.com/love-fromAtoZ/p/9704113.html

时间: 2024-10-12 03:46:35

JAVA——简单科学计算器设计的相关文章

团队-科学计算器-设计文档

"科学计算器"是一种操作简单.界面美观.功能较齐全的电子计算器的一种.这个项目的整个程序我们设计主要分为两个功能模块和十个类模块,其中两个功能模块分别是:计算结果显示模块.计算器按键模块,十个类模块分别是:加.减.乘.除.归零.等于.sin.cos.tan.进制转换. 具体设计过程如下: 1)   设计程序主界面 2)   实现监听TextView.button事件. 具体实现的功能如下: 功能○   :加.减.乘.除.归零.等于 功能一   :具有基本三角函数计算功能(sin,tan

《团队-科学计算器-设计文档》

设计文档: 项目:科学计算器 编辑器:python 所运用知识: 1.字符串的处理 2.正则表达式的运用 3.函数递归 基本思路: 需要优先处理内层括号运算--外层括号运算--先乘除后加减的原则: 1.正则处理用户输入的字符串,然后对其进行判断,判断计算公式是否有括号,有就先将计算公式进行正则处理,先获取最里层的每一个数据,然后一一计算 2.把有括号的计算公式计算出来的结果替换原来初始公式的位置,计算之前分别对重复运算符进行处理需要处理的重复运算 3.然后依次从里到外去除括号并进行计算,和位置替

java简单的计算器类

package chap; import java.awt.BorderLayout; import java.awt.Color; import java.awt.FlowLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.text.DecimalFormat; import javax.swing.JBu

JAVA 图形开发之计算器设计(事件监听机制)

/*文章中用到的代码只是一部分,需要源码的可通过邮箱联系我 [email protected]*/ 前段时间刚帮同学用MFC写了个计算器,现在学到JAVA的图形开发,就试着水了一个计算器出来.(可以说是一个水的不能再水的计算器了,感觉MFC真好用) 既然是设计计算器,首先肯定是要做一个计算器界面出来了,但面对JAVA容器的两种布局,想把按钮放整齐真的是一件比较难的事,我就直接用了坐标法贴图(上篇博客中有介绍).这是我设计的界面 界面设计完了,下面就要开始实现按按钮输入数据.这时就需要使用事件监听

百度的科学计算器(简单)

今年,百度的科学计算器进行了重大更新,可以计算更为复杂的表达式了. 定义表达式中存在加减运算.括号.函数调用.强制类型转换这几种运算.其中数值的类型有整型与浮点型两种.并且, 整型与整型加减运算的结果为整型: 整型与浮点型加减运算结果为浮点型: 浮点型与浮点型加减运算结果为浮点型. 强制类型转换符 包括int(x)与float(x),其中float(x)运算符可以将数值x的类型强制转为浮点型,int(x)运算符可以将数值x的类型强制转为整型.对于浮点型转整型,采用截尾法,例如:int(1.6)=

2017计蒜之道 初赛 第二场 百度的科学计算器(简单)

/** 题目:2017计蒜之道 初赛 第二场 百度的科学计算器(简单) 链接:https://nanti.jisuanke.com/t/15504 题意:给一个合法的表达式,包含加号+.减号-.括号().数字常量,表达式中没有空格. 输入数据保证数字常量以及计算过程中数值绝对值均不超过 10^12??,对于浮点型数值常量,保证小数点后不超过 666 位. 思路:暴力模拟:python有函数可以直接调用. 坑点:如果表达式中出现过浮点数,那么输出结果保留6位小数, 否则输出整数,不出现小数. */

使用Java实现的简单的计算器

package calculate; /** * @author Wayne; * @time 2014年7月14日; * @project java计算器2.0; */ import java.awt.*; import java.awt.event.*; import java.text.DecimalFormat; import javax.swing.*; import javax.swing.JOptionPane; import javax.script.*; public clas

结对项目-增强型科学计算器

题目:增强型计算器   1. 题目简介:       项目采用结对编程方式编写,完成一个图形界面的计算器,可以在标准计算器和科学计算器之间切换,标准计算器的基本功能有:加.减.乘.除基本算术运算:科学计算器的基本功能有:三角函数.进制转换.对数.阶乘:在普通科学计算器基础上新增加:求解一元二次方程,求解勾股定理. 2.基本功能与要求: 1).标准计算器:加.减.乘.除.求平方根: 2).科学计算器:进制转换.求解三角函数.对数运算.阶乘: 3).一元二次方程:求一元二次方程的解: 4).勾股定理

三十一、Java图形化界面设计——布局管理器之GridLayout(网格布局)

摘自http://blog.csdn.net/liujun13579/article/details/7772491 三十一.Java图形化界面设计--布局管理器之GridLayout(网格布局) 网格布局特点: l  使容器中的各组件呈M行×N列的网格状分布. l  网格每列宽度相同,等于容器的宽度除以网格的列数. l  网格每行高度相同,等于容器的高度除以网格的行数. l  各组件的排列方式为:从上到下,从左到右. l  组件放入容器的次序决定了它在容器中的位置. l  容器大小改变时,组件