Java核心技术第6章(3)

6.4 内部类

    内部类(inner class)是定义在另一个类中的类. 为什么需要使用内部类呢?其主要原因有以下三点:
    内部类方法可以访问该类定义所在的作用域中的数据,包括私有数据.
    内部类可以对同一个包中的其他类隐藏起来.
    当想要定义一个回调函数且不想编写大量代码时,使用匿名(annoymous)内部类比较便捷.
    注释:C++有嵌套类,一个被嵌套的类包含在外围类的作用域内.下面是一个典型的例子,一个链表类定义了一个存储结点的类和一个定义迭代器位置的类.

class LinkedList
{
public:
    class Iterator
    {
    public:
        void insert(int x);
        int erase();
        ...
    };
    ...
private:
    class Link
    {
    public:
        Link* next;
        int data;
    };
    ...
};

    嵌套是一种类之间的关系,而不是对象之间的关系.一个LinkedList对象并不包含Iterator类型或Link类型的子对象.
    嵌套类有两个好处:命名控制和访问控制.由于名字Iterator嵌套在LinkedList类的内部,所以在外部被命名为LinkedList::Iterator,这样就不会与其他名为Iterator的类发生冲突.在Java中这个并不重要,因为Java包已经提供了相同的命名控制,需要注意的是,Link类位于LinkedList类的私有部分,因此,Link对其他的代码均不可见.鉴于此情况,可以将Link的数据域设计为公有的,它仍然是安全的.这些数据域只能被LinkedList类中的方法访问,而不会暴露给其他的代码.在Java中,只有内部类能够实现这样的控制.
    然而,Java内部类还有另外一个功能,这使得它比C++的嵌套类更加丰富,用途更加广泛. 内部类的对象有一个隐式引用,它引用了实例化该内部对象的外围类对象.通过这个指针,可以访问外围类对象的全部状态.

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

    下面分析TimerTest示例,并抽象出一个TalkingClock类,构造一个语音时钟时需要提供两个参数:发布通告的间隔和开关铃声的标志.

public class TalkingClock
{
    private int interval;
    private boolean beep;

    public TalkingClock(int interval, boolean beep) { ... }
    public void start() { ... }
    public class TimePrinter implements ActionListener
    {
        ...
    }
}

    需要注意,这里的TimePrinter类位于TalkingClock类内部,这并不意味着每个TalkingClock都有一个TimePrinter实例域.
    下面是TimePrinter类的详细部分.需要注意一点,actionPerformed方法在发出铃声之前检查了beep标志.

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

    令人惊讶的事情发生了,TimePrinter类没有实例域或者名为beep的变量,取而代之的是beep引用了创建TimePrinter的TalkingClock对象的域.这是一种创新的想法.从传统意义上将,一个方法可以引用调用这个方法的对象数据域.内部类既可以访问自身的数据域,也可以访问创建它的外围类对象的数据域.
    为了能够运行这个程序,内部类的对象总有一个隐式引用,它指向了创建它的外部类对象.
    这个引用在内部类的定义中是不可见的,然而,为了说明这个概念,我们将外围类对象的引用称为outer,于是actionPerformed方法等价于下列形式:

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

    外围类的引用在构造器中设置,编译器修改了所有的内部类的构造器,添加一个外围类引用的参数,因为TimePrinter类没有定义构造器,所以编译器为这个类生成了一个默认的构造器,其代码如下所示:

public TimePrinter(TalkingClock clock)
{
    outer = clock;
}

    注意,outer不是Java的关键字,我们只是用它说明内部类中的机制.
    当在start方法中创建了TimePrinter对象后,编译器就会将 this 引用传递给当前的语音时钟的构造器:

ActionListener listener = new TimePrinter(this);    

    注释:TimePrinter类声明为私有的,这样一来,只有TalkingClock的方法才能构造TimePrinter对象, 只有内部类可以是私有类,而常规类只可以具有包可见性,或公有可见性.
    innerClass/InnerClassTest.java如下所示:

package innerClass;

import javax.swing.*;

/**
 * This program demonstrates the use of inner classes.
 */
public class InnerClassTest
{
    public static void main(String[] args)
    {
        TalkingClock clock = new TalkingClock(1000, true);
        clock.start();

        // keep program running until user selects "OK"
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

    innerClass/TalkingClock.java如下所示:

package innerClass;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

public class TalkingClock
{
    private int interval;
    private boolean beep;

    /**
     * Constructs a talking clock
     * @param interval the interval between messages(in milliseconds)
     * @param beep true if the clock should 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)
        {
            Date now = new Date();
            System.out.println("At the tone, the time is " + now);
            if (beep)
                Toolkit.getDefaultToolkit().beep();
        }
    }
}

    运行结果如下所示:

6.4.2   内部类的特殊语法规则

    在上一节中,已经讲述了内部类有一个外围类的引用outer,事实上,使用外围类引用的正规语法还要复杂一些.表达式

OuterClass.this

    表示外围类引用.例如,可以像下面这样编写TimePrinter内部类的actionPerformed方法:

public void actionPerformed(ActionEvent event)
{
    ...
    if (TalkingClock.this.beep)
        Toolkit.getDefaultToolkit().beep();
}

    反过来,可以采用下列语法格式更加明确地编写内部对象的构造器:

outerObject.new InnerClass(construction parameters);

    例如,

ActionListener listener = this.new TimePrinter();

    在这里,最新构造的TimePrinter对象的外围类应用被设置为内部类对象的方法中的 this 引用.这是一种最常见的情况,通常,this 限定词是多余的.不过可以通过显式地命名将外围类引用设置为其他的对象.例如,如果TimePrinter是一个公有内部类,对于任意的语音时钟都可以构造一个TimePrinter:

TalkingClock jabberer = new TalkingClock(1000, true);
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();

    需要注意,在外围类的作用域之外,可以这样应用内部类:

OuterClass.InnerClass

6.4.3   内部类是否有用,必要和安全

    内部类是一种编译器现象,与虚拟机无关. 编译器将会把内部类翻译成用$分隔外部类名与内部类名的常规类文件,而虚拟机则对此一无所知.
    例如,在TalkingClock类内部的TimePrinter类将翻译成类文件TalkingClock$TimePrinter.class .
    如下所示(在TalkingClock与TimePrinter之间有一个$符号, 说明TimePrinter是TalkingClock的内部类):