精华内容
下载资源
问答
  • Java图形界面简单计算器
    2021-02-12 21:51:57

    展开全部

    示例代码如下,请参考:package test.com.test;

    import java.awt.*;

    import java.awt.event.*;

    import javax.swing.*;

    public class Cal {

    TextField tf = new TextField(40);       //显示文本框

    StringBuffer s1 = new StringBuffer();   //记录运算数字,以及保留结果

    StringBuffer s2 = new StringBuffer();   //记录运算数字,保留上一e5a48de588b662616964757a686964616f31333363393731个输入的数字或运算结果

    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 Cal().init();

    }

    }

    更多相关内容
  • java图形化界面计算器

    2020-11-22 11:00:00
    思路 : 设置三个全局变量, firstNumber,secondNumber,opr 前两个近视操作数,opr是操作符 如果按 + - * / 等操作符按钮的话,将 opr 赋值给 这些 按钮 然后给 = 加一个监听 用equals方法判断操作符
  • JAVA图形化界面计算器

    万次阅读 多人点赞 2018-11-19 19:38:56
    我是一名在校大学生,这学期刚刚开JAVA课,老师上周留作业让做个计算器,最近一直在搞Python,今天终于抽出一些时间来写这篇博客,下面是我做的计算器 界面非常简单,功能也非常简单,只有简单的加减乘除,回退...

    优秀的代码是它自己最好的文档。当你考虑要添加一个注释时,问问自己,“如何能改进这段代码,以让它不需要注释

    我是一名在校大学生,这学期刚刚开JAVA课,老师上周留作业让做个计算器,最近一直在搞Python,今天终于抽出一些时间来写这篇博客,下面是我做的计算器

    界面非常简单,功能也非常简单,只有简单的加减乘除,回退清零

    所谓三思而coding,写代码之前一定要多思考,经过思考之后你的代码bug会少一些,可以提高你的工作效率

    这个计算器很简单,没什么复杂的东西,主要就是你先把界面写好,然后把上面的空间加上监听

    你需要思考的就是这个计算逻辑,因为这里没有括号所以不涉及运算优先级的问题

    我一般写逻辑的时候都会把用户操作理想化,然后这样可以快速想明白一条逻辑,然后再考虑异常情况

    理想情况便是用户点击一个数字,然后点击运算符号,然后点击另一个运算数字,最后点击等号显示结果

    对于这种情况呢,我们可以在用户输入完第一个运算数的时候用一个变量把该数保存下来,然后用另一个变量保存运算符号,等用户点击等号的时候进行运算并显示在输入框内

    但作为一个开发者你要知道用户并不总是理想操作,他有时候也会连续点加号和数字很多次,这样就是一个连续的运算了,但我们无法保存这么多数据,怎么办呢?

    你可以把运算前移一个阶段,也就是说用户点击运算符号时就进行运算,把单步运算和连续运算分开来,单步运算只保存运算符号运算等用户点击等号再进行,连续运算时点击运算符号就进行运算,然后保存运算符号。这两部分你可以用一个布尔值进行开关操作

    那还有一些问题呢,比如说用户上来就点击运算符,被除数为0等等异常情况,我们可以采取初始值或者提示,判断等等小操作解决它们

    理清楚思路我们就准备开始写代码了,首先写界面,首先这里面控件一共就两种,一种文字框一种按钮,都是基础控件就不讲了,我们来看看使用什么布局好,常用的基础布局管理器:绝对布局不考虑,流布局,边界布局,网格布局

    嘿,你可能觉得网格布局管理器不错,但是想要实现这个界面还是较为复杂,给你介绍一款非常好用的布局GridBagLayout

     Java中的布局管理器应用了策略者模式,为不同类型的组件布局提供了很好的模型。而其中的GridBagLayout被认为是所有布局管理器中最强大的,因为它十分灵活,GridBagLayout类的对象维持一个动态的矩形单元网格,然后我们可以把组件放进一个或多个矩形单元网格,组件大就多放几个,组件小就少放几个。而每个组件,要占几个网格单元,每个组件要占领的位置在哪等等,都是要用GridBagConstraints类的对象来设置。 

    比如说我的布局我把它分为7行4列,第一行被文本框单独占有,宽度为4高度为1,下面的Back按钮和清零按钮各占宽度为2,高度为1,你加入GriBagLayout内的所有控件都需要GridBagConstraints类对象来设置位置宽高等属性

         * @param gridx     The initial gridx value.
         * @param gridy     The initial gridy value.
         * @param gridwidth The initial gridwidth value.
         * @param gridheight        The initial gridheight value.
         * @param weightx   The initial weightx value.
         * @param weighty   The initial weighty value.
         * @param anchor    The initial anchor value.
         * @param fill      The initial fill value.
         * @param insets    The initial insets value.
         * @param ipadx     The initial ipadx value.
         * @param ipady     The initial ipady value.

    这是GridBagConstraints类可设置的属性,它有两个构造方法,一种是无参构造方法,一种是指定所有参数的构造方法(吐槽:为啥没有只传位置和宽高的)

    public GridBagConstraints ()
    public GridBagConstraints(int gridx, int gridy,
                                  int gridwidth, int gridheight,
                                  double weightx, double weighty,
                                  int anchor, int fill,
                                  Insets insets, int ipadx, int ipady)

    如果你使用无参的构造方法的话你创建出来的对象属性是这样的

            gridx = -1;
            gridy = -1;
            gridwidth = 1;
            gridheight = 1;
    
            weightx = 0;
            weighty = 0;
            anchor = CENTER;
            fill = 0;
    
            insets = new Insets(0, 0, 0, 0);
            ipadx = 0;
            ipady = 0;

    现在来看一看这些参数都代表什么,grodx和gridy控制的是控件的位置,两者的值应为控件左上角的坐标,java中的坐标体系是这样的

    画图水平也就这样了,凑合看吧 ,gridwidth和gridheight分别代表控件的宽高,也就是说占几个小格

    weightx和weighty的作用和名字一样,控制各自方向的空间分布权重的

    anchor指的是对齐方式,有很多方式可以选择

    
         * The absolute values are:
         * <code>CENTER</code>, <code>NORTH</code>, <code>NORTHEAST</code>,
         * <code>EAST</code>, <code>SOUTHEAST</code>, <code>SOUTH</code>,
         * <code>SOUTHWEST</code>, <code>WEST</code>, and <code>NORTHWEST</code>.
         * The orientation relative values are: <code>PAGE_START</code>,
         * <code>PAGE_END</code>,
         * <code>LINE_START</code>, <code>LINE_END</code>,
         * <code>FIRST_LINE_START</code>, <code>FIRST_LINE_END</code>,
         * <code>LAST_LINE_START</code> and <code>LAST_LINE_END</code>.  The
         * baseline relative values are:
         * <code>BASELINE</code>, <code>BASELINE_LEADING</code>,
         * <code>BASELINE_TRAILING</code>,
         * <code>ABOVE_BASELINE</code>, <code>ABOVE_BASELINE_LEADING</code>,
         * <code>ABOVE_BASELINE_TRAILING</code>,
         * <code>BELOW_BASELINE</code>, <code>BELOW_BASELINE_LEADING</code>,
         * and <code>BELOW_BASELINE_TRAILING</code>.

    默认是CENTER

    fill参数控制的是填充方式 ,默认是NONE,可选择:

    横向填充   HORIZONTAL

    竖向填充   VERTICAL

    双向填充  BOTH

    insets属性控制的是外边距,就是控件和控件之间的距离,使用Insets类对象,传入的顺序是:上左下右

    ipadx和ipady控制的是内边距

    在设置完gridBagConstraints类对象之后我们需要使用下面这句代码将它设置到控件上

    gridBagLayout.setConstraints(button, gridBagConstraints);

    做完这些差不多你的界面就搭好了,你可以对它进行一些小修饰,比如背景颜色,字体颜色,点击时变化等等

    现在只要把界面和逻辑一组合就好了

    import java.awt.Color;
    import java.awt.Container;
    import java.awt.Font;
    import java.awt.GridBagConstraints;
    import java.awt.GridBagLayout;
    import java.awt.Insets;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import javax.swing.*;
    
    public class Calculator extends JFrame {
        private Container container = this.getContentPane();
        private GridBagLayout gridBagLayout = new GridBagLayout();
        private GridBagConstraints gridBagConstraints= new GridBagConstraints();
        private JTextField displayField;
        private String lastCommand="=";
        private double result=0.0d;
        private boolean start=true;
    
        public Calculator() {
            super("JAVA图形化界面计算器");
            container.setLayout(gridBagLayout);
            initDisplayArea();
            initButtons();
            initFrame();
        }
    
        private void initFrame() {
            setSize(900, 900);
            setVisible(true);
            setResizable(false);
            setForeground(Color.MAGENTA);
            setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        }
    
        private void initButtons() {
            ActionListener insert = new Calculator.InsertAction();
            ActionListener command = new Calculator.CommandAction();
            addButton("Back", 0, 1, 2, 1, insert);
            addButton("清零", 2, 1, 2, 1, insert);
            addButton("7", 0, 2, 1, 1, insert);
            addButton("8", 1, 2, 1, 1, insert);
            addButton("9", 2, 2, 1, 1, insert);
            addButton("+", 3, 2, 1, 1, command);
            addButton("4", 0, 3, 1, 1, insert);
            addButton("5", 1, 3, 1, 1, insert);
            addButton("6", 2, 3, 1, 1, insert);
            addButton("-", 3, 3, 1, 1, command);
            addButton("1", 0, 4, 1, 1, insert);
            addButton("2", 1, 4, 1, 1, insert);
            addButton("3", 2, 4, 1, 1, insert);
            addButton("*", 3, 4, 1, 1, command);
            addButton("0", 0, 5, 1, 1, insert);
            addButton("-", 1, 5, 1, 1, insert);
            addButton(".", 2, 5, 1, 1, insert);
            addButton("/", 3, 5, 1, 1, command);
            addButton("=", 0, 6, 4, 1, command);
        }
    
        private void initDisplayArea() {
            displayField = new JTextField(20);
            displayField.setHorizontalAlignment(4);
            displayField.setBackground(Color.gray);
            displayField.setDisabledTextColor(Color.MAGENTA);
            displayField.setEnabled(false);
            displayField.setFont(new Font("宋体", Font.BOLD, 50));
            gridBagConstraints.gridx = 0;
            gridBagConstraints.gridy = 0;
            gridBagConstraints.gridwidth = 4;
            gridBagConstraints.gridheight = 1;
            gridBagConstraints.fill = 1;
            gridBagConstraints.weightx = 1;
            gridBagConstraints.weighty = 1;
            gridBagLayout.setConstraints(displayField, gridBagConstraints);
            container.add(displayField);
        }
    
        private void addButton(String label, int column, int row, int with, int height, ActionListener listener) {
            JButton button = new JButton(label);
            button.setForeground(Color.MAGENTA);
            button.setFont(new Font("楷体", Font.BOLD, 36));
            button.addActionListener(listener);
            gridBagConstraints.gridx = column;
            gridBagConstraints.gridy = row;
            gridBagConstraints.gridwidth = with;
            gridBagConstraints.gridheight = height;
            gridBagConstraints.fill = GridBagConstraints.BOTH;
            gridBagConstraints.insets = new Insets(1,1,1,1);
            gridBagLayout.setConstraints(button, gridBagConstraints);
            container.add(button);
        }
    
        public void calculate(double x) {
            if (this.lastCommand.equals("+")) {
                this.result += x;
            } else if (this.lastCommand.equals("-")) {
                this.result -= x;
            } else if (this.lastCommand.equals("*")) {
                this.result *= x;
            } else if (this.lastCommand.equals("/")) {
                this.result /= x;
            } else if (this.lastCommand.equals("=")) {
                this.result = x;
            }
    
            this.displayField.setText("" + this.result);
        }
    
        public static void main(String[] args) {
            new Calculator();
        }
    
        private class CommandAction implements ActionListener {
            private CommandAction() {
            }
    
            public void actionPerformed(ActionEvent evt) {
                String command = evt.getActionCommand();
                if (Calculator.this.start) {
                    Calculator.this.lastCommand = command;
                } else {
                    Calculator.this.calculate(Double.parseDouble(Calculator.this.displayField.getText()));
                    Calculator.this.lastCommand = command;
                    Calculator.this.start = true;
                }
            }
        }
    
        private class InsertAction implements ActionListener {
            private InsertAction() {
            }
    
            public void actionPerformed(ActionEvent event) {
                String input = event.getActionCommand();
                if (Calculator.this.start) {
                    Calculator.this.displayField.setText("");
                    Calculator.this.start = false;
                    if (input.equals("-")) {
                        Calculator.this.displayField.setText(Calculator.this.displayField.getText() + "-");
                    }
                }
    
                if (!input.equals("-")) {
                    if (input.equals("Back")) {
                        String str = Calculator.this.displayField.getText();
                        if (str.length() > 0) {
                            Calculator.this.displayField.setText(str.substring(0, str.length() - 1));
                        }
                    } else if (input.equals("清零")) {
                        Calculator.this.displayField.setText("0");
                        result=0.0d;
                        Calculator.this.start = true;
                    } else{
                        if (input.equals(".")) {
                            if (Calculator.this.displayField.getText().trim().indexOf(".") == -1) {
                                Calculator.this.displayField.setText(Calculator.this.displayField.getText() + input);
                            }
                        } else {
                            Calculator.this.displayField.setText(Calculator.this.displayField.getText() + input);
                        }
                    }
                }
    
            }
        }
    }

     

    展开全文
  • Java图形化界面 计算器 用的是栈 比较简单
  • 主要为大家详细介绍了java实现图形化界面计算器,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了java图形化界面实现简单混合运算计算器的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 从各大招聘网站的招聘要求来看,第一条都明确说明需要扎实的Java基础。因此,一般笔试以及面试的第一轮,对基础的考察是比较多的。 其实我发现有很多开发几年了,基础知识都不扎实,比如说,简单地介绍一下Java8有...

    第一阶段:架构师筑基必备技能

    我觉得,但凡是个成年人应该都清楚扎实的基本功对自己的工作帮助有多重要。从各大招聘网站的招聘要求来看,第一条都明确说明需要扎实的Java基础。因此,一般笔试以及面试的第一轮,对基础的考察是比较多的。

    其实我发现有很多开发几年了,基础知识都不扎实,比如说,简单地介绍一下Java8有哪些新特性吗,或者你比较擅长的新特性有哪些?要么回答的不完整,要么就是回答的牛头不对马嘴。

    配套学习文档

    大厂必问并发编程:

    image

    JVM深入拆解:

    image

    网络编程与高效IO:

    image

    MySQL进阶:

    image

    面试必问数据结构与算法:

    image

    这份笔记里面涵盖的知识非常多,应该是必备的一份笔记,可以时不时的翻阅一下,查漏补缺。

    第二阶段:设计模式+开源框架解读

    设计模式是前辈们用毕生心血专业填坑换来的经验,把这些经验加工精简,就成了设计模式,也就是套路。有了套路,就把类型的业务类型套上去就OK了,不会出太大的问题,也利于软件的开发速度和扩展性。

    目前企业主流的开源框架就是SSM框架,会使用SSM框架早已成为一名Java开发的职业基操。

    配套学习文档

    Java设计模式:

    image

    SSM框架源码解读:

    ①Spring源码解读

    image

    ②Spirng MVC

    image

    ③MyBatis

    image

    第三阶段:架构技术性能提升

    中间件是为了解决某一类复杂技术问题的,比如消息中间件Kafka、RocketMQ,解决了大量处理请求的排队和缓冲、并且做到高性能的情况下不丢失消息,这类通用的复杂技术常见。TDDL、ShardingSphere、MyCat等解决分库分表、读写分离,进而提升整个系统对于更大规模的数据读写的问题。

    推荐学习文档

    Zookeeper:

    image

    NGINX:

    image

    RabbitMQ:

    image

    RocketMQ:

    image

    Kafka:

    image

    ELK:

    image

    第四阶段:高效存储让项目起飞

    重点知识点:Redis、MongoDB、MySQL高可用、Mycat

    现在企业流行的还是Redis和MySQL做存储,如果时间不是很充足的话,主要把这两个弄懂就ok了。

    Redis数据库:

    image

    MySQL数据库高可用:

    image

    第五阶段:分布式扩展到微服务架构

    这一阶段属于拔高的部分。如果时间不够,着急找工作的话,可以跳过这部分,进入下一阶段,直接项目的学习,回头再补。

    image

    Docker:

    image

    ZooKeeper 分布式协调服务技术+Dubbo高性能的 RPC 服务发布和调用框架:

    image

    Spring Boot:

    image

    Spring Cloud:

    image

    Spring Cloud Alibaba:

    image

    最后

    由于篇幅有限,这里就不一一罗列了,20道常见面试题(含答案)+21条MySQL性能调优经验小编已整理成Word文档或PDF文档,点击这里免费下载

    MySQL全家桶笔记

    还有更多面试复习笔记分享如下

    Java架构专题面试复习

    tee.com/vip204888/java-p7)**

    [外链图片转存中…(img-y7vx588O-1626710413503)]

    还有更多面试复习笔记分享如下

    [外链图片转存中…(img-tZXaVp71-1626710413504)]

    展开全文
  • 主要介绍了Java实现图形化界面计算器加法小程序,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java图形界面计算器

    2021-11-11 19:29:19
    文章目录Java图形界面计算器项目创建UI 组件创建和初始(1)窗口的创建(2)所需的组件在窗体中添加 UI 组件(1)面板(2)放置数字键等的面板(3)放置清除框等的面板(4)窗体添加面板 1 和面板 2响应事件需要...

    Java版图形界面计算器

    项目创建

    (1)在文件菜单 File 中选择 New -> Project 来创建项目。

    图片描述

    (2)在弹出的新建项目对话框中选择 Java Project,并点击 Next 按钮进入下一步。

    图片描述

    (3)在 Project name 一栏填写项目名称 Calculator,并点击 Finish 按钮完成创建。

    图片描述

    (4)如果遇到下图所示的对话框,点击 Open Perspective 按钮确认即可。

    图片描述

    (5)在创建好后的项目目录 src 上右键点击,在右键菜单中选择 New -> Class 来创建一个类。

    图片描述

    (6)在新建类对话框中填写包名 com.shiyanlou.calculator 和类名 Calculator (首字母大写)。点击 Finish 按钮完成创建。

    图片描述

    UI 组件创建和初始化

    首先我们需要将界面中要用到的 UI 组件作为 Calculator 类的成员变量在一开始声明。在阅读代码之前,可以思考一下都要用到哪些 UI 组件,以及这些代码应当写在哪个位置等等。

    一个计算器界面至少包括窗口、按钮和显示文本框。如下图,这是我们希望达到的效果。

    img

    (1)窗口的创建

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

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

    这里,我们先不设置窗口的大小,待我们将所有组件添加到窗体上之后,调用 pack() 方法,让窗体自己调整大小(在 3.3 (4)窗体添加面板 1 和面板 2 部分会介绍)。

    (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_Dian = new JButton(".");
    JButton button_jia = new JButton("+");
    JButton button_jian = new JButton("-");
    JButton button_cheng = new JButton("*");
    JButton button_chu = new JButton("/");
    
    • 等于按钮(按下后进行计算)
    // 计算按钮
    JButton button_dy = new JButton("=");
    

    在窗体中添加 UI 组件

    (1)面板

    这个计算器有两个 JPanel。

    此处输入图片的描述

    什么是 JPanel:JPanel 是一般轻量级容器。如上图所示,你可以将其理解为一个盛放其他 UI 组件的“篮子”。 JPanel 位于 javax.swing 包中,为面板容器,可以加入到 JFrame 中 , 它自身是个容器,也可以把其他 component (组件) 加入到 JPanel 中,例如 JButton、JTextArea、JTextField 等。

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

    图片描述

    同样,在书写本段代码时,你应当思考它应该放在哪个部分。如果不清楚,可以回到上面的代码结构中查看。

    (2)放置数字键等的面板

    对于面板 1,可供参考的代码如下所示:

    首先初始化一个面板对象 pan。

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

    设置 pan 的布局为网格布局 GridLayout,具体的使用方法可以参考 Class GridLayout - 官方文档。在本程序中,我们使用的 GridLayout 构造函数传入了四个参数,含义分别为创建一个 4 行(第一个参数)、4 列(第二个参数)的网格,每个网格宽度为 5(第三个参数)、高度为 5 (第四个参数)。

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

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

    图片描述

    对比之前的效果图,我们应该按照下面的顺序进行 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。依次对应为:上北(NORTH)、下南(SOUTH)、左西(WEST)、右东(EAST),中(CENTER)。如下图所示:

    图片描述

    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 = "";
    

    接下来,我们还定义了五个状态开关(五个 int 变量),其含义在注释中有说明。

    // 以下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) {
    
        }
    }
    

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

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

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

    // 读入存储的符号键
    store = (JButton) e.getSource();
    vt.add(store);
    

    还记得我们之前定义的 k1 开关吗?当 k1 为 1 时,我们输入的数字是操作数 1 的一部分;当 k1 为 2 时,我们输入的数字是操作数 2 的一部分。因此会有以下逻辑:

    if( k1 == 1) {
        // 输入是操作数 1 的一部分
    } else if( k1 == 2) {
        // 输入是操作数 2 的一部分
    }
    
    • 输入为操作数 1 的一部分时

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

    if (k3 == 1) {
        str1 = "";
    
        // 还原开关k5状态
        k5 = 1;
    }
    str1 = str1 + ss;
    

    这里,我们输入的是数字,因此后面随时可用输入小数点,为了防止出错,给 k5 进行赋值。

    当输入完成后,我们需要给 k3 的值加 1,保证 操作数 1 不会被清空。并且还需要将操作数 1 打印到结果栏。

    k3 = k3 + 1;
    
    // 显示结果
    result_TextField.setText(str1);
    
    • 输入为操作数 2 的一部分时

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

    if (k4 == 1) {
        str2 = "";
    
        // 还原开关k5状态
        k5 = 1;
    }
    str2 = str2 + ss;
    k4 = k4 + 1;
    result_TextField.setText(str2);
    

    完整的代码如下:

    // 数字键
    class Listener implements ActionListener {
        @SuppressWarnings("unchecked")
        public void actionPerformed(ActionEvent e) {
            // 获取事件源,并从事件源中获取输入的数据
            String ss = ((JButton) e.getSource()).getText();
    
            store = (JButton) e.getSource();
            vt.add(store);
    
            if (k1 == 1) {
                if (k3 == 1) {
                    str1 = "";
    
                    // 还原开关k5状态
                    k5 = 1;
                }
                str1 = str1 + ss;
    
                k3 = k3 + 1;
    
                // 显示结果
                result_TextField.setText(str1);
    
            } else if (k1 == 2) {
                if (k4 == 1) {
                    str2 = "";
    
                    // 还原开关k5状态
                    k5 = 1;
                }
                str2 = str2 + ss;
                k4 = k4 + 1;
                result_TextField.setText(str2);
            }
    
        }
    }
    

    小数点的响应

    注意,小数点的响应也是定义为局部内部类,与数字键的响应类是相同的。这个局部内部类命令为 Listener_xiaos,继承 ActionListener 接口。

    首先是获取响应源,并添加到 vt 中。

    store = (JButton) e.getSource();
    vt.add(store);
    

    输入小数点需要在 k5 为 1 的情况下才可以输入,否则输入的小数点被丢掉。

    if( k5 == 1) {
        // 添加对小数点的处理
    }
    

    接下来,我们写上面的 if 语句中的语句块。

    首先还是获取输入的内容:

    String ss2 = ((JButton) e.getSource()).getText();
    

    对于输入的小数点,可能是 str1 的,也有可能是 str2 的,这部分的逻辑与数字的逻辑是相似的。

    if (k1 == 1) {
        if (k3 == 1) {
            str1 = "";
            // 还原开关k5状态
            k5 = 1;
        }
        str1 = str1 + ss2;
    
        k3 = k3 + 1;
    
        // 显示结果
        result_TextField.setText(str1);
    
    } else if (k1 == 2) {
        if (k4 == 1) {
            str2 = "";
            // 还原开关k5的状态
            k5 = 1;
        }
        str2 = str2 + ss2;
    
        k4 = k4 + 1;
    
        result_TextField.setText(str2);
    }
    

    最后,为了防止输入小数点之后再次输入小数点,需要进行 k5 = k5 + 1; 的操作。

    完整的代码如下:

    // 小数点的处理
    class Listener_xiaos implements ActionListener {
        @SuppressWarnings("unchecked")
        public void actionPerformed(ActionEvent e) {
            store = (JButton) e.getSource();
            vt.add(store);
            if (k5 == 1) {
                String ss2 = ((JButton) e.getSource()).getText();
                if (k1 == 1) {
                    if (k3 == 1) {
                        str1 = "";
                        // 还原开关k5状态
                        k5 = 1;
                    }
                    str1 = str1 + ss2;
    
                    k3 = k3 + 1;
    
                    // 显示结果
                    result_TextField.setText(str1);
    
                } else if (k1 == 2) {
                    if (k4 == 1) {
                        str2 = "";
                        // 还原开关k5的状态
                        k5 = 1;
                    }
                    str2 = str2 + ss2;
    
                    k4 = k4 + 1;
    
                    result_TextField.setText(str2);
                }
            }
    
            k5 = k5 + 1;
        }
    }
    

    运算符号的响应

    注意,运算符的响应定义为局部内部类,与数字键的响应类是相同的。这个局部内部类命令为 Listener_signal,继承 ActionListener 接口。

    获取响应事件的源,读取内容,并且将响应源存入 vt 中。

    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 这样的多符号运算(已经输入 2+3,然后输入 -9),即上一次的运算结果存储在 str1 中,符号输入之后要输入的数字是 str2。

    • 普通运算操作

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

    if (k2 == 1) {
        // 开关 k1 为 1 时向数 1 写输入值,为 2 时向数2写输入值。
        k1 = 2;
        k5 = 1;
        signal = ss2;
        k2 = k2 + 1;// 按符号键的次数
    } else {
        // ...
    }
    
    • 连续运算

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

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

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

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

    singal 存储此次输入的符号。

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

    if (k2 == 1) {
        // ...
    } else {
        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 为 1 时,向数 1 写值,为2时向数2写
            k1 = 2;
            k5 = 1;
            k4 = 1;
            signal = ss2;
        }
        k2 = k2 + 1;
    }
    

    完整的代码如下:

    // 输入的运算符号的处理
    class Listener_signal implements ActionListener {
        @SuppressWarnings("unchecked")
        public void actionPerformed(ActionEvent e) {
            String ss2 = ((JButton) e.getSource()).getText();
            store = (JButton) e.getSource();
            vt.add(store);
    
            if (k2 == 1) {
                // 开关 k1 为 1 时向数 1 写输入值,为 2 时向数2写输入值。
                k1 = 2;
                k5 = 1;
                signal = ss2;
                k2 = k2 + 1;// 按符号键的次数
            } else {
                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 为 1 时,向数 1 写值,为2时向数2写
                    k1 = 2;
                    k5 = 1;
                    k4 = 1;
                    signal = ss2;
                }
                k2 = k2 + 1;
    
            }
    
        }
    }
    

    等于的响应

    注意,等于的响应也是定义为局部内部类,与数字键的响应类是相同的。这个局部内部类命令为 Listener_dy,继承 ActionListener 接口。

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

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

    // 等于按键的逻辑,即在输入完成后开始计算
    class Listener_dy implements ActionListener {
        @SuppressWarnings("unchecked")
        public void actionPerformed(ActionEvent e) {
    
            store = (JButton) e.getSource();
            vt.add(store);
            cal();
    
            // 还原开关k1状态
            k1 = 1;
    
            // 还原开关k2状态
            k2 = 1;
    
            // 还原开关k3状态
            k3 = 1;
    
            // 还原开关k4状态
            k4 = 1;
    
            // 为 7+5=12 +5=17 这种计算做准备
            str1 = result;
        }
    }
    

    计算逻辑的实现

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

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

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

    // 操作数1
    double a2;
    // 操作数2
    double b2;
    
    //...
    
    // 手动只输入一个小数点的问题
    if (str1.equals("."))
        str1 = "0.0";
    if (str2.equals("."))
        str2 = "0.0";
    
    // 转换字符串为 double
    a2 = Double.valueOf(str1).doubleValue();
    b2 = Double.valueOf(str2).doubleValue();
    

    还需要定义一个存储中间运算结果的值

    // 运算结果
    double result2 = 0;
    

    对于运算符号,我们使用一个 String c 来存储。

    // 运算符
    String c = signal;
    
    if (c.equals("")) {
        // 还没有输入符号,不能计算
        result_TextField.setText("Please input operator");
    } else {
        // 可以进行计算
    
        // 手动只输入一个小数点的问题
        if (str1.equals("."))
            str1 = "0.0";
        if (str2.equals("."))
            str2 = "0.0";
    
        // 转换字符串为 double
        a2 = Double.valueOf(str1).doubleValue();
        b2 = Double.valueOf(str2).doubleValue();
    
        //...
    }
    

    当上面的运算符判断和操作数转换都完成后,就可以进行加减乘除运算了。要注意,进行乘法时,为了保证精度,可以将 double 存入大的浮点数类 BigDecimal 中。

    if (c.equals("")) {
        // 还没有输入符号,不能计算
        result_TextField.setText("Please input operator");
    } else {
    
        //...
    
        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;
            }
        }
    }
    

    最后,输出结果

    if (c.equals("")) {
        // 还没有输入符号,不能计算
        result_TextField.setText("Please input operator");
    } else {
    
        //...
    
        result = ((new Double(result2)).toString());
        result_TextField.setText(result);
    }
    
    ``
    
    完整代码如下:
    
    ```java
    // 计算逻辑
    public void cal() {
        // 操作数1
        double a2;
        // 操作数2
        double b2;
        // 运算符
        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);
        }
    }
    

    清除的响应

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

    其代码如下:

    // 清除键的逻辑(Clear)
    class Listener_clear implements ActionListener {
        @SuppressWarnings("unchecked")
        public void actionPerformed(ActionEvent e) {
            store = (JButton) e.getSource();
            vt.add(store);
            k5 = 1;
            k2 = 1;
            k1 = 1;
            k3 = 1;
            k4 = 1;
            str1 = "0";
            str2 = "0";
            signal = "";
            result = "";
            result_TextField.setText(result);
            vt.clear();
        }
    }
    

    注册监听器

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

    // 监听等于键
    Listener_dy jt_dy = new Listener_dy();
    button_dy.addActionListener(jt_dy);
    // 监听数字键
    Listener jt = new Listener();
    button0.addActionListener(jt);
    button1.addActionListener(jt);
    button2.addActionListener(jt);
    button3.addActionListener(jt);
    button4.addActionListener(jt);
    button5.addActionListener(jt);
    button6.addActionListener(jt);
    button7.addActionListener(jt);
    button8.addActionListener(jt);
    button9.addActionListener(jt);
    
    ```java
    // 监听符号键
    Listener_signal jt_signal = new Listener_signal();
    button_jia.addActionListener(jt_signal);
    button_jian.addActionListener(jt_signal);
    button_cheng.addActionListener(jt_signal);
    button_chu.addActionListener(jt_signal);
    // 监听清除键
    Listener_clear jt_c = new Listener_clear();
    clear_Button.addActionListener(jt_c);
    // 监听小数点键
    Listener_xiaos jt_xs = new Listener_xiaos();
    button_Dian.addActionListener(jt_xs);
    

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

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

    至此,整个计算器的主要逻辑就已经讲解完毕,请自行补充其他的细节。

    完成后,请点击菜单中的 Run -> Run 选项或者点击工具栏上方的运行按钮来编译运行这个项目。

    如果没有遇到错误,则会弹出计算器的窗口。

    此处输入图片的描述

    你可以试用一下。

    源码:

    包com.shiyanlou.calculator;
    
    导入 java.awt.*;
    导入 java.awt.event.*;
    导入 javax.swing.*;
    导入 java.util.Vector;
    导入 java.math.BigDecimal;
    
    公共类计算器{
    
        // 鎿滑初綔鏁 1锛屼负浜嗙▼搴忕殑瀹夊叏锛屽垵链间竴瀹氲缃纴杩欓噷鎴剧戜戜域 
    	字符串 str1 = "0"; 
    	
    	// 鎿萌綔鏁 2
    	字符串 str2 = "0"; 
    	
    	//杩愮畻绗 
    	字符串信号 = "+"; 
    	
    	//杩愮畻缁撴灉
    	字符串结果 = "";
    
    	// 浠ヤ笅k1钶2三十虹姸镐佸紑鍏 
    	
    	//寮€鍏 1鐢ㄤ簬阃夋嫨杈揿叆鏂宝石悜锛屽皢瑕佸启鍏tr1鎴杝tr2
    	int k1 = 1;
    	//寮€鍏 2鐢ㄤ簬璁板綍绗﹀佛阌殑娆℃暟锛屽鏋  k2>1 璇存槑杩涜镄勬槸2+3-9+8勫绗﹀佛杩愮畻
    	int k2 = 1;
    	// 寮€鍏 3鐢ㄤ簬镕借曲弯瘑 str1 鏄惁鍙互琚绻0 锛岀瓑浜 1镞跺彲浠ワ纴朵苳苕苳栃栃栃栃0
    	整数 k3 = 1;
    	// 寮€鍏 4鐢ㄤ簬镙六瘑 str2鏄惁鍙互琚竻0
    	int k4 = 1;
    	// 寮€鏆5鐢ㄤ簬鎺у埗灏忔暟镣瑰彲钖﹁褰曞叆锛岀瓑浜 1镞跺彲浠苺ㄤ彲浠ワ纴叞ワ彴勐勐勐勐勐勐勐勐勐彴杳杳泷彴彴彴彴彴彴彴彴嬾旃旃旃1镣彲钖﹁褰曞叆锛岀瓑浜 1鏁扮偣琚涪鎺 
    	int k5 = 1;
    	//店面镄勪綔鐢ㄧ被浼间簬瀵勫瓨鍣纴鐢ㄤ簬璁板綍鏄惁杩炵画鎸変笅绗﹀佛阌 
    	JButton 商店; 
    	
    	@SuppressWarnings("rawtypes")
    	Vector vt = new Vector(20, 10);
    
        //澹版槑钖勪釜UI缁勪欢瀵硅薄骞跺垵濮嫔寲
    	JFrame frame = new JFrame("计算器");
    	JTextField result_TextField = new JTextField(result, 20);
    	JButton clear_Button = new JButton("Clear");
    	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_Dian = new JButton(".");
    	JButton button_jia = new JButton("+");
    	JButton button_jian = new JButton("-");
    	JButton button_cheng = new JButton("*");
    	JButton button_chu = new JButton("/");
    	JButton button_dy = new JButton("=");
    
        // 璁$畻链虹被镄勬瀯阃犲櫒
    	公共计算器(){
    	
    	    // 无限烘寜阍缃瓑鏁堥敭锛屽嵆鍙互阃氲绷瀵魅力簲镄勯敭鐩樻寜錘潵潵栃
    		button0.setMnemonic(KeyEvent.VK_0);
    		// 鍏跺畠绛夋晥阌渷鐣ワ纴浣犲彲浠ヨ嚜瀚岃ˉ鍏呭畲鏁 
    
            // 璁剧界鏂囨湰妗嗕负鏂嗕负钍冲榻愶纴浣ュ拰绦緭鍏ュ拰閮介潬鍙樉紫。
    		result_TextField.setHorizo​​ntalAlignment(JTextField.RIGHT);
    
            //灏哢我缁勪欢娣教导姞杩涘鍣ㄥ唴
    		JPanel pan = new JPanel();
    		pan.setLayout(new GridLayout(4, 4, 5, 5));
    		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.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    
    		JPanel pan2 = new JPanel();
    		pan2.setLayout(new BorderLayout());
    		pan2.add(result_TextField, BorderLayout.WEST);
    		pan2.add(clear_Button, BorderLayout.EAST);
    
            // 璁剧疆界荤獥鍙e嚭鐜板湪灞忓箷串婄殑川崎疆疆域
    		frame.setLocation(300, 200);
    		// 璁剧疆绐椾綋涓嶈兘冨ぇ灏 
    		frame.setResizable(false); 
    		frame.getContentPane().setLayout(new BorderLayout());
    		frame.getContentPane().add(pan2, BorderLayout.NORTH);
    		frame.getContentPane().add(pan, BorderLayout.CENTER);
    
    		框架.pack();
    		frame.setVisible(true);
    
    		// 浜嬩欢澶勭悊绋嫔簭
    
    		// 鏁板瓧阌 
    		类 Listener 实现 ActionListener {
    			@SuppressWarnings("未选中")
    			public void actionPerformed(ActionEvent e) {
    				String ss = ((JButton) e.getSource()).getText();
    				store = (JButton) e.getSource();
    				vt.add(store);
    				如果(k1 == 1){
    					如果(k3 == 1){
    						str1 = "";
    						
    						// 杩桦师寮€鍏砶5钟舵€ 
    						k5 = 1;
    					}
    					str1 = str1 + ss;
    
    					k3 = k3 + 1;
                        
                        // 鏄剧ず缁撴灉
    					result_TextField.setText(str1);
    
    				} else if (k1 == 2) {
    					如果(k4 == 1){
    						str2 = "";
    						
    						// 杩桦师寮€鍏砶5钟舵€ 
    						k5 = 1; 
    					}
    					str2 = str2 + ss;
    					k4 = k4 + 1;
    					result_TextField.setText(str2);
    				}
    
    			}
    		}
    
    		//杈揿叆镄勮繍绠楃鍙风殑澶勭悊
    		类 Listener_signal 实现 ActionListener {
    			@SuppressWarnings("未选中")
    			public void actionPerformed(ActionEvent e) {
    				String ss2 = ((JButton) e.getSource()).getText();
    				store = (JButton) e.getSource();
    				vt.add(store);
    
    				如果(k2 == 1){
    				    //寮€鍏  k1十  1 镞跺悜鏁  1 鍐栾緭鍏ュ€硷纴十 2镞跺悜鏁 2鍐栾緭鍏ュ€笺€ 
    					k1 = 2;
    					k5 = 1;
    					信号 = ss2;
    					k2 = k2 + 1;// 鎸夌鍙烽敭镄勬鏁 
    				} 别的 {
    					int a = vt.size();
    					JButton c = (JButton) vt.get(a - 2);
    
    					如果 (!(c.getText().equals("+"))
    							&& !(c.getText().equals("-"))
    							&& !(c.getText().equals("*"))
    							&& !(c.getText().equals("/")))
    
    					{
    						校准();
    						str1 = 结果;
    						//寮€鍏  k1十  1 镞泄纴钖戞暟 1 鍐椤€硷纴三 2镞跺悜鏁 2鍐 
    						k1 = 2;
    						k5 = 1;
    						k4 = 1;
    						信号 = ss2;
    					}
    					k2 = k2 + 1;
    
    				}
    
    			}
    		}
    
    		// 述呴櫎阌殑阃昏緫锛圕lear锛 
    		类 Listener_clear 实现 ActionListener {
    			@SuppressWarnings("未选中")
    			public void actionPerformed(ActionEvent e) {
    				store = (JButton) e.getSource();
    				vt.add(store);
    				k5 = 1;
    				k2 = 1;
    				k1 = 1;
    				k3 = 1;
    				k4 = 1;
    				str1 = "0";
    				str2 = "0";
    				信号 = "";
    				结果 = "";
    				result_TextField.setText(result);
    				vt.clear();
    			}
    		}
    
    		// 绛変簬阌殑阃昏緫
    		类 Listener_dy 实现 ActionListener {
    			@SuppressWarnings("未选中")
    			public void actionPerformed(ActionEvent e) {
    
    				store = (JButton) e.getSource();
    				vt.add(store);
    				校准();
    				
    				//杩桦师钖勪釜寮€鍏崇殑钟舵€ 
    				k1 = 1; 
    				k2 = 1;
    				k3 = 1;
    				k4 = 1;
    
    				str1 = 结果; 
    			}
    		}
    		
    		// 灏忔暟镣圭殑澶勭悊
    		类 Listener_xiaos 实现 ActionListener {
    			@SuppressWarnings("未选中")
    			public void actionPerformed(ActionEvent e) {
    				store = (JButton) e.getSource();
    				vt.add(store);
    				如果(k5 == 1){
    					String ss2 = ((JButton) e.getSource()).getText();
    					如果(k1 == 1){
    						如果(k3 == 1){
    							str1 = "";
    							// 杩桦师寮€鍏砶5钟舵€ 
    							k5 = 1; 
    						}
    						str1 = str1 + ss2;
    
    						k3 = k3 + 1;
    
                            // 鏄剧ず缁撴灉
    						result_TextField.setText(str1);
    
    					} else if (k1 == 2) {
    						如果(k4 == 1){
    							str2 = "";
    							// 杩桦师寮€鍏砶5镄勭姸镐。
    							k5 = 1;
    						}
    						str2 = str2 + ss2;
    
    						k4 = k4 + 1;
    
    						result_TextField.setText(str2);
    					}
    				}
    
    				k5 = k5 + 1;
    			}
    		}
    
    		//娉ㄥ唽钖勪釜鐩戝惉鍣纴鍗崇粦瀹氩簨浠跺搷搴旈€昏緫鍒板悇三猆I缁勪欢三
    		Listener_dy jt_dy = 新的 Listener_dy();
    		
    		// 鐩戝惉鏁板瓧阌 
    		监听器 jt = 新监听器();
    		// 鐩戝惉绗﹀佛阌 
    		Listener_signal jt_signal = 新的 Listener_signal();
    		// 鐩戝惉述呴櫎阌 
    		Listener_clear jt_c = new Listener_clear(); 
    		//鐩戝惉灏忔暟镣归敭
    		Listener_xiaos jt_xs = new Listener_xiaos();
    
    		button7.addActionListener(jt);
    		button8.addActionListener(jt);
    		button9.addActionListener(jt);
    		button_chu.addActionListener(jt_signal);
    		button4.addActionListener(jt);
    		button5.addActionListener(jt);
    		button6.addActionListener(jt);
    		button_cheng.addActionListener(jt_signal);
    		button1.addActionListener(jt);
    		button2.addActionListener(jt);
    		button3.addActionListener(jt);
    		button_jian.addActionListener(jt_signal);
    		button0.addActionListener(jt);
    		button_Dian.addActionListener(jt_xs);
    		button_dy.addActionListener(jt_dy);
    		button_jia.addActionListener(jt_signal);
    		clear_Button.addActionListener(jt_c);
    
    		// 绐椾綋鍏抽棴浜嬩欢镄勫搷搴旗▼搴 
    		frame.addWindowListener(new WindowAdapter() {
    			公共无效窗口关闭(WindowEvent e){
    				System.exit(0);
    			}
    		});
    
    	}
    
    	// 璁$畻阃昏緫
    	公共无效校准(){
        	// 鎿萌綔鏁 1
    		双a2;
    		// 鎿萌綔鏁 2
    		双 b2;
    		//杩愮畻绗 
    		字符串 c = 信号;
    		//杩愮畻缁撴灉
    		双结果2 = 0;
    
    		如果(c.equals(“”)){
    			result_TextField.setText("请输入运算符");
    
    		} 别的 {
                // 镓嫔姩澶勭悊灏忔暟镣圭殑闂
    			如果 (str1.equals("."))
    				str1 = "0.0";
    			如果 (str2.equals("."))
    				str2 = "0.0";
    			a2 = Double.valueOf(str1).doubleValue();
    			b2 = Double.valueOf(str2).doubleValue();
    
    			如果(c.equals(“+”)){
    				结果2 = a2 + b2;
    			}
    			如果(c.equals(“-”)){
    				结果2 = a2 - b2;
    			}
    			如果(c.equals(“*”)){
    				BigDecimal m1 = new BigDecimal(Double.toString(a2));
    			        BigDecimal m2 = new BigDecimal(Double.toString(b2));
    			        result2 = m1.multiply(m2).doubleValue();
    			}
    			如果(c.equals(“/”)){
    				如果(b2 == 0){
    					结果2 = 0;
    				} 别的 {
    					结果2 = a2 / b2;
    				}
    
    			}
    
    			结果 = ((new Double(result2)).toString());
    
    			result_TextField.setText(result);
    		}
    	}
    
    	@SuppressWarnings("未使用")
    	公共静态无效主(字符串 [] args){
    		// 璁剧界绋嫔簭鏄剧ず镄勭晫闱㈤镙硷纴鍙互信铡婚櫎
    	尝试 {
    			UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
    		} 捕获(异常 e){
    			e.printStackTrace();
    		}
    		计算器 cal = new Calculator();
    	}
    
    }
    
    展开全文
  • 主要为大家详细介绍了基于java语言下图形界面AWT编写计算器,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 图形化界面计算器 2018.6 实现功能基本运算以及一些常用函数sin cos tan等 退格、清零、根号、以及平方功能 可实现进制转换 二进制 十六进制 八进制 可实现带括号运算,调用JavaScript中eval函数 增加彩蛋,如果输入...
  • Java编写的计算器图形界面实现加减乘除带括号运算 版本1.0 1、图形界面 2、计算器显示部分分为两个区域:第一行显示输入将要计算的数值及符号,第二行显示结果,第一行字体要小,第二行字体要大,且加粗。 ...
  • 学 号 11710115 天津城建大学 Java 语言程序设计 C 实验报告 实验 5计算器 ...3掌握图形界面的各种控件的使用如标签文本框按钮复选框列表框窗 框等 二实验要求 1采用布局管理器进行界面的布局 2学会对不同的事件用相应
  • java图形界面计算器

    2021-03-04 21:28:54
    public class Test25 { public static int num; public static int num1; public static int math; public static void main(String[] args) { a: while (true) { ... System.out.println("请输入第一个整数 : ...
  • Java实现简单的图形界面计算器

    万次阅读 多人点赞 2018-06-11 09:44:15
    因为这两天我们的Java实验课程需要做两个小的图形界面,其中就有一个图形界面计算器,所以稍微花了点时间做了一个,同时复习了一下Java的基础内容和GUI编程。因为代码中的注释特别详细,所以这里就不讲解怎么...
  • import java.awt.BorderLayout;public class Compuer extends JFrame {private JPanel contentPane;private JTextField textField;private JTextField textField_1;private JTextField textField_2...
  • 该文件是由我自己用Java写的一个图形用户界面计算器源码,实现了基本的计算功能,需要的可以自行下载解压,直接导入到eclipse中即可。如果有什么问题可以看我的博客,或者在我的博客下留言均可。希望对大家有帮助...
  • java图形化界面实现简单计算器.pdf
  • java Swing 逆波兰表达式 计算器
  • 主要为大家详细介绍了java实现简易版图形界面计算器,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 这是一个实现图形界面计算器。呃呃呃是作业吧。也是想要保留下来。
  • java图形化界面实现简单计算器.doc
  • Java 制作实现的UI可视化界面版数学计算器源代码,另附编程文档,本计算器可以进行常用的加减乘除算术运算。本实例的知识点有:窗口布局器GridLayout的应用,对按钮消息的监听和响应 。运行方法:本实例代码编写完毕...
  • 本文件为JAVA图形化界面设计的基本使用实例 请配合尘飞acmer的博客使用,http://blog.csdn.net/motefly_acmer/article/details/44627847 文件目录如下所示: /src /creatmyself /tryonce:一个简单的JFrame测试...
  • JAVA(GUI)简易计算器Jframe(图形化界面) windowBuilder下载 实现功能: 输入整数,选择运算符号,再点击确定得出结果,点击退出时,结束

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,372
精华内容 3,348
关键字:

java图形化界面计算器

java 订阅