关于内部类的知识

看了下内部类，大致对当前学习的做一个小结

内部类，是定义在另外一个类中的类。

使用内部类的原因：

1.内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据域

2.内部类可以同时对一个包中的其他类隐藏起来

3.当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类会更加的便捷

使用内部类访问对象的状态

代码如下：

package com.caoduanxi.Core;

import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

import javax.swing.JOptionPane;
import javax.swing.Timer;

/**
 * 测试内部类
 *
 */
public class book246 {
    public static void main(String[] args) {
        TalkingClock clock = new TalkingClock(1000, true);
        clock.start();
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

class TalkingClock{
    private int interval;
    private boolean beep;
    
    public TalkingClock(int interval, boolean beep) {
        super();
        this.interval = interval;
        this.beep = beep;
    }
    
    public void start() {
        ActionListener listener = new TimePrinter();
        Timer t = new Timer(interval, listener);
        t.start();
    }
    //内部类 
    //内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域 beep
    //内部类不能有static方法
    public  class TimePrinter implements ActionListener{
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("At the tone, the time is "+ new Date());
            if (beep) {
                Toolkit.getDefaultToolkit().beep();
            }
        }
    }
}

局部内部类，将上述代码稍作改动即可

package com.caoduanxi.Core;

import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

import javax.swing.JOptionPane;
import javax.swing.Timer;


public class book250 {
    public static void main(String[] args) {
        TalkClock clock = new TalkClock(1000, true);
        clock.start();
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

class TalkClock{
    private int interval;
    private boolean beep;
    
    public TalkClock(int interval, boolean beep) {
        super();
        this.interval = interval;
        this.beep = beep;
    }
    
    //局部内部类不能赢public或者private访问说明符进行声明
    //作用域被限定在声明的这个局部类的块中
    //局部类的优势：对外界世界可以完全的隐藏起来
    public void start() {
        class TimePrinter implements ActionListener{
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("At the tone, the time is "+ new Date());
                if (beep) {
                    Toolkit.getDefaultToolkit().beep();
                }
            }
        }
        ActionListener listener = new TimePrinter();
        Timer t = new Timer(interval, listener);
        t.start();
    }
}

关于匿名内部类，匿名内部类是局部内部类深入一步的产物

一般的话如果只创建这个类的一个对象的话，就不需要命名了，此时就是使用我们的匿名内部类

package com.caoduanxi.Core;

import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

import javax.swing.JOptionPane;
import javax.swing.Timer;


public class book251 {
    public static void main(String[] args) {
        TalkClock2 clock = new TalkClock2();
        clock.start(1000, true);
        
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

class TalkClock2{
    //匿名内部类
    public void start(int interval, boolean beep) {
            ActionListener listener = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    System.out.println("At the tone, the time is "+ new Date());
                    if (beep) {
                        Toolkit.getDefaultToolkit().beep();
                    }
                }
            };
        Timer t = new Timer(interval, listener);
        t.start();
    }
}

注意由于构造器的名字与类名相同，而你匿名类没有类名，故匿名类没有构造器

相应的处理做法是将构造器传递给超类构造器

静态内部类

如果使用static来修饰一个内部类，这个内部类就属于外部类本身，而不属于外部类的某个对象，因此使用static修饰的内部类被称为类内部类，有的地方也称为静态内部类