GUI编程，简易计算器的实现2改造篇

继前篇内容的实现基础之上，将编写的代码进行重构优化。

文章目录

• • • • • 1. 面向过程的实现方式
        • 2. 面向组合特性的实现方式
        • 3. 完全面向对象的实现方式

1. 面向过程的实现方式

先看一下前篇的代码

package com.Ltz2.test;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

//简易的计算器练习
public class TestCount {

    //启动程序的主方法
    public static void main(String[] args) {
        new Count("自定义简易计算器的实现测试");
    }
}

//计算器界面实现类
class Count extends Frame{

    //无参构造，用于初始化对象的属性赋值操作
    public Count(String title){
        super(title);

        //存放计算数字的文本框
        TextField t1 = new TextField(10);
        TextField t2 = new TextField(10);
        TextField t3 = new TextField(20);

        //运算符+号的标签
        Label label = new Label("+");
        //运算符=号的按钮
        Button button = new Button("=");
        //开始给等号的按钮添加点击事件
        button.addActionListener(new MyActionListener(t1,t2,t3));

        //将其全部添加到窗体当中
        add(t1);
        add(label);
        add(t2);
        add(button);
        add(t3);


        //设置布局
        setLayout(new FlowLayout());
        //设置布局自适应
        pack();
        //设置窗体可见性
        setVisible(true);

        //在添加一个关闭方法
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}

//自定义监听类
class MyActionListener implements ActionListener {
    private TextField t1, t2, t3;

    //利用构造器将计算器类中接收到的数字参数取过来
    public MyActionListener(TextField t1,TextField t2, TextField t3){
        this.t1 =t1;
        this.t2 =t2;
        this.t3 =t3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //取到参数之后，开始实现监听事件的逻辑

        //先获取三个参数的对象
        int i1 = Integer.parseInt(t1.getText());
        int i2 = Integer.parseInt(t2.getText());
        //有了对象，把参数进行运算，在存入到第三个框框中
        t3.setText(""+(i1+i2)); //利用字符串进行拼接，注意运算优先级，加上括号

        //最后在将前两个框框中的内容清空
        t1.setText("");
        t2.setText("");
    }
}

2. 面向组合特性的实现方式

其实不难看出，其特点完全是面向过程的，我们先给进行第一步改造，将其改造成特点是带有大于继承特性的首选 组合特性来改造。

package com.Ltz2.test;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//简易计算器的面向组合特性的实现方式
public class TestCount1 {

    public static void main(String[] args) {
        new Count1().loadFrame();
    }
}

class Count1 extends Frame{

    TextField f1, f2, f3;

    public void loadFrame(){
        f1 = new TextField(10);
        f2 = new TextField(10);
        f3 = new TextField(20);

        Label add = new Label("+");
        Button equal = new Button("=");
        equal.addActionListener(new MyActionListener1(this));

        setLayout(new FlowLayout());
        add(f1);
        add(add);
        add(f2);
        add(equal);
        add(f3);

        pack();
        setVisible(true);
    }
}

//实现自定义监听类
class MyActionListener1 implements ActionListener{

    //将简易计算器的封装类组合进 监听器当中
    private Count1 count1 = null;

    public MyActionListener1(Count1 count1) {
        this.count1 = count1;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        int i1 = Integer.parseInt(count1.f1.getText());
        int i2 = Integer.parseInt(count1.f2.getText());
        count1.f3.setText(""+ (i1+i2));

        count1.f1.setText("");
        count1.f2.setText("");
    }
}

对比第一个的实现方式来说，第二个实现方式就相对来说，偏向面向对象了，因为我们可以清楚的看到实现的过程是通过对象的属性来实现的。而第一个实现方式则需要自己完成方法的调用来设置好参数。

3. 完全面向对象的实现方式

第三种实现方式采用内部来 来进行进一步的更好的包装，通过内部类，还可以畅通无阻的访问外部类的属性和方法

package com.Ltz2.test;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TestCount2 {
    public static void main(String[] args) {
        new Count2().loaderFrame();
    }
}

class Count2 extends Frame{

    private TextField f1, f2, f3;

    public void loaderFrame(){
        f1 = new TextField(10);
        f2 = new TextField(10);
        f3 = new TextField(20);

        Label add = new Label("+");
        Button equal = new Button("=");
        equal.addActionListener(new MyActionListener2());

        setLayout(new FlowLayout());
        add(f1);
        add(add);
        add(f2);
        add(equal);
        add(f3);

        pack();
        setVisible(true);

    }

    private class MyActionListener2 implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent e) {
            int i1 = Integer.parseInt(f1.getText());
            int i2 = Integer.parseInt(f2.getText());
            f3.setText(""+(i1+i2));
            f1.setText("");
            f2.setText("");
        }
    }
}