Java自学课程笔记10

2021年3月14日17点21分
JAVA自学课程笔记10：
    
    可输入的加法计算文本框1：
        TestTextField.java:
            /*版本1的main函数过长，不美观*/
            import java.awt.*;
            import java.awt.event.*;

            public class TestTextField{
                public static void main(String[] args){
                    TextField tf1 = new TextField(30);
                    TextField tf2 = new TextField(30);
                    TextField tf3 = new TextField(30);
                    
                    Button bn = new Button("=");
                    Label lb = new Label("+");
                    Frame f = new Frame("文本框相加示例");
                    f.setLayout(new FlowLayout());
                    f.add(tf1);
                    f.add(lb);
                    f.add(tf2);
                    f.add(bn);
                    f.add(tf3);

                    MyMonitor aa = new MyMonitor();
                    bn.addActionListener(aa);

                    f.pack();
                    f.setVisible(true);
                }
            }

            class MyMonitor implements ActionListener{
                @Override
                public void actionPerformed(ActionEvent e){
                    String str1 = TestTextField.tf1.getText();
                    String str2 = TestTextField.tf2.getText();
                    int num1 = Integer.parseInt(str1);
                    int num2 = Integer.parseInt(str2);
                    int num3 = num1 + num2;

                    String str3 = String.valueOf(num3);
                    TestTextField.tf3.setText(str3);
                }
            }
    
    可输入的加法计算文本框2：
        TestTextField.java:
            /*对1程序美化修正且添加了关闭程序的功能*/
            import java.awt.*;
            import java.awt.event.*;

            public class TestTextField{
                public static void main(String[] args){
                    new newTextField().launch();
                }
            }

            class newTextField{
                public TextField tf1, tf2, tf3;

                public void launch(){
                    tf1 = new TextField(30);
                    tf2 = new TextField(30);
                    tf3 = new TextField(30);
                    
                    Button bn = new Button("=");
                    Label lb = new Label("+");
                    Frame f = new Frame("文本框相加示例");
                    f.setLayout(new FlowLayout());
                    f.add(tf1);
                    f.add(lb);
                    f.add(tf2);
                    f.add(bn);
                    f.add(tf3);

                    
                    bn.addActionListener(new MyMonitor(this));
                    f.addWindowListener(new MyMonitor(this));

                    f.pack();
                    f.setVisible(true);
                }
            }

            class MyMonitor extends WindowAdapter implements ActionListener{
                private newTextField tf;    //通过在B类中定义A类的属性，就可以达到在B类中访问A类成员的目的
                public MyMonitor(newTextField tf){
                    this.tf = tf;
                }

                @Override
                public void actionPerformed(ActionEvent e){
                    String str1 = tf.tf1.getText();
                    String str2 = tf.tf2.getText();
                    int num1 = Integer.parseInt(str1);
                    int num2 = Integer.parseInt(str2);
                    int num3 = num1 + num2;

                    String str3 = String.valueOf(num3);
                    tf.tf3.setText(str3);
                }

                @Override
                public void windowClosing(WindowEvent e){
                    System.exit(-1);
                }
            }

    内部类：
        内部类的方法可以访问外部类的所有成员。
        内部类可以直接当作外部类的成员。
        外部类的方法不可以直接访问内部类的成员。

        优点：
            可以让一个类方便的访问另一个类的所有成员。
            增加程序安全性，有效避免其他不相关外部类对该类的访问。
        例如，上面的计算文本框程序中的一个MyMonitor类可以作为newTextField的内部类，同时nexTextField的“new MyMonitor(this)”语句中的this可以不要。

    匿名类：
        较不规范，没有逻辑性。
        匿名类是一种特殊的内部类。
        
        Test:
            import java.awt.*;
            import java.awt.event.*;

            public class Test{
                public static void main(String[] args){
                    Frame f = new Frame();
                    f.setSize(300, 300);
                    
                    f.addWindowListener(
                        new WindowAdapter(){
                            @Override
                            public void windowClosing(WindowEvent e){
                                System.exit(-1);
                            }
                        }
                    );
                    
                    f.setVisible(true);
                }
            }

        如果在一个方法内定义了一个匿名类，则该匿名类可以访问外部类的所有成员、包裹该匿名类的方法中的所有final类型局部变量。（非final类型的局部变量无法被匿名类访问。）
            Test:
            import java.awt.*;
            import java.awt.event.*;

            public class Test{
                public static void main(String[] args){
                    final Frame f = new Frame();    //如果去掉final编译会报错
                    f.setSize(300, 300);
                    
                    f.addWindowListener(
                        new WindowAdapter(){
                            @Override
                            public void windowClosing(WindowEvent e){
                                f.setVisible(false);    //匿名类只能调final类型局部变量
                            }
                        }
                    );
                    
                    f.setVisible(true);
                }
            }


        实现接口：
            //其中A是接口。
            new A(){
                //实现接口方法的代码
            }；
            //功能：生成一个实现了A接口的匿名类的对象。

        实现抽象类：
            //其中A是抽象类。
            new A(){
                //实现A中所有抽象方法的代码
                //也可以添加自己的方法或属性代码
            }
            //功能：生成一个匿名类对象，该匿名类必须得实现A类的所有抽象方法，当然该匿名类也可以定义自己的属性和方法。

        继承父类：
            //其中A是类名。
            new A(){
                //重写了A类的方法代码
                //也可以添加自己的方法或属性代码
            }
            //功能：生成一个A类的子类对象，该匿名类继承了A的所有非private成员。

        如果一个类包含了很重要的逻辑，将来要经常修改，则这个类就不应当做匿名类来使用，匿名类会造成代码的混乱。