Java语言编写计算器

最新推荐文章于 2024-05-10 12:47:08 发布
最新推荐文章于 2024-05-10 12:47:08 发布
阅读量10w+ 收藏 984
点赞数 208
文章标签： Java语言 简单计算器 可视化界面
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41398808/article/details/79558789
版权

本文讲述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

二：实现复数运算

三：实现多次方的运算

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

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

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

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

猫猫虫(——)
关注
  • 208
    点赞
  • 踩
  • 984
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 18
    评论
Java语言编写计算器程序_swing界面
01-14
Java语言编写计算器程序_swing界面
用Java制作简单的计算器
充满焦虑的大学生
04-26 1万+
就是往左边判断是(sb.charAt(j)=='*'||sb.charAt(j)=='/'||sb.charAt(j)=='%'||sb.charAt(j)=='B'||sb.charAt(j)=='+'||sb.charAt(j)=='-')，而右边判断是(sb.charAt(j)=='*'||sb.charAt(j)=='/'||sb.charAt(j)=='%'||sb.charAt(j)=='B'||sb.charAt(j)=='+'||sb.charAt(j)=='-'||按钮，和自己本身框架。
Java最全Java设计一个简单的计算器程序，原理解析
2401_84102840的博客
05-10 871
小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！开源分享：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】程序员代码面试指南 IT名企算法与数据结构题目最优解这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。
用JAVA—GUI编程设计实现“简单的计算器”
qq_40615021的博客
12-11 1万+
设计内容：设计一个图形界面（GUI）的计算器应用程序，完成简单的算术运算、 设计要求：设计的计算器应用程序可以完成加法、减法、乘法、除法和取余运算。且有小数点、正负号、求倒数、退格和清零功能。 设计效果： 键钮含义： C 清零， D 求导数， √ 求平方根， % 求余， &lt;&lt;&lt; 退格， (+/-) 正负号 +-*...
java 简易计算器
热门推荐
m0_56078449的博客
07-15 2万+
java 简易计算器
Java设计一个简单的计算器程序
hitpter的专栏
10-02 4286
本文基于Java语言，设计并实现了一个简单的计算器程序。通过定义Calculator类和使用Scanner类实现用户交互，我们可以进行基本的四则运算，并获得最终的计算结果。该计算器程序具备扩展性，可以根据实际需求添加更多的功能。通过编写这样的小项目，我们不仅巩固了Java语法，还学习了面向对象的设计和开发思想。希望读者通过阅读本文，能够对Java的基础知识有更深入的理解，并能够运用所学知识进行更复杂的项目开发。
使用Java实现简单的计算器应用程序
Y18870954401的博客
07-18 2077
通过本文的示例代码，我们学习了如何使用Java编程语言创建一个简单的计算器应用程序。我们使用了Swing库来创建GUI界面，并实现了基本的按钮点击事件处理和计算逻辑。然后，我们可以使用任何集成开发环境（IDE）如Eclipse或IntelliJ IDEA来创建一个新的Java项目。我们将使用面向对象的编程思想和基本的Java语法，以及图形用户界面（GUI）库Swing来创建一个交互式的计算器。在这个例子中，我们将使用Swing库来创建计算器的GUI界面。或者，我们可以使用命令行编译和运行Java代码。
用java实现计算器
weixin_35756637的博客
12-20 1619
在 Java 中实现计算器可以通过以下步骤来实现： 定义计算器所需的变量，例如输入的数字、符号和计算结果。 使用 Scanner 类来获取用户输入的数字和符号。 使用 switch 语句来判断用户输入的符号，并执行相应的计算操作。 最后，输出计算结果。 以下是一个简单的 Java 代码示例，实现了计算器的加减乘除运算： ``` import java.util.Scanner; pub...
Java简易计算器
秋刀鱼的博客
06-05 8235
一个简单的Java计算器
JAVA语言编写计算器
01-21
在编程领域，使用Java语言编写一个计算器是一项基础且实用的任务，它...以上就是关于"JAVA语言编写计算器"、完数和素数判断以及开方运算的知识点详解。理解并掌握这些概念和方法，将有助于开发出功能完善的计算器应用。
JAVA语言编写计算器和文档编辑器.doc
06-10
JAVA语言编写计算器和文档编辑器
java实现的一个简单的计算器功能
03-15
java实现的一个简单的计算器功能，可以进行加减乘除，用面向对象的思想实现的
Java编程语言编写的计算器应用程序
最新发布
06-23
Java语言编写的计算器应用程序，适用于Java课程设计项目，可打包成exe文件方便使用。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
java语言简单编写计算器
05-30
精简的计算器风格 可放大放小 代码准有注释 一般试用于大学生大作业或者小游戏编写系列
【课程设计】Java 计算器实现（源码 + 详解）
Linux猿
12-26 9011
【课程设计】Java 计算器实现（源码 + 详解） CSDN博客专家🏆，华为云享专家🏆，Linux、C/C++、云计算、物联网、面试、刷题、算法尽管咨询我，关注我，有问题私聊！
如何用Java编写简单计算器
weixin_35748962的博客
12-27 2172
要使用Java编写一个简单的计算器，你需要以下步骤： 创建一个Java类，名为"Calculator"。在类中，定义两个数字类型的变量，名为"num1"和"num2"，表示要计算的两个数字。 在类中定义一个方法，名为"add"，用于计算两个数的和。该方法应该接受两个参数，并将它们相加。 在类中定义另一个方法，名为"subtract"，用于计算两个数的差。该方法应该接受两个参数，并将它们相减。...
Java实现计算器
Dawn_3563的博客
09-27 573
使用Java开发一个简易计算器
【Java Mooc图形练习】完整版计算器代码+复选框填空
JacinLee的博客
05-13 1844
Java图形界面，计算器的设计与实现、复选框填空，分别包含有Mooc版和详细版。
java简易计算器（四则运算、三角函数、实现优先级）
8-0416
05-17 9155
本人大一新手小白一枚，今天是我开通博客的第一天，发个java计算器纪念一下。 诸位有意见可以提，有不懂的也可以问，但不保证才疏学浅的博主能回答上来 希望以后能和你们一起共同进步，共勉！ 先放上博主的代码 下面的是界面和一部分运算代码： import java.awt.*; import javax.swing.*; import java.awt.event.*; public c...
使用Java编写简易计算器程序
06-09
好的，下面是一个使用Java编写的简易计算器程序： ```java import java.util.Scanner; public class Calculator { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入第一个数："); double num1 = scanner.nextDouble(); System.out.print("请输入运算符（+、-、*、/）："); String operator = scanner.next(); System.out.print("请输入第二个数："); double num2 = scanner.nextDouble(); double result = 0.0; switch (operator) { case "+": result = num1 + num2; break; case "-": result = num1 - num2; break; case "*": result = num1 * num2; break; case "/": result = num1 / num2; break; default: System.out.println("无效的运算符"); return; } System.out.println("结果为：" + result); } } ``` 该程序可以接收用户输入的两个数和运算符，然后进行相应的计算并输出结果。需要注意的是，程序中使用了 `Scanner` 类来获取用户输入，使用了 `switch` 语句来判断运算符并执行相应的计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫猫虫(——)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值