精华内容
下载资源
问答
  • java编写图形界面计算器源码[定义].pdf
  • java编写图形界面计算器,实现基本的运算
  • 编写程序实现一个简单计算器的基本功能,具体可以模仿Windows附件中的计算器或模拟常见的实物计算器。 package beizi; import java.awt.EventQueue; import javax.swing.JFrame; import javax....

     

    编写程序实现一个简单计算器的基本功能,具体可以模仿Windows附件中的计算器或模拟常见的实物计算器。


    package beizi;
    
    import java.awt.EventQueue;
    
    import javax.swing.JFrame;
    import javax.script.ScriptEngine;
    import javax.script.ScriptEngineManager;
    import javax.swing.JButton;
    import java.awt.event.ActionListener;
    import java.awt.event.ActionEvent;
    import javax.swing.JTextArea;
    import javax.swing.JTextPane;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    
    import java.awt.TextArea;
    import java.awt.Color;
    import javax.swing.JTextField;
    
    public class cal {
    
    	private JFrame frame;
    	private JTextField textField;
    	private JTextField textField_1;
    
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					cal window = new cal();
    					window.frame.setVisible(true);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the application.
    	 */
    	public cal() {
    		initialize();
    //		calResult();
    	}
    
    	/**
    	 * Initialize the contents of the frame.
    	 */
     	private void initialize() {
    		frame = new JFrame();
    		frame.setBounds(100, 100, 450, 400);
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		frame.getContentPane().setLayout(null);
    		
    		
    		
    		JButton btnNewButton = new JButton("1");
    		btnNewButton.setBackground(Color.LIGHT_GRAY);
    		btnNewButton.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"1");
    			}
    		});
    		btnNewButton.setBounds(33, 142, 68, 38);
    		frame.getContentPane().add(btnNewButton);
    
    		JButton button = new JButton("4");
    		button.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"4");
    			}
    		});
    		button.setBackground(Color.LIGHT_GRAY);
    		button.setBounds(33, 194, 68, 38);
    		frame.getContentPane().add(button);
    
    		JButton button_1 = new JButton("7");
    		button_1.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"7");
    			}
    		});
    		button_1.setBackground(Color.LIGHT_GRAY);
    		button_1.setBounds(33, 242, 68, 38);
    		frame.getContentPane().add(button_1);
    
    		JButton button_2 = new JButton("2");
    		button_2.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"2");
    			}
    		});
    		button_2.setBackground(Color.LIGHT_GRAY);
    		button_2.setBounds(111, 142, 68, 38);
    		frame.getContentPane().add(button_2);
    		
    		JButton button_3 = new JButton("5");
    		button_3.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"5");
    			}
    		});
    		button_3.setBackground(Color.LIGHT_GRAY);
    		button_3.setBounds(111, 194, 68, 38);
    		frame.getContentPane().add(button_3);
    		
    		JButton button_4 = new JButton("8");
    		button_4.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"8");
    			}
    		});
    		button_4.setBackground(Color.LIGHT_GRAY);
    		button_4.setBounds(111, 242, 68, 38);
    		frame.getContentPane().add(button_4);
    		
    		JButton button_5 = new JButton("3");
    		button_5.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"3");
    			}
    		});
    		button_5.setBackground(Color.LIGHT_GRAY);
    		button_5.setBounds(189, 142, 68, 38);
    		frame.getContentPane().add(button_5);
    		
    		JButton button_6 = new JButton("6");
    		button_6.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"6");
    			}
    		});
    		button_6.setBackground(Color.LIGHT_GRAY);
    		button_6.setBounds(189, 194, 68, 38);
    		frame.getContentPane().add(button_6);
    		
    		JButton button_7 = new JButton("9");
    		button_7.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"9");
    			}
    		});
    		button_7.setBackground(Color.LIGHT_GRAY);
    		button_7.setBounds(189, 242, 68, 38);
    		frame.getContentPane().add(button_7);
    		
    		JButton button_8 = new JButton("0");
    		button_8.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"0");
    			}
    		});
    		button_8.setBackground(Color.LIGHT_GRAY);
    		button_8.setBounds(111, 290, 68, 38);
    		frame.getContentPane().add(button_8);
    		
    		JButton button_9 = new JButton("(");
    		button_9.setBackground(Color.ORANGE);
    		button_9.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"(");
    			}
    		});
    		button_9.setBounds(33, 93, 68, 38);
    		frame.getContentPane().add(button_9);
    		
    		JButton button_10 = new JButton(")");
    		button_10.setBackground(Color.ORANGE);
    		button_10.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+")");
    			}
    		});
    		button_10.setBounds(109, 94, 70, 38);
    		frame.getContentPane().add(button_10);
    		
    		JButton button_11 = new JButton("+");
    		button_11.setBackground(Color.ORANGE);
    		button_11.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"+");
    			}
    		});
    		button_11.setBounds(267, 142, 44, 38);
    		frame.getContentPane().add(button_11);
    		
    		JButton button_12 = new JButton("-");
    		button_12.setBackground(Color.ORANGE);
    		button_12.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"-");
    			}
    		});
    		button_12.setBounds(267, 194, 44, 38);
    		frame.getContentPane().add(button_12);
    		
    		JButton button_13 = new JButton("*");
    		button_13.setBackground(Color.ORANGE);
    		button_13.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"*");
    			}
    		});
    		button_13.setBounds(267, 242, 44, 38);
    		frame.getContentPane().add(button_13);
    		
    		JButton button_14 = new JButton("/");
    		button_14.setBackground(Color.ORANGE);
    		button_14.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"/");
    			}
    		});
    		button_14.setBounds(267, 290, 44, 38);
    		frame.getContentPane().add(button_14);
    		
    		JButton button_15 = new JButton("=");
    		button_15.setBackground(Color.GREEN);
    		button_15.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				ScriptEngine js = new ScriptEngineManager().getEngineByName("JavaScript");//将字符串公式转换为计算公式
    				String formula=textField.getText();
    				try {
    					textField_1.setText(js.eval(formula).toString());
    //					textField_1.set
    				}catch(Exception e) {
    					
    				}
    			}
    		});
    		button_15.setBounds(334, 252, 44, 76);
    		frame.getContentPane().add(button_15);
    
    		textField = new JTextField();
    		textField.setBounds(33, 21, 345, 37);
    		frame.getContentPane().add(textField);
    		textField.setColumns(10);
    
    		textField_1 = new JTextField();
    		textField_1.setBackground(Color.WHITE);
    		textField_1.setBounds(189, 94, 189, 37);
    		frame.getContentPane().add(textField_1);
    		textField_1.setColumns(10);
    		
    		JButton button_16 = new JButton("C");
    		button_16.setBackground(Color.MAGENTA);
    		button_16.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				int t=text.length()-1;
    				if(t<0) {
    					JOptionPane.showMessageDialog(null, "已经没有了((");
    					
    				}
    				else {
    					text=text.substring(0, t);
    					textField.setText(text);
    				}
    
    			}
    		});
    		button_16.setBounds(334, 142, 44, 38);
    		frame.getContentPane().add(button_16);
    		
    		JButton button_17 = new JButton("X");
    		button_17.setBackground(Color.RED);
    		button_17.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				textField.setText("");
    				textField_1.setText("");
    			}
    		});
    		button_17.setBounds(334, 202, 44, 38);
    		frame.getContentPane().add(button_17);
    		
    		JButton button_18 = new JButton(".");
    		button_18.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+".");
    			}
    		});
    		button_18.setBackground(Color.ORANGE);
    		button_18.setBounds(33, 290, 68, 38);
    		frame.getContentPane().add(button_18);
    		
    		JButton button_19 = new JButton("%");
    		button_19.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent arg0) {
    				String text=textField.getText();
    				textField.setText(text+"%");
    			}
    		});
    		button_19.setBackground(Color.ORANGE);
    		button_19.setBounds(189, 290, 68, 38);
    		frame.getContentPane().add(button_19);
    		
    	}
    }
    

     

     

    大概的效果,Java初学者,,代码重复严重,以后改,,,

     

    转载于:https://www.cnblogs.com/donke/p/10133927.html

    展开全文
  • 主要为大家详细介绍了基于java语言下图形界面AWT编写计算器,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • JAVA编写图形界面计算器

    万次阅读 多人点赞 2016-04-26 10:19:46
    JAVA编写图形界面计算器目录JAVA编写图形界面计算器 目录 计算器功能 代码块 运行界面 心得计算器功能 加减乘除四则运算 负数和小数运算 退格、清除和归零 开根号 百分号 倒数 代码块@requires_...

    JAVA编写有图形化界面的计算器

    目录

    计算器功能

    • 加减乘除四则运算
    • 负数和小数运算
    • 退格、清除和归零
    • 开根号
    • 百分号
    • 倒数

    代码块

    @requires_authorization
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    public class Test {
    
        TextField tf = new TextField(40);       //显示文本框
        StringBuffer s1 = new StringBuffer();   //记录运算数字,以及保留结果
        StringBuffer s2 = new StringBuffer();   //记录运算数字,保留上一个输入的数字或运算结果
        static String flag = new String();      //标记运算符号:+,-,*,/
        boolean start = true;   //标记运算开始或结束,保证一次运算之后,第二次进行运算时能同时清空显示界面,即s1为空
    
        public void init(){
            //主界面
            JFrame f = new JFrame("计算器");
            JPanel p1 = new JPanel();
            p1.add(tf);
            f.add(p1,BorderLayout.NORTH);
            JPanel p2 = new JPanel();
            p2.setLayout(new GridLayout(1,3));
            //动作监听器
            ActionListener listen =new ActionListener() {
    
                public void actionPerformed(ActionEvent arg0) {
    
                    //输入数字0~9
                    if(arg0.getActionCommand()=="0"){
    
                        if(!s1.toString().equals(new String())){
                            if(!start){
                                //s1清零,保证可以重新输入数字
                                s1.delete(0, s1.length());
                            }
                            start = true;
                            tf.setText(s1.append("0").toString());
                        }   
                    }
                    if(arg0.getActionCommand()=="1"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("1").toString());
                    }
                    if(arg0.getActionCommand()=="2"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("2").toString());
                    }
                    if(arg0.getActionCommand()=="3"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("3").toString());
                    }
                    if(arg0.getActionCommand()=="4"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("4").toString());
                    }
                    if(arg0.getActionCommand()=="5"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("5").toString());
                    }
                    if(arg0.getActionCommand()=="6"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("6").toString());
                    }
                    if(arg0.getActionCommand()=="7"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("7").toString());
                    }
                    if(arg0.getActionCommand()=="8"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("8").toString());
                    }
                    if(arg0.getActionCommand()=="9"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        tf.setText(s1.append("9").toString());
                    }
                    //输入小数点
                    if(arg0.getActionCommand()=="."){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start=true;
                        if(s1.toString().equals(new String()))
                            tf.setText(s1.append("0.").toString());
                        else if(s1.length()==1&&s1.charAt(0)=='-')
                            tf.setText(s1.append("0.").toString());
                        else
                            tf.setText(s1.append(".").toString());
                    }
                    //输入负号
                    if(arg0.getActionCommand()=="+/-"){
                        if(!start){
                            s1.delete(0, s1.length());
                        }
                        start = true;
                        if(s1.toString().equals(new String()))
                            tf.setText(s1.append('-').toString());
                    }
                    //退格Backspace
                    if(arg0.getActionCommand()=="Backspace"){
                        start = true;
                        if(s1.length()!=0){
                            //删除最后输入的一位
                            s1.deleteCharAt(s1.length()-1);
                            tf.setText(s1.toString());
                        }
                    }
                    //归零CE
                    if(arg0.getActionCommand()=="CE"){
                        //清空所有,start标记设为true
                        start = true;
                        s1.delete(0, s1.length());
                        s2.delete(0, s2.length());
                        tf.setText(s1.toString());
                    }
                    //清除C
                    if(arg0.getActionCommand()=="C"){
                        //清空当前输入,即s1清零
                        start = true;
                        s1.delete(0, s1.length());
                        tf.setText(s1.toString());
                    }
                    //加号
                    if(arg0.getActionCommand()=="+"){
                        start = true;
                        flag="+";
                        //s2接收s1的值
                        s2.append(String.valueOf(s1.toString()));
                        //s1清零,重新接收下一个数据
                        s1.delete(0, s1.length());
                        tf.setText(s1.toString());
                    }
                    //减号
                    if(arg0.getActionCommand()=="-"){
                        start = true;
                        flag="-";
                        s2.append(String.valueOf(s1.toString()));
                        s1.delete(0, s1.length());
                        tf.setText(s1.toString());
                    }
                    //乘号
                    if(arg0.getActionCommand()=="*"){
                        start = true;
                        flag="*";
                        s2.append(String.valueOf(s1.toString()));
                        s1.delete(0, s1.length());
                        tf.setText(s1.toString());
                    }
                    //除号
                    if(arg0.getActionCommand()=="/"){
                        start = true;
                        flag="/";
                        s2.append(String.valueOf(s1.toString()));
                        s1.delete(0, s1.length());
                        tf.setText(s1.toString());
                    }
                    //开根号
                    if(arg0.getActionCommand()=="sqrt"){
                        start =false;
                        double s=Double.parseDouble(s1.toString());
                        s1.delete(0, s1.length());
                    tf.setText(s1.append(String.valueOf(Math.sqrt(s))).toString());
                    }
                    //求%
                    if(arg0.getActionCommand()=="%"){
                        start =false;
                        double s=Double.parseDouble(s1.toString());
                        s1.delete(0, s1.length());
                        tf.setText(s1.append(String.valueOf(s/100)).toString());
                    }
                    //求1/x
                    if(arg0.getActionCommand()=="1/x"&&!s1.toString().equals(new String())&&Double.parseDouble(s1.toString())!=0){
                        start =false;
                        double s=Double.parseDouble(s1.toString());
                        s1.delete(0, s1.length());
                        tf.setText(s1.append(String.valueOf(1/s)).toString());
                    }
                    //求结果
                    if(arg0.getActionCommand()=="="&&s1.length()!=0&&s2.length()!=0){
                        //start标记为false
                        start =false;
                        //分别获取s1和s2的值
                        double s4=Double.parseDouble(s1.toString()); 
                        double s3=Double.parseDouble(s2.toString());
                        //清空s1和s2,便于开始下一次运算
                        s1.delete(0, s1.length());
                        s2.delete(0, s2.length());
                        //四则运算
                        if(flag=="+"){
                            tf.setText(s1.append(String.valueOf(s3+s4)).toString());
                        }
                        if(flag=="-"){
                            tf.setText(s1.append(String.valueOf(s3-s4)).toString());
                        }
                        if(flag=="*"){
                            tf.setText(s1.append(String.valueOf(s3*s4)).toString());
                        }
                        if(flag=="/"){
                            tf.setText(s1.append(String.valueOf(s3/s4)).toString());
                        }
                    }       
    
                }
            };
            //添加按钮以及监听器
            JButton bks = new JButton("Backspace");
            bks.addActionListener(listen);
            JButton ce = new JButton("CE");
            ce.addActionListener(listen);
            JButton c = new JButton("C");
            c.addActionListener(listen);
            p2.add(bks);
            p2.add(ce);
            p2.add(c);
            f.add(p2);
            JPanel p3 = new JPanel();
            p3.setLayout(new GridLayout(4,5));
            JButton b1 = new JButton("7");
            p3.add(b1);
            b1.addActionListener(listen);
            JButton b2 = new JButton("8");
            p3.add(b2);
            b2.addActionListener(listen);
            JButton b3 = new JButton("9");
            p3.add(b3);
            b3.addActionListener(listen);
            JButton b4 = new JButton("/");
            p3.add(b4);
            b4.addActionListener(listen);
            JButton b5 = new JButton("sqrt");
            p3.add(b5);
            b5.addActionListener(listen);
            JButton b6 = new JButton("4");
            p3.add(b6);
            b6.addActionListener(listen);
            JButton b7 = new JButton("5");
            p3.add(b7);
            b7.addActionListener(listen);
            JButton b8 = new JButton("6");
            p3.add(b8);
            b8.addActionListener(listen);
            JButton b9 = new JButton("*");
            p3.add(b9);
            b9.addActionListener(listen);
            JButton b10 = new JButton("%");
            p3.add(b10);
            b10.addActionListener(listen);
            JButton b11 = new JButton("1");
            p3.add(b11);
            b11.addActionListener(listen);
            JButton b12 = new JButton("2");
            p3.add(b12);
            b12.addActionListener(listen);
            JButton b13 = new JButton("3");
            p3.add(b13);
            b13.addActionListener(listen);
            JButton b14 = new JButton("-");
            p3.add(b14);
            b14.addActionListener(listen);
            JButton b15 = new JButton("1/x");
            p3.add(b15);
            b15.addActionListener(listen);
            JButton b16 = new JButton("0");
            p3.add(b16);
            b16.addActionListener(listen);
            JButton b17 = new JButton("+/-");
            p3.add(b17);
            b17.addActionListener(listen);
            JButton b18 = new JButton(".");
            p3.add(b18);
            b18.addActionListener(listen);
            JButton b19 = new JButton("+");
            p3.add(b19);
            b19.addActionListener(listen);
            JButton b20 = new JButton("=");
            p3.add(b20);
            b20.addActionListener(listen);
            f.add(p3,BorderLayout.SOUTH);
            f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            f.pack();
            f.setVisible(true);
        }
    
        public static void main(String args[]){
            //调用方法,实现计算器
            new Test().init();
        }
    
    }

    运行界面

    计算器的运行界面


    心得

    制作这款具有图形化界面的计算器软件,总的来说并不是太难,但是对于我这种初学者来说,还是很少独立写这么多java代码的,包括这些繁琐的按钮添加和事件监听器的添加。关于计算器运行的算法,关键在于两个StringBuffer以及两个标记String flag,boolean start
    两个StringBuffer分别用于存储当前输入的数字或运算结果和上一个输入的数字或运算结果,运算时就是用Double.parseDouble()函数获取两个StringBuffer中的数字进行四则运算。
    再然后就是两个标记的使用了,String flag的使用时用来标记运算符号的,按下运算符号时,String flag赋值为按下的运算符号,然后在按下“=”时,判断flag的内容,进行相应的四则运算。
    boolean start则是对于运算结束或者开始的标记了,boolean start初始值赋为true,标记运算开始,但是当按下”=“,”%“,”sqrt“,”1/x“时,boolean start要赋值为false,标志一次运算结束。此时,显示框即StringBuffer中有运算结果,当你想进行下一次运算重新输入时,就要对boolean start进行判断,若为false,即一次运算结束,则应清空显示框和对应的StringBuffer,再进行相对应的输入;若为true,即一次运算开始或者进行,则可以直接进行相对应的输入。考虑到有些时候可能需要对上一个获得的运算结果进行运算,因此在“+”,”-“,”“,”/”中添加了*boolean start,赋值为“true”,这样就可以对上一次运算结果进行运算了。
    对于计算器的退格、归零和清除功能,则是对于两个StringBuffer进行delete()这个函数的操作。
    这个程序的毕竟是我仓促间完成的,没有太多的时间去检查代码和bug,肯定会存在不足和错误,请多包涵和指正,谢谢!

    展开全文
  • Java编写计算器图形界面实现加减乘除带括号运算 版本1.0 1、图形化界面 2、计算器显示部分分为两个区域:第一行显示输入将要计算的数值及符号,第二行显示结果,第一行字体要小,第二行字体要大,且加粗。 ...
  • Java实现图形界面计算器(简易版)

    万次阅读 多人点赞 2019-08-01 10:07:19
    经过一个月的Java学习,听说Java中的第一个小型程序好多都做的是计算器,今天我也来做做吧,把这一个月学习的知识简单的综合一下,熟练近期学习的知识点。 我做的计算器如下图: 功能:对实数进行加、减、乘、...

            经过一个月的Java学习,听说Java中的第一个小型程序好多都做的是计算器,今天我也来做做吧,把这一个月学习的知识简单的综合一下,熟练近期学习的知识点。

            我做的计算器如下图:

    功能:对实数进行加、减、乘、除、余操作。

    界面设置:首先设置一个窗体,一个菜单条,三个菜单项(无功能),三个标签(作为显示数据的地方,第一个标签作为提示作用,第二个标签作为输入数据作用,第三个标签显示结果作用),20个按钮(循环进行添加),两个面板(把三个标签添加到第一个面板里,把20个按钮添加到第二个面板里,用网格布局,这样做不易位置错乱),再把两个面板添加到窗体中就OK了。

    下面是完整代码,在一个类中,注释非常详细。

    package day7_29;
    
    import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Container;
    import java.awt.Dimension;
    import java.awt.Font;
    import java.awt.GridLayout;
    import java.awt.SystemColor;
    import java.awt.Toolkit;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.text.NumberFormat;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JMenu;
    import javax.swing.JMenuBar;
    import javax.swing.JPanel;
    import javax.swing.border.BevelBorder;
    
    public class Caculate {
    	// 对计算器整体框架的建立
    	private JFrame frame = new JFrame("&斌的图形界面计算器&");// 创建窗体对象
    	private JMenuBar menubar = new JMenuBar(); // 创建菜单条对象
    	private JMenu menu1 = new JMenu("查看"); // 创建菜单对象1
    	private JMenu menu2 = new JMenu("编辑"); // 创建菜单对象2
    	private JMenu menu3 = new JMenu("帮助"); // 创建菜单对象3
    	private JLabel label_hint = new JLabel(); // 创建提示信息标签
    	private JLabel label_input = new JLabel(); // 创建输入信息标签
    	private JLabel label_result = new JLabel(); // 创建输出结果标签3
    	private JPanel panel_show = new JPanel(); // 创建显示面板
    	private JPanel panel_operation = new JPanel(); // 创建按键面板
    
    	private String[] str = { "AC", "←", "(-)", "+", "7", "8", "9", "-", "4", "5", "6", "*", "1", "2", "3", "÷", "%",
    			"0", ".", "=" }; // 计算器的按键从上到下、从左到右顺序表示
    	private JButton[] button = new JButton[str.length]; // 创建计算器的按键对象
    	private double result = 0; // 存储计算结果
    	private boolean flag = true; //
    	private boolean find = true; 
    	private String command = "=";
    
    	public static void main(String[] args) {// 主方法
    		new Caculate().initJFrame();
    	}
    
    	// 对界面进行初始化
    	public void initJFrame() {
    		Container con = frame.getContentPane();
    		con.setBackground(Color.green); // 设置颜色
    		// 设置窗体位置及大小(下面一段代码实现居中)
    		frame.setSize(600, 550); 
    		//方法一
    //		Toolkit toolKit = Toolkit.getDefaultToolkit(); // 获取默认工具包
    //		Dimension dimension = toolKit.getScreenSize(); // 获取屏幕对象
    //		double screenWidth = dimension.getWidth(); // 获取屏幕的宽和高
    //		double screenHight = dimension.getHeight();
    //		int jframeWidth = frame.getWidth(); // 获取窗体的宽和高
    //		int jframeHight = frame.getHeight();
    //		int x = (int) ((screenWidth - jframeWidth) / 2); // 得到窗体真正位置
    //		int y = (int) ((screenHight - jframeHight) / 2);
    //		frame.setLocation(x, y); // 设置窗体居中
    		//方法二
    		frame.setLocationRelativeTo(null);//设置窗口相对于指定组件的位置。如果组件当前未显示,或者 c 为 null,则此窗口将置于屏幕的中央。
    
    		menubar.add(menu1);// 把菜单添加到菜单条中
    		menubar.add(menu2);
    		menubar.add(menu3);
    		menu1.setFont(new Font("", Font.BOLD, 20));// 设置菜单字体样式
    		menu2.setFont(new Font("", Font.BOLD, 20));
    		menu3.setFont(new Font("", Font.BOLD, 20));
    		frame.setJMenuBar(menubar);// 把菜单添加到菜单条中
    
    		label_hint.setText(" "); // 标签内容初始化为空
    		label_hint.setHorizontalAlignment(JLabel.RIGHT); // 设置图标和文本的水平对齐方式为右对齐
    		label_hint.setFont(new Font("宋体", Font.BOLD, 30));// 设置此标签的字体。
    		label_hint.setForeground(Color.RED); // 设置字体颜色为红色
    
    		label_input.setText(" "); // 标签内容初始化为空
    		label_input.setHorizontalAlignment(JLabel.RIGHT); // 设置图标和文本的水平对齐方式为右对齐
    		label_input.setFont(new Font("宋体", Font.BOLD, 30));// 设置此标签的字体。
    		label_input.setForeground(Color.BLACK); // 设置字体颜色为黑色
    
    		label_result.setText("0");// 标签内容初始化内容为0
    		label_result.setHorizontalAlignment(JLabel.RIGHT); // 设置图标和文本的水平对齐方式为右对齐
    		label_result.setFont(new Font("宋体", Font.BOLD, 35));// 设置此标签的字体。
    		label_result.setForeground(Color.BLUE); // 设置字体颜色为蓝色
    
    		panel_show.setLayout(new BorderLayout()); // 设置为边界布局
    		panel_show.add(label_hint, BorderLayout.NORTH); // 把错误提示标签放在上面
    		panel_show.add(label_input, BorderLayout.CENTER);// 把输入信息标签放在中间
    		panel_show.add(label_result, BorderLayout.SOUTH);// 把输出结果标签放在下面
    		// 创建具有指定类型、高亮显示和阴影颜色的斜面边框。
    		panel_show.setBorder(
    				new BevelBorder(BevelBorder.RAISED, new Color(160, 170, 180), null, SystemColor.scrollbar, null));
    		panel_operation.setLayout(new GridLayout(5, 4, 8, 8));// 按键设置为网格布局5行5列间距为8
    		// 创建具有指定类型、高亮显示和阴影颜色的斜面边框。凸出斜面类型。为滚动条提供的背景色。
    		panel_operation.setBorder(
    				new BevelBorder(BevelBorder.RAISED, new Color(160, 170, 180), null, SystemColor.scrollbar, null));
    		// 添加按钮
    		for (int i = 0; i < str.length; i++) {
    			button[i] = new JButton(str[i]);
    			button[i].setFont(new Font("宋体", Font.BOLD, 30)); // 设置按钮中字体样式
    			if (str[i].equals("+") || str[i].equals("-") || str[i].equals("*") || str[i].equals("÷")
    					|| str[i].equals("%") || str[i].equals("=")) {
    				button[i].addActionListener(new OperationListener());// 给按钮+,-,*,/,%,=注册监听器
    			} else {
    				button[i].addActionListener(new DataListener());//给按钮AC,←,(-),.,0,1,2,3,4,5,6,7,8,9注册监听器
    			}
    
    			panel_operation.add(button[i]);// 把每个按钮分别添加到面板上
    		}
    		// 把面板添加到窗体框架里
    		frame.add(panel_operation, BorderLayout.CENTER);
    		frame.add(panel_show, BorderLayout.NORTH);
    		//frame.setResizable(false); // 设置窗体不能改变大小
    		frame.setVisible(true); // 设置窗体可见
    		frame.setDefaultCloseOperation(frame.DISPOSE_ON_CLOSE);// 释放窗口
    	}
    	
    	public class DataListener implements ActionListener {
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			String str = e.getActionCommand();//返回与此动作相关的命令字符串。
    			if (Caculate.this.flag == true) {//当想输入新的数字时,清空输入显示标签
    				label_input.setText(" ");
    				Caculate.this.flag = false;
    
    			}
    			if (str.equals("(-)")) {//当点击(-)时
    				if (label_input.getText().indexOf("(-)") == -1) {//如果此时显示框里还没出现(-)时
    					label_input.setText(str);
    				}
    			}
    			if (!str.equals("(-)")) {//当命令不是(-)时
    				if (str.equals("AC")) { //点击清零键时
    					clear();
    				} else if (str.equals("←")) { //点击返回键时
    					getBack();
    				} else if (str.equals(".")) { // 点击小数点时,小数点只能出现一次,不能在首位
    					if (label_input.getText().indexOf(".") == -1 && !label_input.getText().equals(" ")) {
    						label_input.setText(label_input.getText() + str);
    					} else {
    						//clear();
    						label_input.setText(label_input.getText() + str);
    						label_hint.setText("小数点不合法,请重新输入");
    					}
    				} else { //点击0,1,2,3,4,5,6,7,8,9时显示原数
    					label_input.setText(label_input.getText() + str);
    				}
    			}
    		}
    	}
    
    	// 返回上一级
    	public void getBack() {
    		if (label_input.getText().length() <= 1) { //长度小于等于1时清空显示框
    			clear();
    		} else {
    			String str = "";
    			if (label_input.getText().length() == 3) { //处理(-)问题,我把(-)看成算一个字符,要返回就整体返回
    				String str1 = label_input.getText().substring(label_input.getText().length() - 3);
    				if (str1.equals("(-)")) {
    					str = " ";
    				} else {
    					str = label_input.getText().substring(0, label_input.getText().length() - 1);
    				}
    			} else { //长度大于3时正常返回上一级
    				str = label_input.getText().substring(0, label_input.getText().length() - 1);
    			}
    			label_input.setText(str); //设置输入显示框为str
    		}
    		label_hint.setText(" "); //清空提示显示框
    	}
    
    	// 清屏
    	public void clear() {
    		label_hint.setText(" ");
    		label_input.setText(" ");
    		label_result.setText("0");
    		this.result = 0;
    		Caculate.this.flag = true; //恢复初始化标记
    		Caculate.this.find = true; //恢复初始化标记
    	}
    
    	public class OperationListener implements ActionListener {
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			String str = e.getActionCommand(); // 返回与此动作相关的命令字符串
    			if (Caculate.this.flag == false) { //当第一次点击+,-,*,、,%,=时
    				if (label_input.getText().contains("(-)")) { //把(-)处理为-,然后在进行数据操作
    					label_input.setText(label_input.getText().replaceAll("\\(-\\)", "-"));
    				}
    
    				caculate(Double.parseDouble(label_input.getText())); //计算
    				Caculate.this.flag = true; //把flag标记处理点击多次操作运算符和输入下一个数的情况
    				Caculate.this.command = str; //供下一次数据运算操作命令
    			} else { //多次点击+,-,*,/,%,=时
    				Caculate.this.command = str;
    				if (str == "%" && Caculate.this.find == true) { //处理刚开始输入显示框为空时对0取余的情况
    					Caculate.this.find = false; //把find标记
    					Caculate.this.command = "=";
    				}
    			}
    		}
    	}
    	//进行数据运算
    	public void caculate(double ans) {
    		switch (this.command) {
    		case "+": //计算数据的和
    			this.result += ans;
    			break;
    		case "-": //计算数据的差
    			this.result -= ans;
    			break;
    		case "*": //计算数据的乘积
    			this.result *= ans;
    			break;
    		case "÷": //计算数据的商
    			if (ans == 0) {
    				label_hint.setText("提示:除数不能为0");
    				return;
    			}
    			this.result /= ans;
    			break;
    		case "%": //计算数据的余
    			double s1 = this.result;
    			int d1 = (int) s1;
    			double s2 = ans;
    			int d2 = (int) s2;
    			if (d1 == this.result && d2 == ans && d2 != 0) {
    				this.result %= ans;
    			} else {
    				if (d1 != s1) {
    					label_hint.setText("提示:余数的分子必须为整数");
    				}
    				else if (d2 != s2) {
    					label_hint.setText("提示:余数的分母必须为整数");
    				}
    				else if (s2 == 0) {
    					label_hint.setText("提示:余数的分母不能为0");
    				}
    			}
    			break;
    		case "=": //计算结果
    			this.result = ans;
    			break;
    		}
    		label_result.setText(" " + format(this.result)); //显示计算结果
    	}
    	//计算结果格式处理
    	public String format(double d) {
    		String formatString = "";
    		NumberFormat nf = NumberFormat.getInstance(); // 放回当前默认语言环境的通用数字格式
    		formatString = nf.format(d); // 格式规范化
    		return formatString; //返回格式化后的数据
    	}
    }
    

     

    展开全文
  • 图形界面计算器

    2020-03-12 17:50:40
    图形界面计算器 UI组件创建和初始化 一个计算器界面至少包括窗口,按钮和显示文本框 1. 窗口的创建 创建一个窗口需要使用Frame类。我们创建一个JFrame实例,并调用实例的方法进行组件的添加(与之前编写一个JFrame...

    图形界面计算器

    UI组件创建和初始化

    一个计算器界面至少包括窗口,按钮和显示文本框

    1. 窗口的创建

    创建一个窗口需要使用Frame类。我们创建一个JFrame实例,并调用实例的方法进行组件的添加(与之前编写一个JFrame子类的效果是相同的)

    // 创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。
    JFrame frame = new JFrame("Calculator");
    
    // 设置主窗口出现在屏幕上的位置
    frame.setLocation(300, 200);
    
    // 设置窗体不能调大小
    frame.setResizable(false); 
    

    这里先不设置窗口的大小,待将所有组件添加到窗体上之后,调用pack()方法,让窗体自己调整大小

    2. 所需的组件

    • 显示计算结果

      // 创建一个 JTextField 对象并初始化。 JTextField 是用于显示操作和计算结果的文本框。
      // 参数 20 表明可以显示 20 列的文本内容
      JTextField result_TextField = new JTextField(result, 20);
      

      这里的result是一个String对象,用来记录计算的结果

    • 清除按钮

      // 清除按钮
      JButton clear_Button = new JButton("Clear");
      
    • 数字按钮

      // 数字键0到9
      JButton button0 = new JButton("0");
      JButton button1 = new JButton("1");
      JButton button2 = new JButton("2");
      JButton button3 = new JButton("3");
      JButton button4 = new JButton("4");
      JButton button5 = new JButton("5");
      JButton button6 = new JButton("6");
      JButton button7 = new JButton("7");
      JButton button8 = new JButton("8");
      JButton button9 = new JButton("9");
      
    • 操作符按钮

      JButton button_add = new JButton("+");
      JButton button_sub = new JButton("-");
      JButton button_mul = new JButton("*");
      JButton button_div = new JButton("/");
      
    • 等于按钮(按下后进行计算)

      JButton button_equal = new JButton("=");
      

    在窗体中添加UI组件

    1. 面板

    这个计算器有两个JPanel

    image-20200312115428522

    JPanel是一般轻量级容器。可以将其理解为一个盛放其他UI组件的篮子。

    JPanel位于javax.swing包中,为面板容器,可以加入到JFrame中,它自身是个容器,也可以把其他component(组件)加入到JPanel中,例如JButton,JTextArea,JTextField等

    在这个项目中,两个JPanel分别 对应这个计算器按键除“Clear”键外的其他键,另外一个面板则是输出栏跟“Clear”键,如下图

    image-20200312115853015

    2.放置数字键等的面板

    对于面板1,首先初始化一个面板对象pan

    // 创建一个 Jpanel 对象并初始化
    JPanel pan = new JPanel();
    

    设置pan的布局为网格布局GridLayout,我们使用的GridLayout传入了四个参数,含义分别为创建一个4行,4列的网格,每个网格宽度为5,高度为5

    // 设置该容器的布局为四行四列,边距为5像素
    pan.setLayout(new GridLayout(4, 4, 5, 5));
    

    如下图,当我们对pan进行add操作时,组件会按照1,2,3,的顺序进行填充

    image-20200312120251762

    对比之前的效果图,我们应该按照下面的顺序进行add操作

    // 将用于计算的按钮添加到容器内
    pan.add(button7);
    pan.add(button8);
    pan.add(button9);
    pan.add(button_chu);
    pan.add(button4);
    pan.add(button5);
    pan.add(button6);
    pan.add(button_cheng);
    pan.add(button1);
    pan.add(button2);
    pan.add(button3);
    pan.add(button_jian);
    pan.add(button0);
    pan.add(button_Dian);
    pan.add(button_dy);
    pan.add(button_jia);
    

    为了更美观,可以为pan对象设置边距:

    // 设置 pan 对象的边距
    pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    

    3.放置清除框等的面板

    对于面板2,先初始化一个面板对象pan2

    // 按照同样的方式设置第二个JPanel
    JPanel pan2 = new JPanel();
    

    设置它的布局为边界布局,边界布局管理器把容器的布局分为五个位置:
    CENTER,EAST,WEST,NORTH,SOUTH。

    image-20200312120747878
    pan2.setLayout(new BorderLayout());
    pan2.add(result_TextField, BorderLayout.WEST);
    pan2.add(clear_Button, BorderLayout.EAST);
    

    这里只设置了WEST和EAST,其他部分没有添加任何东西(没有添加的部分相当于空白)

    4.窗体添加面板1和面板2

    窗体中可以放置JPanel,添加面板1面板2的代码如下:

    frame.getContentPane().setLayout(new BorderLayout());
    frame.getContentPane().add(pan2, BorderLayout.NORTH);
    frame.getContentPane().add(pan, BorderLayout.CENTER);
    

    这里对于frame.getContentPane()(它返回JFrame中默认的JPanel),我们设置布局为BorderLayout

    当我们添加窗体之后:

    frame.pack();
    frame.setVisible(true);
    

    布局结束,下面是计算器的难点:事件处理程序

    响应时间需要使用的变量

    对于计算器而言,涉及到的事件响应逻辑主要有:数字键,加减乘除运算,小数点处理,等于以及清除。

    这里需要定义一些成员变量,方便响应的逻辑实现。

    首先,需要定义存储当前被按下的操作数和操作符,result存储运算的结果

    // 操作数1,为了程序的安全,初值一定设置,这里我们设置为0。
    String str1 = "0"; 
    
    // 操作数2
    String str2 = "0"; 
    
    // 运算符
    String signal = "+"; 
    
    // 运算结果
    String result = "";
    

    接下来还定义了五个状态开关

    // 以下k1至k5为状态开关
    
    // 开关1用于选择输入方向,将要写入str1或str2
    // 为 1 时写入 str1,为 2 时写入 str2
    int k1 = 1;
    
    // 开关 2 用于记录符号键的次数
    // 如果 k2>1 说明进行的是 2+3-9+8 这样的多符号运算
    int k2 = 1;
    
    // 开关3用于标识 str1 是否可以被清 0 
    // 等于 1 时可以,不等于1时不能被清0
    int k3 = 1;
    
    // 开关4用于标识 str2 是否可以被清 0
    // 等于 1 时可以,不等于1时不能被清0
    int k4 = 1;
    
    // 开关5用于控制小数点可否被录入
    // 等于1时可以,不为1时,输入的小数点被丢掉
    int k5 = 1;
    

    这里额外定义了一个JButton变量,用于存储被按下的符号键

    // store的作用类似于寄存器,用于记录是否连续按下符号键
    JButton store; 
    

    vt存储之前输入的运算符

    @SuppressWarnings("rawtypes")
    Vector vt = new Vector(20, 10);
    

    数字键的响应

    后面所有定义的ActionListener都写在构造函数中,即定义为局部内部类

    数字键的响应主要是处理数字存入到对应的变量中(第一个操作数存入str1,第二个操作数存入str2)

    这里我们定义的局部内部类名为Listener,继承ActionListener接口,继承之后,我们需要重写接口定义的actionPerformed方法

    class Listener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
    
        }
    }
    

    通过上面的actionPormed方法的入参ActionEvent e,我们可以获取到事件源

    // 获取事件源,并从事件源中获取输入的数据
    String ss = ((JButton) e.getSource()).getText();
    

    接下来读入存储的符号键,并添加到vt中

    // 读入存储的符号键
    store = (JButton) e.getSource();
    vt.add(store);
    
    • 输入为操作数 1 的一部分时

      我们需要判断操作数 1 是否可以被清零(通过 k3 的值即可判断),如果可以(存储的内容是上一次运算的),则先清空再写入;如果不可以清零(先前已经输入了操作数 1 的一部分,比如输入数字 34,上一次按了 3,这一次读到的是 4),这种情况下需要将输入追加到上一次的输入中

    • 输入为操作数 2 的一部分时

      这部分的逻辑与操作数 1 是完全相同的。唯一不同的是,操作数变为了 str2(即操作数 2)。

    小数点的响应

    小数点响应也是定义为局部内部类,与数字键的响应是相同的

    1. 首先是获取响应源,并添加到vt中
    2. 输入小数点需要在k5为1的情况下才输入,否则输入的小数点被丢掉
    3. 对于输入的小数点,可能是str1的,也可能是str2的,这部分的逻辑与数字的逻辑是相似的
    4. 为了防止输入小数点之后再次输入小数点,需要进行k5 = k5 + 1的操作

    运算符号的响应

    运算符的响应定义为局部内部类,与数字键的响应类是相同的

    运算符的处理,需要分类讨论,k2变量为1时,说明这是进行普通运算操作(比如2 + 3,先输入2,再输入+,然后输入3);如果k2 > 1说明进行的是2+3-9+8这样的多符号运算,即上一次的运算结果存储在str1中,符号输入之后要输入的数字时str2

    • 普通运算操作

      当 k2 为 1 时,我们只需要将 k1 开关设置为 2,即接下来输入的数字是 str2。第二个操作数不能以 . 开头,因此将 k5 置为 1。k2 自增 1,如果等会儿还有符号输入,则对应到第二种情况中。

    • 连续运算

      else 部分对应这种情况。首先读入上一次的输入(vt 中的第 vt.size()-2 个元素),如果这个输入不是 +-*/ 中的一个,说明是要进行连续运算。

    ​ 从逻辑上还可以防止连续输入运算符的情况。

    ​ 此时调用 calc() 进行运算(这个方法是我们自己定义的运算,在 3.9 中实 现 ),将结果存入到 str1 中。

    在这个符号之后就是输入操作数 2,因此 k1 置为 2;在输入数字之前不能输入小数点,因此 k5 置为 1;对于连续运算,str2 应该先被清空再输入,因此 k4 置为 1。

    singal 存储此次输入的符号。

    最后 k2 加 1,增加已经输入的符号的次数。

    等于的响应

    当等于键按下之后,调用 calc() 进行运算,还原开关的值即可。

    最后做了一个操作 str1 = result;,是为了应对 7+5=12 +5=17 这种情况。上一次运算的结果在下一个运算中默认作为第一个操作数。

    计算逻辑的实现

    计算的逻辑要针对输入的不同运算符来对操作数进行运算,同时还要考虑到除以 0 这种不合理的算法容错。

    对于计算逻辑,我们写在一个名为 calc() 的成员函数中。

    首先要将操作数转为 double 类型,代码中定义了 a2 和 b2 用来存储操作数 1 和 操作数 2。

    清除的响应

    清除的逻辑非常简单,将所有变量的值清空或者置为初始值。

    注册监听器

    注册各个监听器,即绑定事件响应逻辑到各个 UI 组件上:

    // 监听等于键
    Listener_dy jt_dy = new Listener_dy();
    button_dy.addActionListener(jt_dy);
    

    除了绑定 UI 的响应时间之外,我们还给窗口绑定了一个事件。

    // 窗体关闭事件的响应程序
    frame.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    });
    

    实现代码

    package calculator;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    import java.util.Vector;
    import java.math.BigDecimal;
    
    public class Calculator{
    	
    	//对于计算器而言,涉及到的事件相应逻辑主要有:
    	//数字键,加减乘除运算,小数点的处理,等于以及清除
    	
    	//响应事件所需要的变量
    	String str1 = "0";
    	String str2 = "0";
    	String signal = "+";
    	String result = "";
    	
    	
    	//五个状态开关:
    	
    	//开关1用于选择输入方向,将要写入str1或str2
    	//为1时写入str1,为2时写入str2
    	int k1 = 1;
    	
    	//开关2用于记录符号键的次数
    	//如果k2>1,说明进行的是2+3-9+8这样的多符号运算
    	int k2 = 1;
    	
    	//开关3用于标识str1是否可以被清0
    	//等于1时可以,不等于1时不能被清零
    	int k3 = 1;
    	
    	//开关4用于标识str2是否可以被清0
    	//等于1时可以,不等于1时不能被清零
    	int k4 = 1;
    	
    	//开关5用于控制小数点可否被录用
    	//等于1时可以,不为1时,输入的小数点被丢掉
    	int k5 = 1;
    	
    	//store的作用类似寄存器,用于计算是否连续按下符号键
    	JButton store;
    	
    	@SuppressWarnings("rawtypes")
    	Vector vt = new Vector(20,10);
    	
    	JFrame frame = new JFrame("Calculator");
    	JTextField result_TextField = new JTextField(result, 20);
    	// 创建一个 JTextField 对象并初始化。 JTextField 是用于显示操作和计算结果的文本框。
    	// 参数 20 表明可以显示 20 列的文本内容
    	JButton clear_Button = new JButton("Clear");
    	//声明各个UI组件对象并初始化
    	JButton button0 = new JButton("0");
    	JButton button1 = new JButton("1");
    	JButton button2 = new JButton("2");
    	JButton button3 = new JButton("3");
    	JButton button4 = new JButton("4");
    	JButton button5 = new JButton("5");
    	JButton button6 = new JButton("6");
    	JButton button7 = new JButton("7");
    	JButton button8 = new JButton("8");
    	JButton button9 = new JButton("9");
    	JButton button_point = new JButton(".");
    	JButton button_add = new JButton("+");
    	JButton button_sub = new JButton("-");
    	JButton button_mul = new JButton("*");
    	JButton button_div = new JButton("/");
    	JButton button_equal = new JButton("=");
    	
    
    	
    	
    		
    	 
    	
    	public Calculator() {
    		//为按钮设置等效键,即可通过对应的键盘按键来代替点击它
    		button0.setMnemonic(KeyEvent.VK_0);
    		
    		//设置文本框为右对齐,使输入和结果都靠右显示
    		result_TextField.setHorizontalAlignment(JTextField.RIGHT);;
    		
    		
    		
    		//2.放置数字键等的面板,将UI组件添加进容器中
    		
    		JPanel pan = new JPanel();
    		// 创建一个 Jpanel 对象并初始化
    		pan.setLayout(new GridLayout(4, 4, 5, 5));
    		// 设置该容器的布局为四行四列,边距为5像素,设置 pan 的布局为网格布局 GridLayout
    		//含义分别为创建一个 4 行(第一个参数)、
    		//4 列(第二个参数)的网格,每个网格宽度为 5(第三个参数)、高度为 5 (第四个参数)。
    		
    		
    		// 将用于计算的按钮添加到容器内
    		pan.add(button7);
    		pan.add(button8);
    		pan.add(button9);
    		pan.add(button_div);
    		pan.add(button4);
    		pan.add(button5);
    		pan.add(button6);
    		pan.add(button_mul);
    		pan.add(button1);
    		pan.add(button2);
    		pan.add(button3);
    		pan.add(button_sub);
    		pan.add(button0);
    		pan.add(button_point);
    		pan.add(button_equal);
    		pan.add(button_add);
    		
    		
    		pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    		//设置 pan 对象的边距
    		
    		
    		//3.放置清除框等的面板
    		
    		//按照他同样的方式设置第二个JPanel
    		//设置它的布局为边界布局。边界布局管理器把容器的布局分为五个位置,CENTER、EAST、WEST、NORTH、SOUTH。
    		//依次对应为:上北(NORTH)、下南(SOUTH)、左西(WEST)、右东(EAST),中(CENTER)。
    		JPanel pan2 = new JPanel();
    		pan2.setLayout(new BorderLayout());
    		pan2.add(result_TextField,BorderLayout.WEST);
    		pan2.add(clear_Button,BorderLayout.EAST);
    		//这里只设置了WEST和EAST,其他部分没有添加任何东西(没有添加的部分相当于空白)
    		
    		
    		//设置主窗口出现在屏幕上的位置
    		frame.setLocation(300,200);
    		
    		//设置窗体不能调大小
    		frame.setResizable(false);
    		
    		//4.窗体添加面板1和面板2
    		frame.getContentPane().setLayout(new BorderLayout());
    		frame.getContentPane().add(pan2,BorderLayout.NORTH);
    		frame.getContentPane().add(pan,BorderLayout.CENTER);
    		
    		frame.pack();
    		frame.setVisible(true);
    		
    	
    	//事件处理程序
    	//数字键
    	//主要处理数字存入对应的变量中(第一个操作数存入str1,第二个操作数存入str2
    	//定义局部内部类名为Listener,继承ActionListener接口
    	
    		class Listener implements ActionListener{
    
    			@SuppressWarnings("unchecked")
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				//获取事件源,并从事件源中获取输入的数据
    				String ss = ((JButton) e.getSource()).getText();
    			
    			//读入存储的符号键,并添加到vt中
    			store = (JButton) e.getSource();
    			vt.add(store);
    			
    			if(k1 == 1) {
    				
    				//输入是操作数1的一部分
    				//判断操作数1是否可以被清0(通过k3)
    				//如果可以,则先清空再写入;
    				//如果不可以,则将输入添加到上一次的输入中
    				if(k3 == 1) {
    					str1 = "";
    					k5 = 1;//还原开关k5的状态
    				}
    				
    				str1 = str1 + ss;
    				//因为输的是数字,因此后面随时可以用小数点,为防止出错给k5赋值
    				
    				k3 = k3 + 1;//保证操作数1不会被清空
    				
    				result_TextField.setText(str1);//将操作数打印到结果栏
    				
    				
    			}else if(k1 == 2){
    				//输入是操作数2的一部分
    				//逻辑与操作数1完全相同,只是操作数变为了str2
    	            if (k4 == 1) {
    	                str2 = "";
    
    	                // 还原开关k5状态
    	                k5 = 1; 
    	            }
    	            str2 = str2 + ss;
    	            k4 = k4 + 1;
    	            result_TextField.setText(str2);				
    				
    				
    			}
    			
    		}
    		
    	}
    	
    	//运算符号的响应
    	
    	 class Listener_signal implements ActionListener{
    
    		@SuppressWarnings("unchecked")
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			String ss2 = ((JButton) e.getSource()).getText();
    			store = (JButton) e.getSource();
    			vt.add(store);
    			
    			
    			
    			
    			//k2变量为1时,说明是进行普通运算操作(比如2+3,先输入2再输入+再输入3)
    			//如果k2>1说明进行的是2+3-9+8这样的多符号运算,
    			//即上一次的运算结果存储在str1中,符号输入之后要输入的数字时str2
    			
    			
    			//普通运算操作:
    			//当k2为1时。我们只需要将k1开关设置为2,即接下来输入的数字时str2
    			//第二个操作不能以.开头,因此将k5置为1,k2自增1
    			//如果还有符号输入,则对应到第二种情况中
    			if(k2 == 1) {
    				k1 = 2;
    				k5 = 1;
    				signal = ss2;
    				k2 = k2 + 1;
    			}else {
    			//连续运算
    			//首先读入上一次的输入(vt中的第vt.size()-2)个元素
    			//如果这个输入不是+-*/中的任何一个,说明是要进行连续计算
    			//此时调用calc()进行运算,将结果存入到str1中
    			//在这个符号之后就是输入操作数2,因此k1置为2
    			//在输入数字之前不能输入小数点,因此k5置为1
    			//对于连续运算,str2应该先被清空再输入,因此k4置为1
    				
    				int a = vt.size();
    				JButton c = (JButton) vt.get(a - 2);
    				if(!(c.getText().equals("+"))&&!(c.getText().equals("-"))
    						&&(!c.getText().equals("*")&&!(c.getText().equals("/")))){
    					
    					cal();
    					str1 = result;
    					k1 = 2;
    					k5 = 1;
    					k4 = 1;
    					signal = ss2;
    					
    				}
    				
    				k2 = k2 + 1;
    			}
    			
    		}
    		 
    	 }
    	
    	
    	 
    	 //等于的响应
    	 //当等于键按下之后,调用calc()进行运算,还原开关的值即可
    	 
    	 
    	 class Listener_equal implements ActionListener{
    
    		@SuppressWarnings("unchecked")
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			
    			store = (JButton) e.getSource();
    			vt.add(store);
    			cal();
    			
    			k1 = 1;
    			k2 = 1;
    			k3 = 1;
    			k4 = 1;
    			
    			str1 = result;
    			//最后做了一个操作str1 = result,是为了应对7+5=12 +5=17这种情况。
    			//上一次运算的结果在下一个运算中默认作为第一个操作数
    		}
    		 
    	 }
    	 
    	 
    	
    	class Listener_point implements ActionListener{
    
    		@SuppressWarnings("unchecked")
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			// TODO Auto-generated method stub
    			//获取响应源并添加到vt中
    			store = (JButton) e.getSource();
    			vt.add(store);
    			
    			if(k5 == 1) {
    				String ss2 = ((JButton) e.getSource()).getText(); 
    				
    				//对于输入的小数点,可能是str1的,也可能是str2的
    				
    				if(k1 == 1) {
    					
    					if(k3 == 1) {
    						str1 = "";
    						k5 = 1;
    					}
    					str1 = str1 + ss2;
    					k3 = k3 + 1;
    					
    					result_TextField.setText(str1);
    				}else if(k1 == 2){
    					
    					if(k4 == 1) {
    						str2 = "";
    						k5 = 1;
    					}
    					str2 = str2 + ss2;
    					
    					k4 = k4 + 1;
    					
    					result_TextField.setText(str2);
    				}
    			}
    			
    			k5 = k5 + 1;
    		}
    		
    	}
    	
    	
    	
    
    	 
    	 //清除的响应
    	 //即将所有变量的值清空或置为初始值
    	 
    	 class Listener_clear implements ActionListener{
    
    		@SuppressWarnings("unchecked")
    		@Override
    		public void actionPerformed(ActionEvent e) {
    			store = (JButton) e.getSource();
    			vt.add(store);
    			k1 = 1;
    			k2 = 1;
    			k3 = 1;
    			k4 = 1;
    			str1 = "0";
    			str2 = "0";
    			signal = "";
    			result = "";
    			result_TextField.setText(result);
    			vt.clear();
    		}
    		 
    	 }
    	 
    		//注册各个监听器,即绑定时间响应逻辑到各个UI组件上
    	 Listener_equal lis_equ = new Listener_equal();
    	 Listener lis_num = new Listener();
    	 Listener_signal lis_sig = new Listener_signal();
    	 Listener_clear lis_cle = new Listener_clear();
    	 Listener_point lis_poi = new Listener_point();
    	 
    	 button_equal.addActionListener(lis_equ);
    	 button0.addActionListener(lis_num);
    	 button1.addActionListener(lis_num);
    	 button2.addActionListener(lis_num);
    	 button3.addActionListener(lis_num);
    	 button4.addActionListener(lis_num);
    	 button5.addActionListener(lis_num);
    	 button6.addActionListener(lis_num);
    	 button7.addActionListener(lis_num);
    	 button8.addActionListener(lis_num);
    	 button9.addActionListener(lis_num);
    	 button_add.addActionListener(lis_sig);
    	 button_div.addActionListener(lis_sig);
    	 button_mul.addActionListener(lis_sig);
    	 button_sub.addActionListener(lis_sig);
    	 clear_Button.addActionListener(lis_cle);
    	 button_point.addActionListener(lis_poi);
    
    	 
    	 
    
    		 
    	
    		 
    		 //窗体关闭事件的响应程序
    		 frame.addWindowListener(new WindowAdapter() {
    			 public void windowClosing(WindowEvent e) {
    				 System.exit(0);
    			 }
    		});
    	 }
    	 
    
    	
    	//计算逻辑
    	 public void cal() {
    		 double a2; //操作数1
    		 double b2;//操作数2
    		 String c = signal;//运算符
    		 
    		 double result2 = 0;//运算结果
    		 
    		 if(c.equals("")) {
    			 result_TextField.setText("Please input operator");
    			 
    		 }else {
    			 //手动处理小数点问题
    			 if(str1.equals("."))
    				 str1 = "0.0";
    			 if(str2.equals("."))
    				 str2 = "0.0";
    			 
    			 a2 = Double.valueOf(str1).doubleValue();
    			 b2 = Double.valueOf(str2).doubleValue();
    			 
    			 if(c.equals("+")) {
    				 result2 = a2 + b2;
    			 }
    			 if(c.equals("-")) {
    				 result2 = a2 - b2;
    			 }
    			 if(c.equals("*")) {
    				 BigDecimal m1 = new BigDecimal(Double.toString(a2));
    				 BigDecimal m2 = new BigDecimal(Double.toString(b2));
    				 result2 = m1.multiply(m2).doubleValue();
    			 }
    			 if(c.equals("/")) {
    				 if(b2 == 0) result2 = 0;
    				 else result2 = a2 / b2;
    			  
    			 }
    			 
    			 result = ((new Double(result2)).toString());
    			 result_TextField.setText(result);
    		 }
    		 
    	 }
    	 
    	
    	@SuppressWarnings("unused")
    	public static void main(String[] args) {
    		
    		try {
    			UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
    		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
    				| UnsupportedLookAndFeelException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		Calculator cal = new Calculator();
    		
    	}
    
    }
    
    
    展开全文
  • 学习图形界面的设计,利用 MFC 应用程序(Java swing 或 QT 框架,或 C#)创 建基于对话框的应用程序,添加按钮、编辑框等控件。 能通过设计的按钮控件输入并实现简单算术运算,要求表达式在编辑框中显示, 能将...
  • JAVA编写登录界面计算器界面

    千次阅读 2018-12-05 09:13:19
     JFrame 窗体容器组件类 顶级容器(要开发一个图形界面,首先必须要先有一个顶级容器)    2.元素组件类:组件上添加文字、图片或者接收用户输入的就是元素组件。  JLabel 标签元素组件类 显示文字或图片信息...
  • Java语言编写计算器

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

    千次阅读 2019-12-12 19:26:30
    利用java实现一个计算器能够实现加减乘除,并设置优先级(不带括号) package 计算器; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.text....
  • 写了半天才写出一个图形界面 不知道怎样实现键盘录入身高、体重,点击评估按钮得到BMI和结果(结果输出的是胖,瘦,正常三种情况) 代码、界面如下: ![图片说明]...
  • 使用JAVA图形用户界面写出来的PC版计算器,只有一个文件,代码简单,功能该有的都有
  • java用GUI图形界面写的计算器源码.可以直接运行。
  • 本次呢先写一个没有事件的、纯图形界面计算器。等自己研究透了结合事件处理后,再在本文章补充上。 需求:有数字1-9按键,有左右括号,有加减乘除,有退格、归零和计算键 大概样子是这样的 这里很容易发现,我...
  • 一个简单的计算器,老师布置的作业。 用的swing和awt,bug还是有的,想起来了,发上来,自己留着收藏。 /** * Created by YunFeng on 2014/12/6 0009. * Student Number: * Teacher:Yongfeng Huang * ...
  • 该文件是由我自己用Java写的一个图形用户界面计算器源码,实现了基本的计算功能,需要的可以自行下载解压,直接导入到eclipse中即可。如果有什么问题可以看我的博客,或者在我的博客下留言均可。希望对大家有帮助...
  • 界面效果:/****/package calculator;import java.awt.BorderLayout;import java.awt.EventQueue;import javax.swing.JFrame;import javax.swing.JPanel;import javax.swing.border.EmptyBorder;import java.awt....
  • java编写计算器

    2018-01-02 08:35:52
    一个图形界面(GUI)的计算器应用程序,可以完成加法、减法、乘法、除法和取余运算。且有小数点、正负号、求倒数、退格和清零,sin,cos,平方,开平方功能
  • 这只是一个小程序,不过你可以在此基础上扩展功能!
  • java编写简单计算器

    2015-11-22 09:52:39
    加减乘除开方 三角函数等功能,图形化用户界面,类似windows上的简单计算器
  • Java, Swing实现的简单的表达式计算器 带简单的图形界面 可以参考下~ 也可以看看这里:http://blog.csdn.net/he_qiao/article/details/17335411
  • java eclipse 编写的简单计算器界面编程)
  • package J_9_3_01;...import java.awt.*; import java.awt.event.*; import javax.swing.*;public class CalculatorTest { public static void main(String[] args) { EventQueue.invokeLater(() ->
  • Java实现图形计算器

    千次阅读 2019-07-30 21:10:00
    package java计算器; import java.awt.*; import java.awt.event.Act...
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录前言一、知识点介绍:二、代码实现:完成此项目,...本项目主要用到了java swing图形界面编程的知识。比如java swing的各种组件; 还有事

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,075
精华内容 1,230
关键字:

编写java图形界面计算器

java 订阅