java_caculator_钱宇坤_2011435112

近年来，随着计算机和互联网的飞速发展，编程语言也愈发受到重视。

其中，Java作为一种广泛应用的编程语言，其计算方法备受程序员们关注。

在本文中，我将深入探讨Java计算方法的相关内容，以便读者能更深入地理解这一主题。

1. Java计算方法的基础概念在Java中，计算方法是通过运算符和表达式来实现的。

常见的运算符包括加减乘除、取模、自增自减等，而表达式可以由常量、变量、运算符和方法调用等组成。

通过合理地组合运算符和表达式，便可以实现各种复杂的计算操作。

2. Java计算方法的数据类型在Java中，数据类型对计算方法起着至关重要的作用。

Java中的数据类型包括基本数据类型和引用数据类型，其中基本数据类型包括整型、浮点型、字符型和布尔型等。

不同的数据类型对应着不同的计算方法，了解数据类型的特点和适用范围有助于更加灵活地运用计算方法。

3. Java计算方法的流程控制除了基本的运算操作外，Java还提供了丰富多样的流程控制语句，如if-else语句、switch语句、for循环、while循环和do-while循环等。

这些流程控制语句可以根据条件和循环来控制计算方法的执行流程，使程序具有更强的逻辑性和灵活性。

4. Java计算方法的函数和方法在Java中，函数和方法是实现计算操作的重要手段。

函数是一段独立的代码块，可以被多次调用，而方法则是用于实现特定功能的代码块。

了解如何定义和调用函数、方法，以及它们的参数传递和返回值等内容，对提高计算方法的效率和复用性至关重要。

5. 个人观点和理解通过对Java计算方法的深入理解和实践，我深切体会到，计算方法的灵活运用可以大大提高程序的效率和可维护性。

Java语言本身具有丰富的计算方法支持和优秀的跨评台性能，使得它成为众多开发者的首选语言之一。

总结与回顾通过本文的阐述，我对Java计算方法进行了全面深入的探讨，从基础概念、数据类型、流程控制、函数方法到个人观点和理解，全方位地展现了Java计算方法的重要性和应用价值。

今天闲着没事，用java写了一个简单计算器，能实现简单的数据计算。

语言：java开发环境：eclipse（因为是按自己的想法写的，所以有些不尽人意的地方请谅解，希望对初学java者有些许帮助，有不好理解的地方，我尽量注释，有不理解的可以在百度HI我）事先一定要安装好JDK，可以在下载，配置好环境变量，再安装好eclipse，也可以在网上下载到，具体自己去找；然后打开eclipse建立一个工程，取名随便，我这里取名Calculator；然后在建立好的工程里面新建两个包，报名也自己取，尽量易懂，容易让人理解；我这里建立了两个包，Client和UI，等下在Client里面放的是主函数，UI里面放的是界面文件和控制器；好了下面开始写代码；一、先写界面代码：在UI包里面新建一个Class文件，取名自己想，这里我写的是CalculatorFramepackage ui;import java.awt.Color;import java.awt.Font;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JOptionPane;import javax.swing.JPanel;import javax.swing.JScrollPane;import javax.swing.JTextArea;import javax.swing.border.TitledBorder;public class CalculatorFrame extends JFrame {private static final long serialV ersionUID = 1L;public String opt;public String str;private JTextArea show;private ClientContext clientContext;//引用控制器对象/*因为调用了控制器里面的方法，所以要对控制器的对象进行赋值，否则运行会出现空指针异常*/public void setClientContext(ClientContext clientContext) {this.clientContext = clientContext;}public CalculatorFrame() {init();}private void init() {setTitle(" Simple Calculator");setBounds(533, 184, 300, 400);setContentPane(creatContentPane());}private JPanel creatContentPane() {JPanel p = new JPanel(new GridLayout(4, 1)); /* 在面板里面添加4个面板*/p.add(showPane());//显示屏p.add(btnPane1());//下面三个都是按钮p.add(btnPane2());p.add(btnPane3());return p;}/*实现各个面板*/private JScrollPane showPane() {JScrollPane p = new JScrollPane();p.setBorder(new TitledBorder("Display:"));show = new JTextArea();show.setFont(new Font("",Font.PLAIN,25));show.setForeground(Color.RED);show.setLineWrap(true);show.setEditable(false);p.getViewport().add(show);return p;}private JPanel btnPane1() {JPanel p = new JPanel(new GridLayout(2, 4));JButton add = new JButton("+");JButton jian = new JButton("-");JButton cheng = new JButton("*");JButton chu = new JButton("/");JButton one = new JButton("1");JButton two = new JButton("2");JButton three = new JButton("3");JButton anser = new JButton("=");p.add(add);p.add(jian);p.add(cheng);p.add(chu);p.add(one);p.add(two);p.add(three);p.add(anser);/*用内部类实现按钮监视器，后面的都是这样*/one.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent arg0) {String number = show.getText() + String.valueOf(1);//按了数字“1”按//钮后，操作显示屏,既更新一下显示屏clientContext.setNumber(number);//调用控制器里面的方法}});two.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent arg0) {String number = show.getText() + String.valueOf(2);;clientContext.setNumber(number);}});three.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(3);clientContext.setNumber(number);}});add.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent arg0) {opt = "+";clientContext.setOpt(opt);}});jian.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubopt = "-";clientContext.setOpt(opt);}});cheng.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubopt = "*";clientContext.setOpt(opt);}});chu.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubopt = "/";clientContext.setOpt(opt);}});anser.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent arg0) { str = "=";clientContext.setAnswer(str);}});return p;}private JPanel btnPane2() {JPanel p = new JPanel(new GridLayout(2, 4));JButton four = new JButton("4");JButton five = new JButton("5");JButton six = new JButton("6");JButton pi = new JButton("PI");JButton seven = new JButton("7");JButton eight = new JButton("8");JButton nine = new JButton("9");JButton com = new JButton(".");p.add(four);p.add(five);p.add(six);p.add(pi);p.add(seven);p.add(eight);p.add(nine);p.add(com);four.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(4);clientContext.setNumber(number);}});five.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(5);clientContext.setNumber(number);}});six.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {String number = show.getText() + String.valueOf(6);clientContext.setNumber(number);}});seven.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(7);clientContext.setNumber(number);}});eight.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(8);clientContext.setNumber(number);}});nine.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(9);clientContext.setNumber(number);}});com.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubsetShow(show.getText() + ".");}});pi.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {setShow(String.valueOf(Math.PI));}});return p;}private JPanel btnPane3() {JPanel p = new JPanel(new GridLayout(2, 4));JButton zero = new JButton("0");JButton sqrt = new JButton("√");JButton guiling = new JButton("C");final JButton help = new JButton("Help");p.add(zero);p.add(sqrt);p.add(guiling);p.add(help);help.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubJOptionPane.showMessageDialog(help, "注意：假如第二运算数为空的话，这里将默认为0.0！");}});guiling.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubclientContext.setMc();}});zero.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubString number = show.getText() + String.valueOf(0);clientContext.setNumber(number);}});sqrt.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubsetShow("" + Math.sqrt(getShow()));}});return p;}/*更新计算器的显示屏*/public void setShow(String str) {show.setText(str);}/*获取当前显示屏里面的数据*/public Double getShow() {String str = show.getText();if (str.equals("")) {str = "0.0";}return Double.valueOf(str);}/*获取当前选择的运算符：比如加或减或乘或除*/ public String getOpt() {return this.opt;}}二、写控制器代码在UI包建立一个Class，我取名ClientContext package ui;import java.util.ArrayList;import java.util.List;import javax.swing.JOptionPane;public class ClientContext {private CalculatorFrame calculatorFrame;private Double first = 0.0;private Double next = 0.0;public void setCalculatorFrame(CalculatorFrame calculatorFrame) {this.calculatorFrame = calculatorFrame;}double sum = 0;public void setNumber(String str) {calculatorFrame.setShow(str);}public void setOpt(String opt) {first = calculatorFrame.getShow();calculatorFrame.setShow("");}public void setAnswer(String str) {//按了“=”后，对数据按运算符进行计算next = calculatorFrame.getShow();// calculatorFrame.setShow(str);// switch(str){//// }if (calculatorFrame.getOpt() == "+") {double answer = first + next;calculatorFrame.setShow(String.valueOf(answer));} else if (calculatorFrame.getOpt() == "-") {double answer = first - next;calculatorFrame.setShow(String.valueOf(answer));} else if (calculatorFrame.getOpt() == "*") {double answer = first * next;calculatorFrame.setShow(String.valueOf(answer));} else if (calculatorFrame.getOpt() == "/") {if (next == 0) {calculatorFrame.setShow("对不起，除数不能为0");} else {double answer = first / next;calculatorFrame.setShow(String.valueOf(answer));}} else {calculatorFrame.setShow(String.valueOf(calculatorFrame.getShow()));}}public void setMc() {// TODO Auto-generated method stubcalculatorFrame.setShow("");first = 0.0;next = 0.0;calculatorFrame.opt=null;}}三、写主方法在Client包里面新建Class，我取名Mainpackage client;import javax.swing.JOptionPane;import ui.CalculatorFrame;import ui.ClientContext;public class Main {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubCalculatorFrame c = new CalculatorFrame();c.setV isible(true);ClientContext clientContext = new ClientContext();c.setClientContext(clientContext);clientContext.setCalculatorFrame(c);}}最后运行后如下：。

Java科学计算法是一种使用Java编程语言进行科学计算的方法。

Java科学计算法可以用于各种科学领域，如物理学、化学、生物学、工程学等。

它使用Java的强大功能和科学计算库，如Java Math库和JavaFX库，来处理复杂的数学问题，如微积分、线性代数、概率统计等。

在Java科学计算法中，可以使用Java的数值类型，如double和float，来存储和处理数值数据。

这些数值类型提供了高精度的浮点运算，可以处理各种科学计算中的复杂问题。

此外，Java还提供了许多数学函数库，如Java Math库和Apache Commons Math库，这些库提供了许多数学函数和算法的实现，如三角函数、指数函数、对数函数等。

在Java科学计算法中，可以使用循环和条件语句来处理复杂的数学问题。

Java提供了许多控制流语句，如for循环、while循环、if语句和switch语句，这些语句可以帮助程序员编写高效的算法和程序。

此外，Java还提供了许多数据结构和算法库，如Java Collections Framework和Java Stream API，这些库可以帮助程序员处理大规模的数据集和复杂的数据结构。

在Java科学计算法中，可以使用图形用户界面（GUI）库来创建可视化界面。

JavaFX库是Java 的一个图形用户界面库，它提供了许多可视化组件和动画效果，可以帮助程序员创建美观和交互式的可视化界面。

通过使用JavaFX库，程序员可以轻松地将科学计算的结果可视化，以便更好地理解和解释结果。

总之，Java科学计算法是一种使用Java编程语言进行科学计算的方法。

它使用Java的数值类型、数学函数库、控制流语句和图形用户界面库来处理复杂的数学问题。

通过使用Java 科学计算法，程序员可以更高效地编写科学计算程序，并更好地理解和解释结果。

Java 数字转科学计数法在实际开发过程中，我们经常会遇到处理大量数据的情况，而这些数据往往会以科学计数法的形式出现。

在 Java 中，我们要学会如何将数字转换为科学计数法表示，以便更好地处理这些数据。

我们需要了解什么是科学计数法。

科学计数法是一种用来表示非常大或非常小的数字的方法，它包括两部分：一个基数和一个指数。

基数通常是一个在1和10之间的数，而指数是10的整数次幂。

1.23 × 10^4 和4.56 × 10^-6 都是科学计数法表示的数字。

接下来，我们将讨论如何在 Java 中实现将数字转换为科学计数法表示的方法。

1. 使用 String.format 方法Java 中的 String.format 方法可以方便地将一个数字转换为科学计数法表示。

```javadouble number = xxx;String scientificNotation = String.format(".2e", number);```在这个例子中，我们将 xxx 转换为科学计数法，并且限制小数位数为2。

结果将会是 "1.23e+08"。

2. 使用 DecimalFormat 类另一种方法是使用 DecimalFormat 类来格式化数字为科学计数法。

```javadouble number = xxx;DecimalFormat df = new DecimalFormat("0.00E0");String scientificNotation = df.format(number);```在这个例子中，我们同样将 xxx 转换为科学计数法，并且限制小数位数为2。

结果同样为 "1.23E8"。

3. 自定义方法如果我们需要更加灵活地控制科学计数法的格式，可以通过自定义方法来实现。

```javapublic static String convertToScientificNotation(double number, int decimalPlaces) {double exponent =Math.floor(Math.log10(Math.abs(number)));double mantissa = number / Math.pow(10, exponent);return String.format("." + decimalPlaces + "fE+03.0f", mantissa, exponent);}```在这个例子中，我们自定义了一个 convertToScientificNotation 方法，可以传入数字和小数位数，返回对应的科学计数法表示。

java转换科学计数法在科学计数法中，一个数将被写成一个数字和一个指数的乘积，其中数字通常在1到10之间。

例如，1.23×10^6表示1.23乘以10的6次方(或1,230,000)。

在Java程序中，可以使用NumberFormat类将一个数从科学计数法格式转换为常规数字格式，或者反之。

下面将介绍如何使用Java转换科学计数法。

1. 将科学计数法转换为常规数字格式要将一个数从科学计数法转换为常规数字格式，可以使用NumberFormat类的format()方法。

下面是一个Java代码示例，演示如何将一个数从科学计数法格式转换为常规数字格式：```import java.text.NumberFormat;public class ScientificToDecimal {}```在上面的示例中，我们使用format()方法将1.23E6转换为常规数字格式。

首先，我们创建一个NumberFormat对象，然后使用setGroupingUsed(false)方法禁止分组，这是因为常规数字格式不包含分组。

最后，我们使用format()方法将科学计数法转换为常规数字格式，并输出结果，结果为"1230000"。

在上面的示例中，我们使用String.format()方法将1234567.89转换为科学计数法。

在参数字符串中，%E表示以科学计数法输出，%f表示以常规数字格式输出。

最后，我们输出结果，结果为"1.234568E+06"。

3. 使用BigDecimal进行科学计数法转换```import java.math.BigDecimal;import java.math.RoundingMode;在上面的示例中，我们使用BigDecimal类将一个常规数字格式转换为科学计数法。

首先，我们使用new BigDecimal()方法将一个字符串转换为BigDecimal，然后使用setScale()方法设置精度和舍入模式。

java绝对值的方法Java绝对值的方法介绍在Java编程中，我们经常需要计算一个数的绝对值。

Java提供了多种方法来实现这一功能。

本文将介绍几种常用的方法，以及它们的使用和区别。

Math类的abs方法Math类是Java提供的一个用于数学计算的工具类，其中的abs 方法可以用于计算一个数的绝对值。

该方法的使用非常简单，只需要传入一个数作为参数，即可返回该数的绝对值。

示例代码：int num = -5;int absNum = (num);("绝对值为：" + absNum);Integer类的方法除了Math类的abs方法外，Java的Integer类也提供了计算绝对值的方法。

intValue方法Integer类的intValue方法可以将一个Integer对象转换为int 类型的值。

通过先将Integer对象转换为int类型后再调用Math类的abs方法，即可计算得到绝对值。

示例代码：Integer num = -5;int absNum = (());("绝对值为：" + absNum);abs方法Integer类还提供了一个名为abs的静态方法，直接调用该方法即可计算一个整数的绝对值。

示例代码：Integer num = -5;int absNum = (num);("绝对值为：" + absNum);BigDecimal类的方法如果需要计算一个浮点数的绝对值，可以使用Java的BigDecimal类进行处理。

abs方法BigDecimal类的abs方法可以用于计算一个BigDecimal对象的绝对值。

该方法返回的是一个新的BigDecimal对象，不会修改原来的对象。

示例代码：BigDecimal num = new BigDecimal("-");BigDecimal absNum = ();("绝对值为：" + absNum);总结通过本文的介绍，我们了解了在Java中计算绝对值的几种方法。

用Java实现的计算器计算器是一个广泛应用的工具，用于进行数学运算。

如今，随着计算机技术的不断发展，计算器也逐渐被软件程序所替代。

本文将介绍如何使用Java语言实现一个简单的计算器程序。

一、程序概述计算器程序主要包括用户界面和计算逻辑两部分。

用户界面负责显示计算器的按钮和输入输出框，计算逻辑负责根据用户输入进行运算并返回结果。

二、用户界面设计在Java中，我们可以使用Swing或JavaFX等图形库来设计用户界面。

本文选用JavaFX来实现计算器的界面。

界面需要包括数字按钮、运算符按钮、输入输出框等组件。

在程序启动时，我们需要初始化界面并设置各个组件的位置、大小和样式。

为了方便布局，我们可以使用GridPane等布局管理器来管理组件。

三、计算逻辑实现1. 表达式解析计算器需要将用户输入的表达式解析为计算机可以识别的格式。

Java中可以使用正则表达式或者逆波兰表达式来解析表达式。

本文选用简单的正则表达式方法进行解析。

2. 运算逻辑解析表达式后，我们需要根据运算符的优先级进行运算。

Java中可以使用栈来实现运算符的优先级判断和运算。

我们可以定义一个操作数栈和一个运算符栈，按照规则将表达式中的数字和运算符依次入栈，并根据运算符的优先级进行运算并将结果入栈。

四、完整代码示例import javafx.application.Application;import javafx.geometry.Insets;import javafx.scene.Scene;import javafx.scene.control.Button;import javafx.scene.control.TextField;import yout.GridPane;import javafx.stage.Stage;public class Calculator extends Application {private TextField inputField; // 输入框private Button[] numberButtons; // 数字按钮private Button[] operatorButtons; // 运算符按钮@Overridepublic void start(Stage primaryStage) {primaryStage.setTitle("计算器");primaryStage.setResizable(false);// 初始化界面GridPane gridPane = new GridPane();gridPane.setHgap(10);gridPane.setVgap(10);gridPane.setPadding(new Insets(10));// 初始化输入框inputField = new TextField();inputField.setEditable(false);inputField.setPrefHeight(40);inputField.setMaxWidth(Double.MAX_VALUE);gridPane.add(inputField, 0, 0, 4, 1);// 初始化数字按钮numberButtons = new Button[10];for (int i = 0; i < 10; i++) {numberButtons[i] = createNumberButton(String.valueOf(i), i); }gridPane.add(numberButtons[7], 0, 1);gridPane.add(numberButtons[9], 2, 1);gridPane.add(numberButtons[4], 0, 2);gridPane.add(numberButtons[5], 1, 2);gridPane.add(numberButtons[6], 2, 2);gridPane.add(numberButtons[1], 0, 3);gridPane.add(numberButtons[2], 1, 3);gridPane.add(numberButtons[3], 2, 3);gridPane.add(numberButtons[0], 0, 4);gridPane.add(createDotButton(), 1, 4);gridPane.add(createEqualButton(), 2, 4);// 初始化运算符按钮operatorButtons = new Button[4];operatorButtons[0] = createOperatorButton("+"); operatorButtons[1] = createOperatorButton("-"); operatorButtons[2] = createOperatorButton("*"); operatorButtons[3] = createOperatorButton("/"); gridPane.add(operatorButtons[0], 3, 1);gridPane.add(operatorButtons[1], 3, 2);gridPane.add(operatorButtons[3], 3, 4);Scene scene = new Scene(gridPane);primaryStage.setScene(scene);primaryStage.show();}private Button createNumberButton(String text, int number) { Button button = new Button(text);button.setPrefSize(60, 40);button.setOnAction(e -> {String oldText = inputField.getText();inputField.setText(oldText + number);});return button;}private Button createDotButton() {Button button = new Button(".");button.setPrefSize(60, 40);button.setOnAction(e -> {String oldText = inputField.getText();inputField.setText(oldText + ".");});return button;}private Button createEqualButton() {Button button = new Button("=");button.setPrefSize(60, 40);button.setOnAction(e -> {String expression = inputField.getText();// 调用计算逻辑进行计算if (expression != null && !expression.isEmpty()) { double result = calculate(expression);inputField.setText(String.valueOf(result));}});return button;}private Button createOperatorButton(String text) {Button button = new Button(text);button.setPrefSize(60, 40);button.setOnAction(e -> {String oldText = inputField.getText();inputField.setText(oldText + text);});return button;}private double calculate(String expression) {// 进行计算逻辑的实现// ...}public static void main(String[] args) {launch(args);}}五、总结通过本文的介绍，我们可以了解到使用Java语言实现一个简单计算器的基本框架和思路。

java 计算数学运算的函数
Java中有许多内置的数学函数可以用于进行数学运算，常见的数学函数包括：
1. Math.abs(x)：返回x的绝对值。

2. Math.sqrt(x)：返回x的平方根。

3. Math.pow(x, y)：返回x的y次幂。

4. Math.exp(x)：返回e的x次幂。

5. Math.log(x)：返回x的自然对数。

6. Math.sin(x)：返回x的正弦值。

7. Math.cos(x)：返回x的余弦值。

8. Math.tan(x)：返回x的正切值。

9. Math.atan(x)：返回x的反正切值。

10. Math.max(x, y)：返回x和y中较大的值。

11. Math.min(x, y)：返回x和y中较小的值。

12. Math.ceil(x)：返回大于或等于x的最小整数。

13. Math.floor(x)：返回小于或等于x的最大整数。

14. Math.round(x)：返回最接近x的整数。

这些函数都属于Math类的静态方法，可以直接通过类名调用。

除了上述常见的数学函数，还有一些其他的数学函数可以参考Java官方文档。

//把代码改成Calc.java编译运行，完整版计算器，最下面是计算器界面import java.awt.*;import java.awt.event.*;public class Calc extends WindowAdapter implements ActionListener, MouseListener{Color cMoveOut=new Color(240 ,240 ,240);Color cMoveIn =new Color( 255,255,55);//状态变量boolean clicked=true;//判断是否单击了小数点boolean clear=true;//判断是否单击了符号位double previous;//记录第一个操作数double next;//记录第二个操作数String fuhao;//记录符号位int first=1;//标记是否开始一次新的运算过程Frame f;Panel p1,p2;TextField tf;Font fnt;Button b1,b2,b3,b4,b5,b6,b7,b8,b9,b0;Button bDiv,bSqrt,bMulti,bMinus,bPercent,bPlus,bReciprocal,bEqual,bDot,bNegative,bBack;Button bPingFang , bDaoShu , bSin, bCos ,bTan;Button bC;GridLayout p2Layout;public void display(){f=new Frame("计算器");f.setSize(280,213);f.setLocation(200,200);f.setBackground(Color.LIGHT_GRAY);f.setResizable(false);p1=new Panel(new FlowLayout());tf=new TextField(35);tf.setText("0.");tf.setEditable(false);p1.add(tf);f.add(p1,BorderLayout.NORTH);p2Layout=new GridLayout(5,5,5,4);p2=new Panel(p2Layout);f.add(p2,BorderLayout.CENTER);fnt=new Font("Serief",Font.BOLD,20);b1=new Button("1");b1.setFont(fnt);b2=new Button("2");b2.setFont(fnt);b3=new Button("3");b3.setFont(fnt);b4=new Button("4");b4.setFont(fnt);b5=new Button("5");b5.setFont(fnt);b6=new Button("6");b6.setFont(fnt);b7=new Button("7");b7.setFont(fnt);b8=new Button("8");b8.setFont(fnt);b7.setFont(fnt);b9=new Button("9");b9.setFont(fnt);b0=new Button("0");b0.setFont(fnt);b9.setFont(fnt);bPingFang=new Button("^2"); bPingFang.setFont(fnt); bDaoShu=new Button("1/X"); bDaoShu.setFont(fnt);bSin=new Button("sin");bSin.setFont(fnt);bCos=new Button("cos"); bCos.setFont(fnt);bTan=new Button("tan"); bTan.setFont(fnt);b1.addActionListener(this);b2.addActionListener(this);b3.addActionListener(this);b4.addActionListener(this);b5.addActionListener(this);b6.addActionListener(this);b7.addActionListener(this);b8.addActionListener(this);b9.addActionListener(this);b0.addActionListener(this); bBack=new Button("Back");//退格bBack.setFont(fnt);bC=new Button("C");//清空bC.setFont(fnt);bDiv=new Button("/");bDiv.setFont(fnt);bSqrt=new Button("sqrt"); bSqrt.setFont(fnt);bMulti=new Button("*"); bMulti.setFont(fnt);bMinus=new Button("-"); bMinus.setFont(fnt);bPercent=new Button("%"); bPercent.setFont(fnt);bPlus=new Button("+"); bPlus.setFont(fnt);bEqual=new Button("="); bEqual.setFont(fnt);bDot=new Button(".");bDot.setFont(fnt);bNegative=new Button("+/-"); bNegative.setFont(fnt); bBack.addActionListener(this);bC.addActionListener(this); bDiv.addActionListener(this); bSqrt.addActionListener(this); bPingFang.addActionListener(this); bPercent.addActionListener(this); bDaoShu.addActionListener(this); bMulti.addActionListener(this); bPlus.addActionListener(this); bMinus.addActionListener(this); bMulti.addActionListener(this); bDiv.addActionListener(this); bSin.addActionListener(this); bCos.addActionListener(this); bTan.addActionListener(this); bEqual.addActionListener(this); bDot.addActionListener(this); bNegative.addActionListener(this); bSqrt.addMouseListener(this); bPingFang.addMouseListener(this); bPercent.addMouseListener(this); bC.addMouseListener(this); bBack.addMouseListener(this);b7.addMouseListener(this);b8.addMouseListener(this);b9.addMouseListener(this); bDiv.addMouseListener(this); bDaoShu.addMouseListener(this); b4.addMouseListener(this);b5.addMouseListener(this);b6.addMouseListener(this); bMulti.addMouseListener(this); bSin.addMouseListener(this);b1.addMouseListener(this);b2.addMouseListener(this);b3.addMouseListener(this); bMinus.addMouseListener(this); bCos.addMouseListener(this);b0.addMouseListener(this); bDot.addMouseListener(this); bEqual.addMouseListener(this); bPlus.addMouseListener(this); bTan.addMouseListener(this);p2.add(bSqrt);p2.add(bPingFang);p2.add(bPercent);p2.add(bC);p2.add(bBack);p2.add(b7);p2.add(b8);p2.add(b9);p2.add(bDiv);p2.add(bDaoShu);p2.add(b4);p2.add(b5);p2.add(b6);p2.add(bMulti);p2.add(bSin);p2.add(b1);p2.add(b2);p2.add(b3);p2.add(bMinus);p2.add(bCos);p2.add(b0);p2.add(bDot);p2.add(bEqual);p2.add(bPlus);p2.add(bTan);f.setV isible(true);f.addWindowListener(this);}public void actionPerformed(ActionEvent e) {if (first ==1)tf.setText("");first=0;Object temp=e.getSource();//退格if (temp== bBack){String s=tf.getText();tf.setText("");for (int i=0;i<s.length()-1;i++){char a=s.charAt(i);tf.setText(tf.getText()+a);}}//清零if (temp==bC){tf.setText("0.");clear=true;first=1;}if (temp==b0){//判断是否单击了符号位if (clear==false)tf.setText("");tf.setText(tf.getText()+"0");}if (temp==b1){if (clear==false)tf.setText("");tf.setText(tf.getText()+"1");clear=true;}if (temp==b2){if (clear==false)tf.setText("");tf.setText(tf.getText()+"2");clear=true;}if (temp==b3){if (clear==false)tf.setText("");tf.setText(tf.getText()+"3");clear=true;}if (temp==b4){if (clear==false)tf.setText("");tf.setText(tf.getText()+"4");clear=true;}if (temp==b5){if (clear==false)tf.setText("");tf.setText(tf.getText()+"5");clear=true;}if (temp==b6){if (clear==false)tf.setText("");tf.setText(tf.getText()+"6");clear=true;}if (temp==b7){if (clear==false)tf.setText("");tf.setText(tf.getText()+"7");clear=true;}if (temp==b8){if (clear==false)tf.setText("");tf.setText(tf.getText()+"8");clear=true;}if (temp==b9){if (clear==false)tf.setText("");tf.setText(tf.getText()+"9");clear=true;}//判断是否含有小数点if (temp == bDot){clicked=true;for (int i=0;i<tf.getText().length();i++)if ('.'==tf.getText().charAt(i)){clicked = false;break;}if (clicked == true){tf.setText(tf.getText()+".");clear=true;}}//bSqrtif(temp == bSqrt){tf.setText( Math.sqrt( Double.parseDouble(tf.getText())) + "" );clear=false;}//bPingFangif(temp == bPingFang ){tf.setText( Math.pow( Double.parseDouble(tf.getText() ), 2 ) + "" );clear=false;}//倒数if(temp == bDaoShu){tf.setText( 1 / Double.parseDouble(tf.getText()) + "" );clear =false;}//Sinif(temp == bSin){tf.setText( Math.sin( Math.toRadians( Double.parseDouble( tf.getText() ) ) ) + "" );clear =false;}//Cosif(temp == bCos){tf.setText( Math.cos( Math.toRadians( Double.parseDouble( tf.getText() ) ) ) + "" );clear =false;}//tanif(temp == bTan){tf.setText( Math.tan( Math.toRadians( Double.parseDouble( tf.getText() ) ) ) + "");clear =false;}//加法运算if (temp==bPlus){previous=Double.parseDouble(tf.getText());fuhao="+";clear=false;//System.out.print("+");}//减法运算if (temp == bMinus){previous=Double.parseDouble(tf.getText());fuhao="-";clear=false;}//乘法运算if (temp == bMulti){previous=Double.parseDouble(tf.getText());fuhao="*";clear=false;}//除法运算bDivif (temp == bDiv){previous=Double.parseDouble(tf.getText());fuhao="/";clear=false;}//求余数if(temp == bPercent){previous=Double.parseDouble( tf.getText());fuhao="%";clear=false;}//等于if (temp==bEqual){try{next = Double.parseDouble(tf.getText());tf.setText("");if (fuhao =="+")tf.setText(previous + next +"");if(fuhao == "-")tf.setText(previous - next +"");if(fuhao == "*")tf.setText(previous * next +"");if(fuhao == "/")tf.setText(previous / next +"");if(fuhao == "%")tf.setText(previous % next +"");clear=false;}catch(Exception ex){tf.setText("请检查输入的数据：" + ex.getMessage()) ;clear=false;}}}public void mouseEntered(MouseEvent e){Object temp= e.getSource();if(temp==bPingFang){//System.out.println( bBack.getBackground() );bPingFang.setBackground(cMoveIn);}if(temp==bSqrt){bSqrt.setBackground(cMoveIn);}if(temp==bPercent){bPercent.setBackground(cMoveIn);}if(temp==bC){bC.setBackground(cMoveIn);}if(temp==bBack){bBack.setBackground(cMoveIn);}if(temp==b7){b7.setBackground(cMoveIn);}if(temp==b8){b8.setBackground(cMoveIn);}if(temp==b9){b9.setBackground(cMoveIn);}if(temp==bDiv){bDiv.setBackground(cMoveIn);}if(temp==bDaoShu){bDaoShu.setBackground(cMoveIn); }if(temp==b4){b4.setBackground(cMoveIn);}if(temp==b5){b5.setBackground(cMoveIn);}if(temp==b6){b6.setBackground(cMoveIn);}if(temp==bMulti){bMulti.setBackground(cMoveIn); }if(temp==bSin){bSin.setBackground(cMoveIn);}if(temp==b1){b1.setBackground(cMoveIn);}if(temp==b2){b2.setBackground(cMoveIn);}if(temp==b3){b3.setBackground(cMoveIn);}if(temp==bMinus){bMinus.setBackground(cMoveIn); }if(temp==bCos){bCos.setBackground(cMoveIn);}if(temp==b0){b0.setBackground(cMoveIn);}if(temp==bDot){bDot.setBackground(cMoveIn);}if(temp==bEqual){bEqual.setBackground(cMoveIn);}if(temp==bPlus){bPlus.setBackground(cMoveIn);}if(temp==bTan){bTan.setBackground(cMoveIn);}}public void mouseExited(MouseEvent e) {Object temp= e.getSource();if(temp==bPingFang){//System.out.println( bBack.getBackground() );bPingFang.setBackground(cMoveOut);}if(temp==bSqrt){bSqrt.setBackground(cMoveOut);}if(temp==bPercent){bPercent.setBackground(cMoveOut);}if(temp==bC){bC.setBackground(cMoveOut);}if(temp==bBack){bBack.setBackground(cMoveOut);}if(temp==b7){b7.setBackground(cMoveOut);}if(temp==b8){b8.setBackground(cMoveOut);}if(temp==b9){b9.setBackground(cMoveOut);}if(temp==bDiv){bDiv.setBackground(cMoveOut);}if(temp==bDaoShu){bDaoShu.setBackground(cMoveOut); }if(temp==b4){b4.setBackground(cMoveOut);}if(temp==b5){b5.setBackground(cMoveOut);}if(temp==b6){b6.setBackground(cMoveOut);}if(temp==bMulti){bMulti.setBackground(cMoveOut); }if(temp==bSin){bSin.setBackground(cMoveOut);}if(temp==b1){b1.setBackground(cMoveOut);}if(temp==b2){b2.setBackground(cMoveOut);}if(temp==b3){b3.setBackground(cMoveOut);}if(temp==bMinus){bMinus.setBackground(cMoveOut); }if(temp==bCos){bCos.setBackground(cMoveOut);}if(temp==b0){b0.setBackground(cMoveOut);}if(temp==bDot){bDot.setBackground(cMoveOut);}if(temp==bEqual){bEqual.setBackground(cMoveOut);}if(temp==bPlus){bPlus.setBackground(cMoveOut);}if(temp==bTan){bTan.setBackground(cMoveOut);}}public static void main(String args[]){Calc frame=new Calc();frame.display();}public void windowClosing(WindowEvent e){System.exit(0);}public void mouseClicked(MouseEvent arg0) {}public void mousePressed(MouseEvent arg0) {}public void mouseReleased(MouseEvent arg0) { }}。

基于java的简易计算器的设计摘要自从java语言诞生以来，java语言就以不可抵挡的趋势很快成为国际上广泛流行的面向对象编程语言，它既具有高级语言的特点，又少了C语言中指针特点，因而变得简单了很多。

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，其具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

本文介绍了用java语言编写一个简易计算器。

实现数学上的加、减、乘、除、乘方、开方、阶乘、正弦、余弦运算等相关运算。

利用这个程序可以方便的进行日常性的小规模运算，小巧简易，是个实用的工具。

关键词：程序设计；简易计算器；java语言THE DESIGN OF SIMPLE CALCULATOR BASED ON JA V AABSTRACTSince the inception of the java language, java language Take irresistible trend soon beca me widespread international popular object-oriented programming language, both with advan ced language features, and less of the C language pointer characteristics, and thus becomes a l ot simpler . Java is a cross-platform application software can write object-oriented programmi ng language, which has excellent versatility, efficiency, platform portability, and security, are widely used in personal PC, data center, gaming consoles, scientific super-computers, mobile phones and the Internet, also has the world's largest developer of professional community. In t he global cloud computing and mobile Internet industry environment, Java and more have sig nificant advantages and broad prospects.This article describes the use java language a simple calculator. Achieve mathematical addition, subtraction, multiplication, division, involution, evolution, factorial, sine, cosine op erations and other related operations. With this program you can easily carry out daily operati ons of small-scale, small simple, is a useful tool.Key words:program design；simple calculator；java language目录1前言 (1)1.1 课程设计背景 (1)1.2 需求环境 (1)1.3 课程设计思路 (1)2课程设计概要 (2)3 计算器详细设计 (3)3.1 计算器界面……….………….........………………………………………. .33.1.1 CAL主类的显示分布 (3)3.1.2计算器显示界面实现代码 (3)3.2 监听各个按钮的类 (5)3.2.1 编写监听类目的 (5)3.2.2 监听类实现代码 (5)3.3 按键响应类 (7)3.3.1 响应类编写的目的 (7)3.2.2 响应类实现代码 (7)3.3 运算处理类 (9)3.3.1 处理方式 . (9)3.2.2 处理类实现代码 (9)4 运行与调试 (12)4.1 进入程序主界面 (12)4.2 加减乘除功能实现 (12)4.3 正余弦、正切功能实现 (13)4.4 阶乘功能实现 (13)4.5 乘方、开方功能实现 (14)5 实验总结 (15)参考文献 (16)附录：源代码 (17)1 前言1.1 课程设计背景日常生活中我们经常会遇到一些小型数据计算的问题，本课程设计就是以此为出发点，设计了这样一个简单的计算器，用以实现基本的数学运算。

java直接代入公式计算的方法【原创版3篇】目录（篇1）1.Java 中直接代入公式计算的方法2.使用 Java 内置的数学库3.使用第三方库：Apache Commons Math 库4.示例：使用 Apache Commons Math 库计算平方根和三角函数正文（篇1）在 Java 编程语言中，可以直接代入公式进行计算。

为了实现这一功能，我们可以使用 Java 内置的数学库，也可以借助一些第三方库。

下面我们将介绍两种方法。

首先，我们来了解一下 Java 内置的数学库。

Java 提供了一个名为`ng.Math`的类，它包含了一些常用的数学方法，如：sin、cos、tan、sqrt 等。

通过导入这个类，我们就可以直接在代码中使用这些方法进行计算。

示例：```javapublic class Main {public static void main(String[] args) {double a = 9;double b = 4;double c = Math.sqrt(a * a + b * b);System.out.println("三角形斜边长度为：" + c);}}```然而，`ng.Math`类提供的功能相对有限。

如果我们需要更多的数学计算功能，可以使用第三方库——Apache Commons Math 库。

这是一个强大的数学库，提供了许多高级数学算法和函数。

要使用 Apache Commons Math 库，首先需要将其添加到项目中。

如果项目是 Maven 项目，可以在`pom.xml`文件中添加以下依赖：```xml<dependency><groupId>mons</groupId><artifactId>commons-math3</artifactId><version>3.6.1</version></dependency>```接下来，我们可以在代码中导入`mons.math3.math.MathUtils`类，然后调用其中的方法进行计算。

java实现⼀个简单的数学表达式分析器（加减乘除和括号）1.使⽤此分析器需要输⼊两个量：String str1=运算符号有前后有空格的数学表达式（如 1 + 2 * ( 3+1) - 5 #）,并在最后添加‘#’字符作为结束标志；String str2=⽆空格的分割的数学表达式（如 1+2*(3+1)-5#）,同样添加‘#’字符作为结束标志；2.注：表达式必须严格正确“( )”是不允许存在单个的情况。

源代码中有⼀定的检测机制，但现在还不确定是否能够检错所有情况；使⽤两种输⼊的原因是⽅便于检错和字符串的切割；3.花了两天晚上写的（包括安卓app），虽然简陋。

但是对于我来说还是太肝了。

这个是为⾯试学校的⼀个学⽣组织的实验室，准备做的安卓上的计算器中的输⼊分析器（算是核⼼的代码了doge.jpg）；因为考虑到可能以后还可以改改，所以就单独写了个⽅法（算是低耦合吧doge.jpg）；4.注：此代码暂时只能解析含加减乘除和括号的算式。

主要核⼼算法思想参考《数据结构C语⾔版吴伟民著》P53。

其他的实现都是⾃⼰写的，把c转为java确实也遇到很多问题。

5.使⽤时使⽤的是EvaluateExpression这个类，创建是⽤构造⽅法EvaluateExpression(str2（不含空格）,str1（含空格）)，使⽤.doEvaluateExpression()⽅法实现计算（如果返回值为False则表⽰输⼊的表达式有误），使⽤.sum得到最后结果。

6.下⾯是步骤：实现⼀个栈：public class strStack {private String[] myStack=new String[80];private int StackLength=0;private int StackPoint=0;public boolean isEmpty(){if(StackLength==0)return true;elsereturn false;}public int getStacklength(){return StackLength;}public boolean push(String str){if(StackPoint==80)return false;else{myStack[StackPoint]=str;StackLength++;StackPoint++;return true;}}public String getTop(){if(StackPoint==0){return null;}else{return myStack[StackPoint-1];}}public String pop(){String popn=myStack[StackPoint-1];myStack[StackPoint-1]=null;StackLength--;StackPoint--;return popn;}public void clearStack(){if(!isEmpty()){for(int i=StackLength-1;i>=0;i--){myStack[i]=null;}StackLength=0;StackPoint=0;}}public void trevalstack(){for(int i=0;i<StackPoint;i++){System.out.print(" "+myStack[i]);}}}实现字符串处理类：public class cutStr {private String[] mystr;//切割后的表达式private String outstr;//不含空格的表达式private String outstrhasSpace;//含空格的表达式public cutStr(){}public cutStr(String outstr,String outstrhasSpace){this.outstr=outstr;this.outstrhasSpace=outstrhasSpace;//初始化，得到外来字符串 }public String[] ReAddstr(){//切割字符串，将运算符号与数字分开mystr=outstrhasSpace.split("[ ]+");return mystr;}public boolean countsymple(){boolean temp=true;for(int i=0;i<outstr.length();i++){if(i!=outstr.length()-1){//判断是否有⾮法的连续输⼊if(outstr.charAt(i)=='+'||outstr.charAt(i)=='-'||outstr.charAt(i)=='*'||outstr.charAt(i)=='/'||outstr.charAt(i)=='.'){if(outstr.charAt(i+1)=='+'||outstr.charAt(i+1)=='-'||outstr.charAt(i+1)=='*'||outstr.charAt(i+1)=='/'||outstr.charAt(i+1)=='.'){temp=false;break;}}}else{//判断最后⼀个字符是否合法if(outstr.charAt(i)=='+'||outstr.charAt(i)=='-'||outstr.charAt(i)=='*'||outstr.charAt(i)=='/'){temp=false;break;}}}return temp;}public boolean khnumber(){int kl=0;int kr=0;for(int i=0;i<outstr.length();i++){if(outstr.charAt(i)=='(')kl++;if(outstr.charAt(i)==')')kr++;}if(kr==kl&&(kr+kl)%2==0)return true;elsereturn false;}public String[] getMystr() {//返回切割后的字符串数组ReAddstr();return mystr;}}实现运算符优先级⽐较处理类：public class Precede {private char[][] mylist={{'>','>','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','>','>','<','>','>'},{'>','>','>','>','<','>','>'},{'<','<','<','<','<','=',0},{'>','>','>','>',0,'>','>'},{'<','<','<','<','<',0,'='}};public char doPrecede(char c1,char c2){//查询两者关系int c1n,c2n;c1n=exchange(c1);c2n=exchange(c2);return mylist[c1n][c2n];}public int exchange(char mychar){//将符号转换为⾃定义数字，⽤于定位表中位置int temp=-1;switch(mychar){case '+': temp=0; break;case '-': temp=1; break;case '*': temp=2; break;case '/': temp=3; break;case '(': temp=4; break;case ')': temp=5; break;case '#': temp=6; break;}return temp;}}实现运算的操作类：public class Operate {private double a;private double b;private char threta;public Operate(){}public Operate(double a,char threta,double b){this.a=a;this.b=b;this.threta=threta;}public double doOperaate(){double temp=0;switch(threta){case '+': temp=a+b;break;case '-': temp=a-b;break;case '*': temp=a*b;break;case '/': temp=a/b;break;}return temp;}}实现运⾏运算的类：public class EvaluateExpression {public String sum;//储存计算的最终结果public boolean jugment=true;//作为表达式是否合法的标志String outstr,outstrhasSpace;public EvaluateExpression(String outstr,String outstrhasSpace){this.outstr=outstr;this.outstrhasSpace=outstrhasSpace;}public boolean isOP(String x){//判断是否为运算符号的⽅法if(x.charAt(0)=='+'||x.charAt(0)=='-'||x.charAt(0)=='*'||x.charAt(0)=='/'||x.charAt(0)=='('||x.charAt(0)==')'||x.charAt(0)=='#') return true;elsereturn false;}public boolean doEvaluateExpression(){//求解过程的⽅法，如果判断表达式错误那么直接结束Precede pre=new Precede();strStack OPTR=new strStack();OPTR.push("#");strStack OPND=new strStack();cutStr cS=new cutStr(outstr,outstrhasSpace);jugment=cS.countsymple();String[] mystr=cS.getMystr();jugment=cS.khnumber();for(int i=0;jugment&&((mystr[i].charAt(0)!='#')||(OPTR.getTop().charAt(0)!='#'));){if(!isOP(mystr[i])){OPND.push(mystr[i]);i++;}else{switch(pre.doPrecede(OPTR.getTop().charAt(0),mystr[i].charAt(0))){case '<':OPTR.push(mystr[i]);i++;break;case '=':OPTR.pop();i++;break;case '>':String thretax=OPTR.pop();char threta=thretax.charAt(0);String b=OPND.pop();String a=OPND.pop();double bb=0;double aa=0;try{bb=Double.parseDouble(b);aa=Double.parseDouble(a);}catch(NumberFormatException e){jugment=false;}Operate oper=new Operate(aa,threta,bb);//创建⼀个操作对象，并初始化 String numberx=String.valueOf(oper.doOperaate());OPND.push(numberx);break;case '0':jugment=false;break;}}/*System.out.print(i);System.out.print(" ");OPND.trevalstack();System.out.print(" ");OPTR.trevalstack();System.out.println(" ");*/}sum=OPND.getTop();return jugment;}}。

java字符串转科学计数法Java中的字符串转科学计数法主要是针对科学计算中非常大或者非常小的数值进行精确计算，以方便人们进行相关的科研工作。

在Java程序中，我们可以使用一些方法来实现字符串转科学计数法。

第一步，定义初值：首先需要定义一个代表初始值的字符串。

这个字符串中通常会包含非常大或非常小的数字，例如：```String str = "1000000000";```第二步，将字符串转为科学计数法：为了将字符串转换为科学计数法，我们需要使用Java中提供的BigDecimal类。

这个类是Java中可表示任意大小且精度可控制的浮点数类，所以它非常适合进行科学计算。

通过设置BigDecimal的precision和scale属性，我们可以控制输出的位数和数字大小。

例如，在将字符串“1000000000”转换为科学计数法时，我们可以使用以下代码：```BigDecimal bd = new BigDecimal(str); //将字符串转化为BigDecimal类型System.out.println(bd.toEngineeringString()); //按科学计数法格式输出```这段代码中，toEngineeringString()方法可以输出一个字符串类型的值，表示BigDecimal的科学计数法显示形式。

第三步，进行数据格式化：如果希望输出的结果更具可读性，我们需要进行数据格式化。

在Java中，可以使用DecimalFormat类来对整数和浮点数类型的数据进行格式化。

例如：```BigDecimal bd = new BigDecimal(str);DecimalFormat df = new DecimalFormat("#.00000000E000"); System.out.println(df.format(bd));```这段代码中，我们将数值格式化为科学计数法的形式，并控制小数点后显示的位数。

计算机工程系《Java程序设计》设计报告题目：百宝箱之计算器班级：学号：姓名：小组名字：小组成员：指导教师：报告递交日期：2011 年 12 月 15 日百宝箱之—计算器想不想拥有一个小软件，打开它，里面的的小工具应有尽有，想不想拥有一个小软件，里面的东西，随你怎么添加，想不想拥有一个小软件，里面的小工具快捷而方便，。

现在我们将一点一点来组装出这个软件：软件最终样式图为：目录第1章系统设计目的 (1)第2章系统实现思路 (2)第3章系统详细设计 (3)第4章系统调试运行 (7)第5章参考文献 (9)第6章附录 (10)第1章系统设计目的设计一个包含诸多小工具的小程序,可以实现以下功能：1：图形化计算器，能精确计算；2：打包小工具，便于添加；3：执行完操作后，能够顺利所有的小程序。

第2章系统实现思路装载所需的类库，创建主类BaiBaoXiang，再创建主函数main，接着创建监听按钮btn的事件监听器，然后设计事件监听器（JiSuanQi），就可以直接在编译器中运行程序。

1：界面设计在主界面中设计一个JFrame窗口对象，并在其中加入一个按钮btn，创建桌面层对象JDesktopPane，设置大小位置，颜色；实现窗口对象的关闭按钮；2:功能设计按钮中加入监听器（jisuanqi）并进行监听。

设计监听器的功能；当按钮按下时，生成计算器界面，设计生成数字键按钮，文本框，并设计监听程序； 3：代码设计编写每个控件的相关代码，并进行调试。

第3章系统详细设计1：界面设计创建一个按钮；窗口对象，及关闭按钮的功能;主要代码：static JFrame frm = new JFrame("百宝箱");//创建窗口对象static JButton btn = new JButton("计算器");//创建按钮对象static Container cp =frm.getContentPane();//取得内容层static JDesktopPane jdp = new JDesktopPane();//创建桌面层对象/*************主函数****************/public static void main(String[] args) {//cp.setLayout(newFlowLayout());/////**************;;*********这个问题费了我一个早上的时间没整出来，一定几下了啦布局的限制cp.add(btn,BorderLayout.SOUTH); //将按钮添加到内容层中cp.add(jdp); //将桌面层对象添加到内容层里jdp.setBackground(Color.blue); //设置桌面层颜色btn.addActionListener(new JiSuanQi()); //设置JiSuanQi监听btnbtn.setBackground(Color.yellow); //设置按钮的颜色frm.setBounds(500, 200, 500, 500); //设置窗口的大小位置frm.setVisible(true); //显示窗口/************窗口的关闭**************/frm .addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e) //监听器接口{System.exit(0); //退出(释放资源)}});}2：功能设计对每个按钮项进行注册监听。

目录目录 (I)1需求分析 (1)1.1计算器的基本功能： (1)1.1.1加法运算：用数字按钮和“+”按钮进行运算； (1)1.1.2减法运算：用数字按钮和“-”按钮进行运算； (1)1.1.3乘法运算：用数字按钮和“*”按钮进行运算； (1)1.1.4除法运算：用数字按钮和“/”按钮进行运算； (1)1.2退格键和清零键: 用”Backspace”、”C”和”CE”按钮实现; (1)1.3计算器的科学计算方法： (1)1.3.1开方：用数字按钮和“Sqrt”按钮进行运算； (1)1.3.2百分比：用数字按钮和“%”按钮进行运算； (1)1.3.3求倒数：用数字按钮和“1/x”按钮进行运算； (1)1.3.4求自然对数：用数字按钮和“ln”按钮进行运算； (1)1.3.5三角函数：用数字按钮和“tan”“cos”“sin”按钮进行运算 (1)1.3.6角度换算成弧度：用数字按钮和“’ ””按钮进行运算 (1)1.3.7求反：用数字按钮和“-/+”按钮进行运算 (1)1.3.8平方和三次方：用数字按钮和“x^2”“x^3”按钮进行运算 (1)1.4常数： (2)1.4.1π：用Math类中的PI来实现 (2)1.4.2自然对数e：用Math类中的E来实现 (2)2设计 (2)2.1用户界面设计 (2)2.1.1该计算器程序的设计：用户界面包括Swing组件,不过程序中大都使用的是AWT组件. (2)2.1.2在AWT组件, (2)2.1.3这个界面设计中包含了五个接口，分别控制运算符，数字，清除，存储功能和小数点的输入 (2)2.1.4程序设计中,使用了布局管理: (3)2.2概要设计 (3)2.2.1它的功能是使用图形用户来实现计算器的界面设计和运算功能以及一些科学运算方法. (3)3实现 (3)4测试 (14)4.1实现加法运算：4+12=16 (14)4.2实现乘法运算：3*9=27 (15)4.3用”C’实现清零功能: (16)4.4用”Backspace”实现退格功能: (17)4.5求倒数:1/4=0.25 (18)1 需求分析该计算器程序除了具备加减乘除基本功能外，还有清零键C、CE和退格键Backspace，和一些部分的科学计算方法，包括开方、求倒、百分比，由于时间问题，之后会完善键盘事件的监听功能。

import java.awt.BorderLayout;import java.awt.Color;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyEvent;import java.awt.event.KeyListener;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JPanel;import javax.swing.JTextField;/使用java 语言开发一个简易计算器/public class TestJsq extends JFrame implements ActionListener, KeyListener {private JTextField jtf;private JButton jb_bk, jb_ce, jb_c;private String xs = "";private double sum = 0;private int fh;public static void main(String[] args) {new TestJsq().creatCUI();}public void creatCUI() {JFrame jf = new JFrame();jf.setTitle("计算器");jtf = new JTextField("0.");jtf.setHorizontalAlignment(JTextField.RIGHT);jf.add(jtf, BorderLayout.NORTH);JPanel jp_main = new JPanel(new BorderLayout());jf.add(jp_main);JPanel jp1 = new JPanel(new GridLayout(1, 3, 1, 1));jb_bk = new JButton("Backspace");jb_bk.setForeground(Color.RED);jb_bk.addActionListener(this);jb_ce = new JButton("CE");jb_ce.setForeground(Color.RED);jb_ce.addActionListener(this);jb_c = new JButton("C");jb_c.setForeground(Color.RED);jb_c.addActionListener(this);jp1.add(jb_bk);jp1.add(jb_ce);jp1.add(jb_c);jp_main.add(jp1, BorderLayout.NORTH);JPanel jp2 = new JPanel(new GridLayout(4, 5, 1, 1));String str[] = { "7", "8", "9", "/", "sqrt", "4", "5", "6", "", "%","1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };for (int i = 0; i < 20; i++) {JButton jb = new JButton(str[i]);jb.addActionListener(this);jb.setForeground(Color.blue);if (i == 3 || i == 8 || i == 13 || i == 18 || i == 19) { jb.setForeground(Color.RED);}jp2.add(jb);}jp_main.add(jp2, BorderLayout.CENTER);jf.setResizable(false);jf.setBounds(50, 50, 350, 350);jf.setVisible(true);}Overridepublic void actionPerformed(ActionEvent e) {String s = e.getActionCommand();if (s.equals("CE") || s.equals("C")) {xs = "";jtf.setText("0.");} else if (s.equals("Backspace")) {String str = xs.substring(0, xs.length() - 1);xs = str;jtf.setText(xs);} else if (s.equals("7") || s.equals("8") || s.equals("9") || s.equals("4") || s.equals("5") || s.equals("6")|| s.equals("1") || s.equals("2") || s.equals("3")|| s.equals("0") || s.equals(".")) {xs = xs + s;jtf.setText(xs);} else if (s.equals("+/-")) {double x = Double.parseDouble(xs);xs="" + (-x);jtf.setText(xs);} else if (s.equals("/")) {fh = 4;int point = xs.indexOf(".");if (point = -1) {String strt = xs.substring(0, point);String z = xs.substring(point + 1, xs.length());int z_num = z.length();sum = Integer.decode(strt) + (double) (Integer.decode(z))/ (10 z_num);} else {sum = Integer.decode(xs);}xs = "";jtf.setText(null);} else if (s.equals("")) {fh = 3;int point = xs.indexOf(".");if (point = -1) {String strt = xs.substring(0, point);String z = xs.substring(point + 1, xs.length());int z_num = z.length();sum = Integer.decode(strt) + (double) (Integer.decode(z))/ (10 z_num);} else {sum = Integer.decode(xs);}xs = "";jtf.setText(null);} else if (s.equals("-")) {fh = 2;int point = xs.indexOf(".");if (point = -1) {String strt = xs.substring(0, point);String z = xs.substring(point + 1, xs.length());int z_num = z.length();sum = Integer.decode(strt) + (double) (Integer.decode(z))/ (10 z_num);} else {sum = Integer.decode(xs);}xs = "";jtf.setText(null);} else if (s.equals("+")) {fh = 1;int point = xs.indexOf(".");if (point = -1) {String strt = xs.substring(0, point);String z = xs.substring(point + 1, xs.length());int z_num = z.length();sum = Integer.decode(strt) + (double) (Integer.decode(z))/ (10 z_num);} else {sum = Integer.decode(xs);}xs = "";jtf.setText(null);} else if (s.equals("sqrt")) {double x = Double.parseDouble(xs);double x1 = Math.sqrt(x);xs = x1 + "";jtf.setText(xs);} else if (s.equals("%")) {double x = Double.parseDouble(xs);x=0.01 xx;xs=x+"";jtf.setText(xs);} else if (s.equals("1/x")) {if (xs == "0") {jtf.setText("除数不能为0");} else {double x = Double.parseDouble(xs);double x1 = 1 / x;xs = x1 + "";jtf.setText(String.valueOf(xs));}} else if (s.equals("=")) {if (fh = 0) {switch (fh) {case 1:int point1 = xs.indexOf(".");if (point1 = -1) {String s1 = xs.substring(0, point1);String z1 = xs.substring(point1 + 1, xs.length());int z1_num = z1.length();xs = "";double ss1 = Integer.decode(s1)+ (double) Integer.decode(z1) / (10 z1_num);sum = sum + ss1;} else {sum = sum + Integer.decode(xs);xs = "";}fh = 0;break;case 2:int point2 = xs.indexOf(".");if (point2 = -1) {String s2 = xs.substring(0, point2);String z2 = xs.substring(point2 + 1, xs.length());int z2_num = z2.length();xs = "";double ss2 = Integer.decode(s2)+ (double) Integer.decode(z2) / (10 z2_num);sum = sum - ss2;} else {sum = sum - Integer.decode(xs);xs = "";}fh = 0;break;case 3:int point3 = xs.indexOf(".");if (point3 = -1) {String s3 = xs.substring(0, point3);String z3 = xs.substring(point3 + 1, xs.length());int z1_num = z3.length();xs = "";double s4 = Integer.decode(s3)+ (double) Integer.decode(z3) / (10 z1_num);sum = sum s4;} else {sum = sum Integer.decode(xs);xs = "";}fh = 0;break;case 4:int point4 = xs.indexOf(".");if (point4 = -1) {String s4 = xs.substring(0, point4);String z4 = xs.substring(point4 + 1, xs.length());int z4_num = z4.length();xs = "";double s5 = Integer.decode(s4)+ (double) Integer.decode(z4) / (10 z4_num);sum = sum / s5;} else {sum = sum / Integer.decode(xs);xs = "";}fh = 0;break;default:break;}xs = String.valueOf(sum);jtf.setText(xs);fh = 0;} else {jtf.setText(null);}}}Overridepublic void keyPressed(KeyEvent e) {// TODO Auto-generated method stub}Overridepublic void keyReleased(KeyEvent e) { // TODO Auto-generated method stub }Overridepublic void keyTyped(KeyEvent e) { // TODO Auto-generated method stub }}。