简易计算器，组合 + 内部类回顾

输入框监听事件

package GUI;

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

public class TextFiledDemon {
    public static void main(String[] args) {
        // 启动！
        MyFrame myFrame = new MyFrame();
    }
}

class MyFrame extends Frame { // 继承Frame
    public MyFrame(){
        TextField textField = new TextField();
        add(textField);
        // 监听这个文本框输入的文字
        MyActionListener myActionListener = new MyActionListener();
        // 按下回车就会触发这个事件
        textField.addActionListener(myActionListener);

        setVisible(true);
        pack();
    }
}

class MyActionListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        //e.getSource(); // 获得一些资源, 返回一个对象（Object类）：因此要下转型：监听了谁就是谁
        TextField field = (TextField) e.getSource();

        System.out.println(field.getText()); // 获得输入框的文本

        field.setText(""); // 清空
    }
}

简易计算器，组合 + 内部类回顾

OOP原则：组合 大于 继承

尽量别用多态，别用继承

面向过程

package GUI;

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

// 简易计算器
public class TextCalc {
    public static void main(String[] args) {
        // 启动！
        Calculator calculator = new Calculator();
    }
}

// 计算器类
class Calculator extends Frame {
    public Calculator(){
        // 3 三个文本框
        TextField num1 = new TextField(10); // 框的大小：字符数
        TextField num2 = new TextField(10);
        TextField num3 = new TextField(20);
        // 1个按钮
        Button button = new Button("=");

        // 给按钮绑定一个加法事件！
        button.addActionListener(new MyCalculatorListener(num1, num2, num3)); // 通过传参更快拿到数据

        // 1个标签
        Label label = new Label("+");

        // 布局
        setLayout(new FlowLayout());

        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);



        pack();
        setVisible(true);
    }
}
// 监听器类

class MyCalculatorListener implements ActionListener {

    //  获取三个变量（String类型）
    private TextField num1 ,num2, num3;

    public MyCalculatorListener(TextField num1, TextField num2, TextField num3) {
        this.num1 = num1;
        this.num2 = num2;
        this.num3 = num3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1. 获得加数 跟 被加数
        int n1 = Integer.parseInt(num1.getText()); // Integer.parseInt()将字符串转为整数类型
        int n2 = Integer.parseInt(num2.getText());
        //2. 加法运算后 将这个值传到第三个框 setText（）
        num3.setText("" + (n1 + n2)); // 加后转为字符串！
        //3. 清除前两个框
        num1.setText("");
        num2.setText("");
    }
}

**01改进：面向对象——组合!

package GUI;

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

// 简易计算器
public class TextCalc {
    public static void main(String[] args) {
        // 启动！
        Calculator calculator = new Calculator();
        calculator.loadFrame();
    }
}

// 计算器类
class Calculator extends Frame {

    // 属性
    TextField num1, num2, num3;
    Button button;
    Label label1;
    // 方法
    public void loadFrame(){ // 省去了构造器！
        // 组件
        num1 = new TextField(10); // 框的大小：字符数
        num2 = new TextField(10);
        num3 = new TextField(20);
        button = new Button("=");
        label1 = new Label("+");

        // 给按钮绑定一个加法事件！
        // 获取的是对象而不是数据！
        button.addActionListener(new MyCalculatorListener(this)); // 把自己这个对象丢进去

        // 布局
        setLayout(new FlowLayout());
        
        // 组件拼接
        add(num1);
        add(label1);
        add(num2);
        add(button);
        add(num3);
        
        pack();
        setVisible(true);
    }

}
// 监听器类 —— 我们获取到一个计算器对象
// 改用组合 完全面向对象
// 操作： 对象.属性 / 对象.方法
class MyCalculatorListener implements ActionListener {

    // 获取计算器这个对象，在一个类中组合另外一个类！
    Calculator calculator = null;

    // 构造方法
    public MyCalculatorListener(Calculator calculator) { // 计算器类里面有num1 num2 num3了！
        this.calculator = calculator;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1. 获得加数 跟 被加数
        //2. 加法运算后 将这个值传到第三个框 setText（）
        //3. 清除前两个框
        int n1 = Integer.parseInt(calculator.num1.getText());
        int n2 = Integer.parseInt(calculator.num2.getText());
        calculator.num3.setText("" + (n1 + n2));
        calculator.num1.setText("");
        calculator.num2.setText("");


    }
}

**02改进：面向对象——内部类！

内部类：更好的包装！

内部类最大的好处，就是可以畅通无阻的访问外部属性和方法！

package GUI;

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

// 简易计算器
public class TextCalc {
    public static void main(String[] args) {
        // 启动！
        Calculator calculator = new Calculator();
        calculator.loadFrame();
    }
}

// 计算器类
class Calculator extends Frame {

    // 属性
    TextField num1, num2, num3;
    Button button;
    Label label1;
    // 方法
    public void loadFrame(){ // 省去了构造器！
        // 组件
        num1 = new TextField(10); // 框的大小：字符数
        num2 = new TextField(10);
        num3 = new TextField(20);
        button = new Button("=");
        label1 = new Label("+");

        // 给按钮绑定一个计算器操作事件！
        button.addActionListener(new MyCalculatorListener()); // 直接new一个监听器！

        // 布局
        setLayout(new FlowLayout());

        // 组件拼接
        add(num1);
        add(label1);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }

    // 监听器类（对监听器类进行封装到计算器类中）这样就不用再另外进行组装了（计数器类这个类直接使用监听器类）

    // 内部类最大的好处，就是可以畅通无阻的访问外部属性和方法！

    // 要是写在外面还要另外进行组合写代码 ———— 减少了代码！
    private class MyCalculatorListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            //1. 获得加数 跟 被加数
            //2. 加法运算后 将这个值传到第三个框 setText（）
            //3. 清除前两个框
            int n1 = Integer.parseInt(num1.getText());
            int n2 = Integer.parseInt(num2.getText());
            num3.setText("" + (n1 + n2));
            num1.setText("");
            num2.setText("");

        }
    }

}