精华内容
下载资源
问答
  • java代码编写计算器

    2017-08-05 19:18:30
    import java.awt.BorderLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.J
    package shx;
    
    import java.awt.BorderLayout;
    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.JPanel;
    import javax.swing.JTextField;  
    public class Jsq implements ActionListener { 
    private JFrame frame;
    private JButton[] bus;  
    private JTextField jtx;  
    private JButton bu;   
    private char[] strs; 
    private String d_one = "";  
    private String operator;  
    public static void main(String[] args) {  
    new Jsq(); 
    }
    public Jsq() { 
    frame = new JFrame("计算器"); 
    jtx = new JTextField(14);  
    bus = new JButton[16];   
    strs = "789/456*123-0.+=".toCharArray();   
    for (int i = 0; i < 16; i++) {  
    bus[i] = new JButton(strs[i] + "");  
    bus[i].addActionListener(this);  

    bu = new JButton("C");  
    bu.addActionListener(this);  
    init();  } 
    public void init() {
    JPanel jp1 = new JPanel(); 
    jp1.add(jtx);   jp1.add(bu); 
    frame.add(jp1, BorderLayout.NORTH);  
    JPanel jp2 = new JPanel();   
    jp2.setLayout(new GridLayout(4, 4));  
    for (int i = 0; i < 16; i++) {  
    jp2.add(bus[i]);  
    }   
    frame.add(jp2, BorderLayout.CENTER);  
    frame.pack();  
    frame.setLocation(300, 400);  
    frame.setVisible(true);  
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
    }   
    public void actionPerformed(ActionEvent arg0) {  

    String conn = arg0.getActionCommand();  
      
    if ("C".equals(conn)) { 

      d_one = "";   
      operator = "";  
      jtx.setText("");   
      return;   
      }
     
    if(".".equals(conn)){  
    return;   
    }   

    if (("+-*/".indexOf(conn)) != -1) { 
    if("".equals(d_one) && "".equals(jtx.getText())) 
    return; 
    d_one = jtx.getText();    operator = conn;  
    jtx.setText("");    
    return;  
    }   

    if ("=".equals(conn)) { 
    if("".equals(d_one) && "".equals(jtx.getText()))
    return;  
    double db = 0; 
    if ("+".equals(operator)) {  
    db = Double.parseDouble(d_one)       + Double.parseDouble(jtx.getText());  
    jtx.setText(db + "");  
    }
    if ("-".equals(operator)) {  
    db = Double.parseDouble(d_one)       - Double.parseDouble(jtx.getText()); 
    jtx.setText(db + "");   
    }
    if ("*".equals(operator)) { 
    db = Double.parseDouble(d_one)  * Double.parseDouble(jtx.getText());  
    jtx.setText(db + "");   
    }  
    if ("/".equals(operator)) { 
    db = Double.parseDouble(d_one)       / Double.parseDouble(jtx.getText()); 
    jtx.setText(db + ""); 
    }   
    d_one = db + ""; 
    return;

     
    jtx.setText(jtx.getText() + conn);  

    }
    展开全文
  • 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编写计算器

    2008-09-14 02:10:33
    JAVA代码编写计算器 仿照WINDOWS下的计算器 只实现了基本的功能
  • java编写计算器代码

    2012-05-04 13:46:39
    java编写计算器代码
  • Java EJB制作的计算器源码,Calculator计算器,是很多初学软件编写朋友都喜欢仿写的功能,从中可以熟悉一下一些基本的Java代码编写规范,算法和技巧等。因测试时Java环境问题,我没有调试起来,这个自己下载源码编译...
  • 本篇文章给大家分享的只用200行java代码,实现一个计算器程序,不仅能够计算加减乘除,还能够匹配小括号。实现代码超简单,需要的朋友参考下吧
  • Java编写计算器-源代码
  • java编写计算器代码 适合初学java者。
  • JAVA编写计算器代码

    2009-05-21 12:21:26
    JAVA实现的计算器,功能完备,代码简单明了便于理解。可以参考
  • Java编写计算器,包含代码和文档
  • JAVA编写计算器

    千次阅读 多人点赞 2019-05-23 22:32:02
    JAVA编写一个实现加减乘除运算的计算器 1.实现加减乘除以及乘方运算; 2.C是清除键,清除之前输入所有数据,计算结果归零。 3.CE也是清除键,清除上一个输入的数据。 思路就是创建一个窗口,然后给窗口添加容器或...

    用JAVA编写一个实现加减乘除运算的计算器

    1.实现加减乘除以及乘方运算;
    2.C是清除键,清除之前输入所有数据,计算结果归零。
    3.CE也是清除键,清除上一个输入的数据。

    思路就是创建一个窗口,然后给窗口添加容器或组件,然后给组件添加监视器,检测事件的发生,然后进行相应的事件处理。
    主要知识点:窗口建立,添加组件,布局,事件处理。

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

    PS:总的来说这是java的入门,初学者的话遇到这个实验不要慌,没有多难。其实就相当于修房子一样,你首先得打地基(这里就是窗口),然后在这个基础上添砖加瓦(这里可以当做容器和组件)。弄好以后根据你的需求让房子里面的器件实现你的功能,给电器(组件)安装一个开关,当你按下开关以后就根据相应操作做出相应的反应(就是给事件源添加一个监视器,一旦监视器监视到事件源做出反应,就进行相应的事件处理)。

    来吧,见代码:

    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    public class CaculatorDemo {
    	public static void main(String[] args) {
    		JS win=new JS();
    	}
    }
    class JS extends JFrame implements ActionListener{
    	private StringBuilder sBuilder = new StringBuilder();  //利用StringBuilder类来显示,以及区分两个操作数
    	JTextArea text=new JTextArea();
    	double a,b;
    	Double sum;
    	int i;
    	public JS()
    	{
    		setBounds(100,100,400,400);
    		setTitle("计算器");
    		JMenuBar menubar=new JMenuBar();//创建菜单条
    		JMenu menu1=new JMenu("查看(V)");//创建和设置菜单名
    		JMenu menu2=new JMenu("编辑(E)");//创建和设置菜单名
    		JMenu menu3=new JMenu("帮助(H)");//创建和设置菜单名
    		menubar.add(menu1);//将菜单加入到菜单条中
    		menubar.add(menu2);
    		menubar.add(menu3);
    		this.setJMenuBar(menubar);//将设置好的菜单条放在窗口中
    		this.setLayout(new BorderLayout());//添加文本框
    		JPanel p1=new JPanel();
    		JPanel p2=new JPanel();
    		text.setPreferredSize(new Dimension (370,60));//设置组件大小
    		p2.setLayout(new FlowLayout());
    		p1.add(text);
    		this.add(p1,BorderLayout.NORTH);
    		
    		
    		p2.setLayout(new GridLayout(5,4));	//添加按钮
    		JButton button[]=new JButton[20];
    		button[0]=new JButton("C");		//清空
    		button[1]=new JButton("CE");	//清除之前输入的一个数据
    		button[2]=new JButton("%");		//取余
    		button[3]=new JButton("÷");   //除法
    		button[4]=new JButton("7");
    		button[5]=new JButton("8");
    		button[6]=new JButton("9");
    		button[7]=new JButton("x");  //乘号
    		button[8]=new JButton("4");
    		button[9]=new JButton("5");
    		button[10]=new JButton("6");
    		button[11]=new JButton("—");  //减号
    		button[12]=new JButton("1");
    		button[13]=new JButton("2");
    		button[14]=new JButton("3");
    		button[15]=new JButton("+");  //加号
    		button[16]=new JButton("e");	//乘方
    		button[17]=new JButton("0");
    		button[18]=new JButton(".");  //小数点
    		button[19]=new JButton("="); //等于
    		
    		for(int i=0;i<button.length;i++ )	//将组件加入容器
    			p2.add(button[i]);
    		button[19].setBackground(Color.ORANGE);//设置按钮的背景颜色为橙色
    		p2.add(button[19]);
    		add(p2,BorderLayout.CENTER);
    		
    		for(int i=0;i<button.length;i++)	//为每一个事件(按钮)添加监视器
    			button[i].addActionListener(this);
    		this.setVisible(true);
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //点击X号可以关闭程序
    	}
    	
    	public void actionPerformed(ActionEvent e) //事件处理
    	{
    		// TODO Auto-generated method stub
    		String lab=e.getActionCommand();			//得到当前的按钮字符,后面进行匹配
    		
    		if(lab.equals("0"))								//处理按钮 0~9
    		{
    			sBuilder.append("0");		//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据
    		}
    		else if(lab.equals("1"))
    		{
    			sBuilder.append("1");		//利用StringBuilder类的对象调用方法,将数据存起来			
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据	
    		}
    		else if(lab.equals("2"))
    		{
    			sBuilder.append("2");		//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());	 //显示之前所有输入的数据
    		}
    		else if(lab.equals("3"))
    		{
    			sBuilder.append("3");		//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据
    		}
    		else if(lab.equals("4"))
    		{
    			sBuilder.append("4");					
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("5"))
    		{
    			sBuilder.append("5");				
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("6"))
    		{
    			sBuilder.append("6");				
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("7"))
    		{
    			sBuilder.append("7");					
    			text.setText(sBuilder.toString());	
    		}
    		
    		else if(lab.equals("8"))
    		{
    			sBuilder.append("8");						
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("9"))
    		{
    			sBuilder.append("9");		//利用StringBuilder类的对象调用方法,将数据存起来		
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据
    		}
    		
    		else if(lab.equals("CE"))    				//处理"CE"按钮事件   即清除当前的输入的数据
    		{
    			sBuilder.deleteCharAt(sBuilder.length() - 1);	//StringBuilder的实例化对象调用方法下标减1即可
    			text.setText(sBuilder.toString());
    		}
    		else if(lab.equals("C"))                   //处理"CE"按钮事件   即清除之前的输入所有的数据
    		{
    			sBuilder = new StringBuilder();						//重新创建即可清除之前的输入所有的数据
    			text.setText(sBuilder.toString());
    		}
    		else if(lab.equals("."))						// 处理按钮 "." 事件
    		{
    			sBuilder.append(".");						//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());			//显示之前输入的数据
    		}
    		
    		else if(lab.equals("+"))	//处理+"按钮乘法
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将 运算符 之前的数据 作为第一个操作数 a
    			i=0;
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("+");
    		}
    		else if(lab.equals("—"))		//处理"—"按钮乘法
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=1;												//标记运算类型  即"÷"之前的数据即将作为因数
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b									
    			text.setText("—");
    		}
    		else if(lab.equals("x"))    	//处理"x"按钮乘法
    		{										
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=2;											//标记运算类型  即"÷"之前的数据即将作为因数
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("x");
    		}
    		else if(lab.equals("÷"))		//处理"÷"按钮事件
    		{
    			i=3;											//标记运算类型  即"÷"之前的数据即将作为被除数
    			a = Double.parseDouble(sBuilder.toString());	//将除法的输入的数 作为第一个操作数a
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("÷");
    		}
    		
    		else if(lab.equals("%"))	//处理取余运算
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=4;											//标记取余运算
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("%");
    		}
    		else if(lab.equals("e"))	//处理取余运算
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=5;											//标记取余运算
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("e");
    		}
    		else if(lab.equals("="))
    		{
    			b = Double.parseDouble(sBuilder.toString());	//一遇到"=",我们就能得到第二个操作数b
    			if (i == 0)			//加法 a+b
    				{
    					sum=a+b;
    					text.setText(sum.toString());		//输出第二个操作数已经输入的数据
    					sBuilder = new StringBuilder();		//清空数据,为后面的操作数留空间
    					sBuilder.append(sum);
    				} 
    			else if (i == 1) 	//加法  a-b
    				{
    					sum = a - b;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();		//清空数据,为后面的操作数留空间
    					sBuilder.append(sum);
    				}
    			else if (i == 2) 	//乘法  a*b
    				{
    					sum = a * b;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			else if (i == 3) 	//除法 a÷b
    				{
    					sum = a / b;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			else if (i == 4)	 //	取余      a%b
    				{
    					sum=a % b;
    					int m=(int)a;
    					int n=(int)b;
    					sum=(double)m % n;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			else if (i == 5) 	//	次幂      a是底数	 b是指数
    			 {
    				 sum=1.0;
    				 if(b==0)
    					 sum=1.0;
    				 else
    					 for(int i=1;i<=b;i++)
    					  sum=sum*a;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			 else 
    				text.setText(sBuilder.toString());
    		}
    	}
    }
    
    
    
    
    
    
    展开全文
  • JAVA代码编写计算器,包括所有代码和一个.JAR文件,双击既可运行
  • JAVA编写计算器代码

    2011-08-23 00:10:18
    初涉java写的源代码、不是很长大概300行、、
  • 使用Java编写计算器代码,可以正常运行,进行简单的四则运算。项目结构设计可能不够合理,你可以下载下来进行参考和学习,做出相应的修改,使之更加完善。使用substance对界面进行了美化。
  • java编写计算器代码

    2010-12-05 21:24:36
    有用就下载吧,仅供学习,相互探讨 如有错误,请指正!
  • java编写简单计算器

    2012-11-25 21:50:28
    java编写的简单计算器代码 放win7计算器界面
  • java编写计算器代码 很给力 可以进行简单的加减乘除 刚做的不好指出来啊
  • java 编写计算器,附源代码。用java 编写计算器,附源代码。用java 编写计算器,附源代码
  • Java编写计算器

    2015-05-24 18:54:53
    Java编写的小计算器可以实现加减乘除
  • Java写一个计算器算一个难度非常低的练习,它将我之前学过的 Java 的知识重新地拾起来了。在这个小练习中,我选择了逻辑层和显示层分离(MVC模式)的JavaFX 技术。在javafx 中,用fxml文件来表示显示层内容,用...

    引言:

    最近在学习java ,在学习的过程中想找几个简单的小程序练手。用Java写一个计算器算一个难度非常低的练习,它将我之前学过的 Java 的知识重新地拾起来了。在这个小练习中,我选择了逻辑层和显示层分离(MVC模式)的JavaFX 技术。在javafx 中,用fxml文件来表示显示层内容,用Java 来编写程序的业务逻辑。

    文章结构

    |-- 显示层设计
    |-- 逻辑层设计
    |-- 源代码

    显示层

    显示层的设计中只存在一个简单的界面,界面中包含两部分 -- 按钮区和显示区。具体的界面如图:

    具体的布局为 :

    SpiltPane--|--VBox--|--HBox
               |        |--HBox
               |        |--HBox
               |
               |--GridPane

     

     在整个JavaFX程序中,显示层的界面和布局都是由fxml 文件生成的,在idea中可以直接由集成的Java Scene Builder 拖拽和配置相应的参数完成。

    逻辑层

    在这次的练习中计算器的设计逻辑是这样的:

    1. 用一个Stack 去存储输入的数字和操作符,并将输入input1,input2分别用两个StringBuffer类存储,并实时更新到显示区域。

    2. 每点击一个数字,都会在显示区域的标签中, 并分别存入输入栈和 输入字符串的StringBuffer中。

    3. 用操作符来区分输入的数字是第一个还是第二个。

    4. 当点击删除(DEL)时,从栈中将栈顶的元素删除,从输入的StringBuffer类中去掉这个字符。当点击Clear 时,清空输入栈(inputStack)和输入字符串(firstInputStr,secondInputStr)。并将对应的结果实时更新到显示区。

    5. 当点击  ' = ' 时,开始进行计算,并把计算的结果反馈到显示区域。每次计算之后,都会对相应的参数进行清空。

    源代码文件

    GitHub仓库:https://github.com/XDKejin/java_files_of_my_study

     

    1. Calculator.java

    ​
    package calculator;
    
    import javafx.application.Application;
    import javafx.fxml.FXMLLoader;
    import javafx.scene.Parent;
    import javafx.scene.Scene;
    import javafx.stage.Stage;
    
    public class Calculator extends Application {
    
        @Override
        public void start(Stage primaryStage) throws Exception{
    
            Parent root = FXMLLoader.load(getClass().getResource("calculator.fxml"));
            primaryStage.setTitle("Calculator");
            primaryStage.setScene(new Scene(root, 400, 500));
            primaryStage.show();
        }
        public static void main(String[] args) {
            launch(args);
        }
    }
    
    ​

    2. CalculatorController.java

    package calculator;
    
    import javafx.event.ActionEvent;
    import javafx.fxml.FXML;
    import javafx.fxml.Initializable;
    import javafx.scene.control.Label;
    
    import java.net.URL;
    import java.util.ResourceBundle;
    import java.util.Stack;
    
    
    public class CalculatorController implements Initializable{
    
        @FXML private Label firstInput;
        @FXML private Label secondInput;
        @FXML private Label showResult;
        @FXML private Label showOperator;
    
    
        Stack <Character>inputStack ;
    
        StringBuffer firstInputStr;
        StringBuffer secondInputStr;
    
        char operator;
    
        boolean isChanged = false;
    
        int result;     //store result
    
    
        @Override
        public void initialize(URL location, ResourceBundle resources) {
            firstInputStr = new StringBuffer();
            secondInputStr = new StringBuffer();
            inputStack = new <Character>Stack();
        }
    
    
    
        /*
        *   number button action code  is below here:
        * */
    
        @FXML protected void pressNumZero(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('0');
            else
                secondInputStr.append('0');
    
            inputStack.push('0');
            putStrToLabel();
    
    
        }
        @FXML protected void pressNumOne(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('1');
            else
                secondInputStr.append('1');
    
            inputStack.push('1');
            putStrToLabel();
    
        }
        @FXML protected void pressNumTwo(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('2');
            else
                secondInputStr.append('2');
    
            inputStack.push('2');
            putStrToLabel();
        }
    
        @FXML protected void pressNumThree(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('3');
            else
                secondInputStr.append('3');
    
            inputStack.push('3');
            putStrToLabel();
    
        }
        @FXML protected void pressNumFour(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('4');
            else
                secondInputStr.append('4');
    
            inputStack.push('4');
            putStrToLabel();
        }
        @FXML protected void pressNumFive(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('5');
            else
                secondInputStr.append('5');
    
            inputStack.push('5');
            putStrToLabel();
        }
        @FXML protected void pressNumSix(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('6');
            else
                secondInputStr.append('6');
    
            inputStack.push('6');
            putStrToLabel();
        }
        @FXML protected void pressNumSeven(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('7');
            else
                secondInputStr.append('7');
    
            inputStack.push('7');
            putStrToLabel();
        }
        @FXML protected void pressNumEight(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('8');
            else
                secondInputStr.append('8');
    
            inputStack.push('8');
            putStrToLabel();
        }
        @FXML protected void pressNumNine(ActionEvent event){
            if (!isChanged)
                firstInputStr.append('9');
            else
                secondInputStr.append('9');
    
            inputStack.push('9');
            putStrToLabel();
        }
    
        /*
        *       operator button action code is below here;
        *
        * */
    
        @FXML protected void pressOperatorAdd(ActionEvent event){
            operator = '+';
            inputStack.push('+');
            showOperator.setText("+");
            isChanged = true;
    
        }
        @FXML protected void pressOperatorMinus(ActionEvent event){
            operator = '-';
            inputStack.push('-');
            showOperator.setText("-");
            isChanged = true;
        }
        @FXML protected void pressOperatorMultiply(ActionEvent event){
            operator = '*';
            inputStack.push('*');
            showOperator.setText("*");
            isChanged = true;
        }
        @FXML protected void pressOperatorDivide(ActionEvent event){
            operator = '/';
            inputStack.push('/');
            showOperator.setText("/");
            isChanged = true;
        }
        @FXML protected void pressOperatorMod(ActionEvent event){
            operator = '%';
            inputStack.push('%');
            showOperator.setText("%");
            isChanged = true;
        }
    
    
        /*
        *       function key action code is below here
        * */
        @FXML protected void pressFunckeyDel(ActionEvent event){
            if (inputStack.empty()){
                clearCache();
                updateDisplay();
                return;
            }
    
    
            if ( (int)(inputStack.peek()) >= (int)('0')  && (int)(inputStack.peek()) <= (int)('9')){
                if (!isChanged)
                    firstInputStr.deleteCharAt( firstInputStr.length() - 1 );
                else
                    secondInputStr.deleteCharAt( secondInputStr.length() - 1 );
            }else {
                showOperator.setText("");
                isChanged = false;
            }
    
            inputStack.pop();
            updateDisplay();
    
        }
    
        @FXML protected void pressFunckeyClear(ActionEvent event){
            clearCache();
            updateDisplay();
        }
    
    
        /*
        *       press '=' button get RESULT
        * */
        @FXML protected void getResult(ActionEvent event){
            int first = Integer.parseInt(firstInputStr.toString());
            int second = Integer.parseInt(secondInputStr.toString());
    
            switch (operator){
                case '+' :
                    result = first + second;
                    break;
                case '-' :
                    result = first - second;
                    break;
                case '*' :
                    result = first * second;
                    break;
                case '/' :
                    if (0 == second)
                        break;
                    result = first / second;
                    break;
                case '%' :
                    result = first % second;
                    break;
            }
            showResult.setText(result+"");
    
            //清空各种参数的缓存
            clearCache();
        }
    
    
    
        /*
        *       extra method
        *
        * */
    
        void putStrToLabel(){
            firstInput.setText(firstInputStr.toString());
            secondInput.setText(secondInputStr.toString());
        }
    
        void updateDisplay(){
            if (inputStack.empty()){
                setDisplayNull();
                return;
            }
    
            firstInput.setText(firstInputStr.toString());
            secondInput.setText(secondInputStr.toString());
            showOperator.setText(operator+"");
            if ( 0 == result )
                showResult.setText("");
            else
                showResult.setText(result+"");
    
        }
    
    
        void clearCache(){
            isChanged = false;
            firstInputStr.delete( 0,(firstInputStr.length()) );
            secondInputStr.delete( 0, (secondInputStr.length()));
            result = 0;
    
            while(!inputStack.empty()){
                inputStack.pop();
                System.out.println(inputStack.toString());
            }
    
        }
    
        void setDisplayNull(){
            firstInput.setText("");
            secondInput.setText("");
            showOperator.setText("");
            showResult.setText("");
    
        }
    
    
    
    
    
    }
    

    3. calculator.fxml

    <?xml version="1.0" encoding="UTF-8"?>
    
    <?import javafx.geometry.Insets?>
    <?import javafx.scene.control.Button?>
    <?import javafx.scene.control.Label?>
    <?import javafx.scene.control.SplitPane?>
    <?import javafx.scene.layout.AnchorPane?>
    <?import javafx.scene.layout.ColumnConstraints?>
    <?import javafx.scene.layout.GridPane?>
    <?import javafx.scene.layout.HBox?>
    <?import javafx.scene.layout.RowConstraints?>
    <?import javafx.scene.layout.VBox?>
    <?import javafx.scene.text.Font?>
    
    <GridPane alignment="center" hgap="10" prefHeight="500.0" prefWidth="400.0" vgap="10" xmlns="http://javafx.com/javafx/8.0.172-ea" xmlns:fx="http://javafx.com/fxml/1" fx:controller="calculator.CalculatorController">
       <columnConstraints>
          <ColumnConstraints />
       </columnConstraints>
       <rowConstraints>
          <RowConstraints />
       </rowConstraints>
       <children>
          <SplitPane dividerPositions="0.3273092369477912" orientation="VERTICAL" prefHeight="500.0" prefWidth="400.0">
            <items>
              <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="180.0" prefWidth="398.0">
                   <children>
                      <VBox prefHeight="150.0" prefWidth="400.0">
                         <children>
                            <HBox prefHeight="50.0" prefWidth="400.0">
                               <children>
                                  <Label prefHeight="50.0" prefWidth="70.0" style="-fx-background-color: #CDC9C9;" text="Input 1:">
                                     <font>
                                        <Font size="16.0" />
                                     </font>
                                     <HBox.margin>
                                        <Insets />
                                     </HBox.margin></Label>
                                  <Label fx:id="firstInput" prefHeight="50.0" prefWidth="280.0">
                                      <font>
                                          <Font size="16.0" />
                                      </font></Label>
                                  <Label fx:id="showOperator" alignment="CENTER" contentDisplay="CENTER" prefHeight="50.0" prefWidth="50.0" style="-fx-background-color: #F0FFF0;">
                                     <font>
                                        <Font size="20.0" />
                                     </font></Label>
                               </children></HBox>
                            <HBox layoutY="50.0" prefHeight="50.0" prefWidth="400.0">
                               <children>
                                  <Label prefHeight="50.0" prefWidth="70.0" style="-fx-background-color: #CDC9C9;" text="Input 2:">
                                      <font>
                                          <Font size="16.0" />
                                      </font></Label>
                                  <Label fx:id="secondInput" prefHeight="50.0" prefWidth="330.0">
                                      <font>
                                          <Font size="16.0" />
                                      </font></Label>
                               </children></HBox>
                            <HBox layoutY="100.0" prefHeight="50.0" prefWidth="400.0">
                               <children>
                                  <Label prefHeight="50.0" prefWidth="70.0" style="-fx-background-color: #CDC9C9;" text="Result :">
                                      <font>
                                          <Font size="16.0" />
                                      </font></Label>
                                  <Label fx:id="showResult" prefHeight="50.0" prefWidth="330.0">
                                      <font>
                                          <Font size="16.0" />
                                      </font></Label>
                               </children></HBox>
                         </children>
                      </VBox>
                   </children></AnchorPane>
              <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="350.0" prefWidth="400.0">
                   <children>
                      <GridPane layoutY="10.0" prefHeight="320.0" prefWidth="400.0">
                        <columnConstraints>
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
    
                        </columnConstraints>
                        <rowConstraints>
                          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                          
    
                        </rowConstraints>
                         <children>
                            <Button fx:id="numOne" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumOne" prefHeight="80.0" prefWidth="80.0" text="1" GridPane.columnIndex="0" GridPane.rowIndex="0">
                               <font>
                                  <Font size="20.0" />
                               </font></Button>
                             <Button fx:id="numTwo" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumTwo" prefHeight="80.0" prefWidth="80.0" text="2" GridPane.columnIndex="1" GridPane.rowIndex="0">
                                 <font>
                                     <Font size="20" />
                                 </font>
                             </Button>
                             <Button fx:id="numThree" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumThree" prefHeight="80.0" prefWidth="80.0" text="3" GridPane.columnIndex="2" GridPane.rowIndex="0">
                                 <font>
                                     <Font size="20" />
                                 </font>
                             </Button>
                            <Button fx:id="numFour" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumFour" prefHeight="80.0" prefWidth="80.0" text="4" GridPane.columnIndex="0" GridPane.rowIndex="1">
                                 <font>
                                     <Font size="20" />
                                 </font>
                            </Button>
                             <Button fx:id="numFive" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumFive" prefHeight="80.0" prefWidth="80.0" text="5" GridPane.columnIndex="1" GridPane.rowIndex="1">
                                 <font>
                                     <Font size="20" />
                                 </font>
                             </Button>
                             <Button fx:id="numSix" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumSix" prefHeight="80.0" prefWidth="80.0" text="6" GridPane.columnIndex="2" GridPane.rowIndex="1">
                                 <font>
                                     <Font size="20" />
                                 </font>
                             </Button>
                            <Button fx:id="numSeven" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumSeven" prefHeight="80.0" prefWidth="80.0" text="7" GridPane.columnIndex="0" GridPane.rowIndex="2">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="numEight" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumEight" prefHeight="80.0" prefWidth="80.0" text="8" GridPane.columnIndex="1" GridPane.rowIndex="2">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="numNine" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumNine" prefHeight="80.0" prefWidth="80.0" text="9" GridPane.columnIndex="2" GridPane.rowIndex="2">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="operatorMod" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressOperatorMod" prefHeight="80.0" prefWidth="80.0" text="mod" GridPane.columnIndex="0" GridPane.rowIndex="3">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="numZero" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressNumZero" prefHeight="80.0" prefWidth="80.0" text="0" GridPane.columnIndex="1" GridPane.rowIndex="3">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="calculatorResult" contentDisplay="CENTER" mnemonicParsing="false" onAction="#getResult" prefHeight="80.0" prefWidth="80.0" text="=" GridPane.columnIndex="2" GridPane.rowIndex="3">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="funckeyDel" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressFunckeyDel" prefHeight="80.0" prefWidth="80.0" text="DEL" GridPane.columnIndex="3">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="funcKeyClear" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressFunckeyClear" prefHeight="80.0" prefWidth="80.0" text="CLEAR" GridPane.columnIndex="3" GridPane.rowIndex="1">
                                <font>
                                    <Font size="16" />
                                </font>
                            </Button>
                            <Button fx:id="operatorAdd" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressOperatorAdd" prefHeight="80.0" prefWidth="80.0" text="+" GridPane.columnIndex="3" GridPane.rowIndex="2">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="operatorMinus" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressOperatorMinus" prefHeight="80.0" prefWidth="80.0" text="-" GridPane.columnIndex="4" GridPane.rowIndex="2">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="operatorMultiply" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressOperatorMultiply" prefHeight="80.0" prefWidth="80.0" text="*" GridPane.columnIndex="3" GridPane.rowIndex="3">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button fx:id="operatorDivide" contentDisplay="CENTER" mnemonicParsing="false" onAction="#pressOperatorDivide" prefHeight="80.0" prefWidth="80.0" text="/" GridPane.columnIndex="4" GridPane.rowIndex="3">
                                <font>
                                    <Font size="20" />
                                </font>
                            </Button>
                            <Button contentDisplay="CENTER" mnemonicParsing="false" prefHeight="80.0" prefWidth="80.0" text="spare1" GridPane.columnIndex="4" GridPane.rowIndex="0">
                                <font>
                                    <Font size="16" />
                                </font>
                            </Button>
                            <Button contentDisplay="CENTER" mnemonicParsing="false" prefHeight="80.0" prefWidth="80.0" text="spare2" GridPane.columnIndex="4" GridPane.rowIndex="1">
                                <font>
                                    <Font size="16" />
                                </font>
                            </Button>
                         </children>
                      </GridPane>
                   </children></AnchorPane>
            </items>
          </SplitPane>
       </children>
    </GridPane>
    

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

     

    展开全文
  • java scanner 编写计算器程序

    千次阅读 2016-10-19 17:33:00
    写了个简单java 计算器程序,记录一下 package test; import java.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; class Calculator { private Double num1; private Double ...
  • java编写的简单计算器,实现加、减、乘、除四则运算
  • Java编写计算器程序及源代码
  • JAVA编写计算器程序源代码

    热门讨论 2009-04-28 10:39:11
    JAVA编写计算器程序源代码 ; JAVA编写的看图软件程序源代码 ; JAVA编写的螃蟹过街程序源代码 ; JAVA编写的拼图---键盘操作程序源代码 ; JAVA编写的拼图---鼠标操作程序源代码 ; JAVA编写的文本编辑器程序源代码 ...
  • Java编写计算器代码展示! import java.awt.BorderLayout; import java.awt.Dimension; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,337
精华内容 5,334
关键字:

java代码编写计算器

java 订阅