关于Java中的内部类（java核心卷1有感）

关于Java中的内部类：

​ 为什么要使用内部类：

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

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

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

eg：

​

public class TalkingClock
{
private int interval:
private boolean beep;
public TalkingClock(int interval, boolean beep) { . . . }
public void start0 { • . . }
public class TimePrinter implements ActionListener
// an inner class
{
	......
} 
}
//下面为内部类TimePrinter的具体实现内容
public class TimePrinter implements ActionListener
{
public void actionPe「formed(ActionEvent event) {
	System.out.println("At the tone, the time is " + new Date());
if (beep) Toolkit.getDefaultToolkit().beep();
} 
}
//TimePrinter没有实例域或名为beep的变量,beep引用了创建TimePrinter的TalkingClock的域
内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。

内部类的对象总有一个隐式引用，它指向了创建它的外部类对象。

这个引用在内部类的定义中是不可见的，这里将外围类对象的引用成为outer。（outer不是关键字）

只有内部类可以为私有类，而常规类只可以具有包可见性，或公有可见性。

eg：

//这是一个实时的钟表
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.Timer;

public class InnerClassTest {
    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)
    {
        this.interval = interval;
        this.beep = beep;
    }

    public void start()
    {
        ActionListener listener = new TimePrinter();
        Timer t = new Timer(interval,listener);
        t.start();
    }

    public class TimePrinter implements ActionListener
    {
        public void actionPerformed(ActionEvent event)
        {
            System.out.println("At the tone,the time is" + new Date());
            if(beep) Toolkit.getDefaultToolkit().beep();
        }
    }
}

匿名内部类：

​ 假如只创建这个类的一个对象，就不必命名。这种类被称为匿名内部类。

​ 由于构造器的名字必须与类名相同，而匿名类没有类名，所以，匿名类不能有构造器。取而代之的是，将构造器参数传递给超类构造器。

eg：

Person queen = new Person("Mary");
//a Person object
Person count = new Person("Dracula"){....};
//an object of an inner class extending Person
如果构造参数的小括号后面跟一个开大括号，正在定义的就是匿名内部类

//这是使用匿名内部类
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;

public class AnnoymousInnerClassTest {
    public static void main(String[] args){
        TalkingClock clock = new TalkingClock();
        clock.start(1000,true);

        JOptionPane.showMessageDialog(null,"Quit program?");
        System.exit(0);
    }
}

class TalkingClock
{
    public void start(int interval, boolean beep)
    {
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent event) {
                System.out.println("At the tone, the time is" + new Date());
                if(beep) Toolkit.getDefaultToolkit().beep();
            }
        };
        Timer t = new javax.swing.Timer(interval,listener);
        t.start();
    }
}

还有一种方法称为“双括号初始化“：

ArrayList<String> friends = new ArrayList<>();
friends.add("Marry");
friends.add("Tony");
invite(friends);

//如果不需要这个数组列表，最好让它作为一个匿名列表，添加方法如下：
invite(new ArrayList<String>(){{add("Marry"); add("Tony");}})
//注意这里的双括号。外层括号建立了ArrayList的一个匿名子类。内层括号是一个对象构造块

静态内部类：

​ 在内部类不需要访问外围类对象的时候，应该使用静态内部类。

​ 与常规内部类不同，静态内部类可以有静态域和方法。

g>(){{add(“Marry”); add(“Tony”);}})
//注意这里的双括号。外层括号建立了ArrayList的一个匿名子类。内层括号是一个对象构造块

静态内部类：

​	在内部类不需要访问外围类对象的时候，应该使用静态内部类。

​	与常规内部类不同，静态内部类可以有静态域和方法。

​	声明在接口中的内部类自动称为static和public类