一个小程序

　　主要是测试java的GUI编程，听说java的GUI编程用得不多了，但是在学习的过程中老是用system.out.println打印真的是很无聊。而且看起来很low，所以。。。

之前用vb还有c#都写过一些小程序，对控件的概念还是不陌生，那么从1+1=2开始吧。

　　java的GUI类都在awt包里。java.awt.*，里面好多东西，不过我分2种：一种是容器类Container,另一种非容器(我自己定的)。Container又分为windows与Panel,其中Windows分为Frame与Dialog，其实看java的api文档我这么说是错的，Container的子类就不止2个了。没关系，先记住常用的。好的，先写个计算器1+1的计算器，虽然是个小程序但是涉及到一些问题。

　　这是继承JFrame的类

class MyFrame extends JFrame{
    JTextField num1,num2,num3;
    JButton jButton;
    public MyFrame() {
        JFrame jFrame = new JFrame("相加");
        JPanel jPanel = new JPanel(new FlowLayout());
         num1 = new JTextField(5);
         num2 = new JTextField(5);
         num3 = new JTextField(6);

        JLabel jl = new JLabel("+");
        jButton = new JButton("=");
        jPanel.add(num1);
        jPanel.add(jl);
        jPanel.add(num2);
        jPanel.add(jButton);
        jPanel.add(num3);

        jButton.addActionListener(new Monitor(this));//第一种
        //jButton.addActionListener(new Monitor1(num1, num2, num3));//第二种
        jFrame.setLayout(new BorderLayout());
        jFrame.add(jPanel,BorderLayout.CENTER);
        jFrame.pack();

        jFrame.setVisible(true);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }
}

　　用到了JButton、JTextField、JPanel 都跟vb差不多上手很快。按钮添加了监听事件，计算结果。不过这里有一个问题，要取得一个类内部的对象的引用(不知道这么说对不对),改怎么做。

　　1 就是直接把num1 num2 num3，当成参数传入其他类。

　　2 将Frame当成参数传入其他类，这样就可以用Frame的引用来访问Frame内部的对象了。不过前提这些被访问对象不要是私有的。

第一种的写法

class Monitor implements ActionListener{
    private MyFrame jf = null;
    public Monitor() {};
    public Monitor(MyFrame jf) {
        this.jf = jf;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO 自动生成的方法存根
        int n;
        n = Integer.parseInt(jf.num1.getText())+Integer.parseInt(jf.num2.getText());
        jf.num3.setText(String.valueOf(n));
    }
}

这里Monitor的构造函数的参数就是Frame控件。

第二种写法

class Monitor1 implements ActionListener{
    JTextField num1,num2,num3;
    public Monitor1(JTextField n1,JTextField n2,JTextField n3){
        this.num1 = n1;
        this.num2 = n2;
        this.num3 = n3;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO 自动生成的方法存根
        int n;
        n = Integer.parseInt(num1.getText())+Integer.parseInt(num2.getText());
        num3.setText(String.valueOf(n));
    }

}

这里Monitor1的构造函数的三个参数就是文本控件。
　　结果就是

　　好了，开始讨论其他的东西。

　　1　程序里有一段是

　  jFrame.setLayout(new BorderLayout());
 　 jFrame.add(jPanel,BorderLayout.CENTER);
 　 jFrame.pack();

　　在Frame添加panel之前pack()结果与pack之后不一样。看来我写程序太随意了。

2   这里点击等于号就开始计算结果，这个动作是只希望这个按钮来完成的，不希望其他地方调用，那么就把这个监控类写到内部类的形式，这里涉及到内部类使用的好处(翻资料的)：

　         a 可以方便的访问包装类的成员变量；

　　　　b 防止误访问，在语法上防止不应访问次类的类访问。

什么时候使用内部类呢？在你不希望其他类访问的时候。

　　修改后的代码如下。

class MyFrame extends JFrame{
    JTextField num1,num2,num3;
    JButton jButton;
    public MyFrame() {
        JFrame jFrame = new JFrame("相加");
        JPanel jPanel = new JPanel(new FlowLayout());
         num1 = new JTextField(5);
         num2 = new JTextField(5);
         num3 = new JTextField(6);

        JLabel jl = new JLabel("+");
        jButton = new JButton("=");
        jPanel.add(num1);
        jPanel.add(jl);
        jPanel.add(num2);
        jPanel.add(jButton);
        jPanel.add(num3);

        jButton.addActionListener(new Monitor());
        jFrame.setLayout(new BorderLayout());
        jFrame.add(jPanel,BorderLayout.CENTER);
        jFrame.pack();

        jFrame.setVisible(true);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }
    class Monitor implements ActionListener{
        public Monitor() {};
        @Override
        public void actionPerformed(ActionEvent e) {
            // TODO 自动生成的方法存根
            int n;
            n = Integer.parseInt(num1.getText())+Integer.parseInt(num2.getText());
            num3.setText(String.valueOf(n));
        }
    }
}

　　最后讲一点。有关内部类的一种罕见的用法：一个类继承了接口A，B。接口A，B都用一个方法f();但是返回值不一样。怎么实现？
包装类实现接口A，内部类实现接口B。代码如下：

public class InnerClass {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Ab ab = new Ab();
        System.out.println(ab.f());
        //System.out.println(ab.new inner().f());
        Ab.inner ai = ab.new inner();
        System.out.println(ai.f());
    }
}
interface A{
    abstract int f();
}
interface B{
    abstract String f();
}

class Ab implements A{

    @Override
    public int f() {
        // TODO 自动生成的方法存根
        return 100;
    }
    class inner implements B{
        @Override
        public String f() {
            // TODO 自动生成的方法存根
            return "B";
        }
    }
}

执行结果是

100
B

　　今天就到这里。