内部类与控制框架

在我将要介绍的控制框架（control framework）中，可以看到更多使用内部类的具体例

子。

 

应用程序框架（application framework）就是被设计用以解决某类特定问题的一个类或

一组类。要使用某个应用程序框架，通常是继承一个或多个类，并重载某些方法。在重载

的方法中，你的代码将应用程序框架提供的通用解决方案特殊化，以解决你的特定问题（这

是设计模式中Template Method 的一个例子。控制框架是一类特殊的应用程序框架，它用来解决

响应事件的需求。主要是用来响应事件的系统被称作事件驱动系统（event-driven

system）。应用程序最重要的问题之一是图形用户接口（GUI），它几乎完全是事件驱动

的系统。在第十四章你会看到，Java Swing 库就是一个控制框架，它优雅地解决了 GUI

的问题，并使用了大量的内部类。

 

要理解内部类是如何允许简单的创建过程以及如何使用控制框架的，就请你考虑这样一个

控制框架的例子，它的工作就是在事件“就绪（ready）”的时候执行事件。虽然“就绪”

可以指任何事，但在本例中缺省的是基于时间触发的。接下来的问题就是，对于要控制什

么，控制框架并不包含任何具体的信息。那些信息是在实现“模板方法（template

method）”的时候，通过继承来提供的。

 

首先，接口描述了要控制的事件。因为其缺省的行为是基于时间去执行控制，所以使用抽

象类代替实际的接口。下面的例子包含了某些实现：

 

//:c08:controller:Event.java

// The commonmethods for any control event.

package c08.controller;

 

public   abstract    class Event {

private   long eventTime;

protected   final   long delayTime;

public Event(long delayTime) {

this.delayTime = delayTime;

    start();

  }

public   void start() {           // Allows restarting

    eventTime = System.currentTimeMillis() +delayTime;

  }

public   boolean ready() {

return System.currentTimeMillis() >=eventTime;

  }

public   abstract    void action();

}   ///:~

如果你希望运行Event，然后调用 start()，那么构造器就会捕获（从对象创建的时刻开始

的）时间，此时间是这样得来的：start()获取当前时间，然后加上一个延迟时间后，生成

触发事件的时间。start()是一个独立的方法，而没有包含在构造器内，因为这样你就可以

在事件运行以后重新启动计时器，也就是能够重复使用 Event 对象。例如，如果你要重复

一个事件，你只需简单地在 action()中调用 start()方法。

 

ready()告诉你现在可以运行 action()方法了。当然，可以在导出类中重载 ready()，使

得 Event 能够基于时间以外的其它因素而触发。

 

下面的文件包含了一个实际的管理并触发事件的控制框架。Event 对象被保存在 ArrayList

类型的容器对象中，容器会在第十一章中详细介绍。目前你只需要知道 add()方法将一个

Object 添加到 ArrayList 的尾端，size()方法得到 ArrayList 中元素的个数，get()通过索

引从 ArrayList 中获取一个元素，remove()方法从 ArrayList 中移除一个指定的元素。

 

//:c08:controller:Controller.java

// With Event,the generic framework for control systems.

package c08.controller;

import java.util.*;

 

public   class Controller {

// An objectfrom java.util to hold Event objects:

private List eventList =        new ArrayList();

public   void addEvent(Event c) { eventList.add(c); }

public   void run() {

while(eventList.size() > 0) {

for(int i = 0; i < eventList.size(); i++) {

        Event e = (Event)eventList.get(i);

if(e.ready()) {

          System.out.println(e);

          e.action();

          eventList.remove(i);

        }

      }

    }

  }

}   ///:~

 

run()方法循环遍历 eventList，通过 ready()寻找就绪的 Event。对找到的每一个就绪的

事件，使用toString()打印其信息，调用其 action()方法，然后从队列中移除此 Event。

注意，在目前的设计中你并不知道 Event 到底做了什么。这正是此设计的关键之处，“使

变化的事物与不变的事物相互分离”。用我的话说，“变化向量（vector of change）”

就是各种不同的Event 对象所具有的不同行为，而你通过创建不同的 Event 子类来表现不

同的行为。

 

这正是内部类要做的事情，你可以：

 

1.     用一个单独的类完整地实现一个控制框架，从而将实现的细节封装起来。内

部类用来表示解决问题所必需的各种不同的 action()。

2.    内部类能够轻易的访问外围类的任意成员，所以可以避免这种实现变得很笨

拙。如果没有这种能力，代码将变得很令人讨厌，以至于你肯定会选择别的

方法。

 

考虑此控制框架的一个特殊实现，用以控制温室的运作⁷：控制灯光、水、温度调节器的开

关，以及响铃和重新启动系统，每个行为都是完全不同的。控制框架的设计使得分离这些

不同的代码变得非常容易。使用内部类，可以在单一的类里面产生对同一个基类Event的多

种继承版本。对于温室系统的每一种行为，都继承一个新的Event内部类，并在要实现的

action()中编写控制代码。

 

作为典型的应用程序框架，GreenhouseControls 类继承自 Controller:

 

//:c08:GreenhouseControls.java

// Thisproduces a specific application of the

// controlsystem, all in a single class. Inner

// classesallow you to encapsulate different

//functionality for each type of event.

import com.bruceeckel.simpletest.*;

import c08.controller.*;

 

public   class GreenhouseControlsextends Controller {

private   static Test monitor = new Test();

private   boolean light = false;

public   class LightOn   extends Event {

public LightOn(long delayTime) {super(delayTime); }

public   void action() {

// Put hardwarecontrol code here to

// physicallyturn on the light.

      light = true;

    }

public String toString() {                   return   "Light is on"; }

  }

public   class LightOff extends Event { 

public LightOff(long delayTime) {super(delayTime); }

public   void action() {

// Put hardwarecontrol code here to

// physicallyturn off the light.

      light = false;

    }

public String toString() {                   return   "Light is off"; }

  }

private   boolean water = false;

public   class WaterOn  extends Event {

public WaterOn(long delayTime) {super(delayTime); }

public   void action() {

// Put hardwarecontrol code here.

      water = true;

    }

public String toString() {

return   "Greenhouse water is on";

    }

  }

public   class WaterOff extends Event {

public WaterOff(long delayTime) {super(delayTime); }

public   void action() {

// Put hardwarecontrol code here.

      water = false;

    }

public String toString() {

return   "Greenhouse water is off";

    }

  }

private String thermostat = "Day";

public   class ThermostatNight   extends Event {

public ThermostatNight(long delayTime) {

super(delayTime);

    }

public   void action() {

// Put hardwarecontrol code here.

      thermostat =    "Night";

    }

public String toString() {

return   "Thermostat on night setting";

    }

  }

public   class ThermostatDay   extends Event {

public ThermostatDay(long delayTime) {

    }

super(delayTime);

public   void action() {

// Put hardwarecontrol code here.

      thermostat =    "Day";

    }

public String toString() {

return   "Thermostat on day setting";

    }

  }

// An exampleof an action() that inserts a

// new one ofitself into the event list:

public   class Bell     extends Event {

public Bell(long delayTime) {              super(delayTime); }

public   void action() {

      addEvent(new Bell(delayTime));

    }

public String toString() {                   return   "Bing!"; }

  }

public   class Restart     extends Event {

private Event[] eventList;

public Restart(long delayTime, Event[] eventList) {

super(delayTime);

this.eventList = eventList;

for(int i = 0; i < eventList.length; i++)

        addEvent(eventList[i]);

    }

public   void action() {

for(int i = 0; i < eventList.length; i++) {

        eventList[i].start(); // Rerun each event

        addEvent(eventList[i]);

      }

      start();      // Rerun this Event

      addEvent(this);

    }

public String toString() {

return   "Restarting system";

    }

  }

public   class Terminate    extends Event {

public Terminate(long delayTime) {super(delayTime); }

public   void action() { System.exit(0); }

public String toString() {                   return   "Terminating"; }

  }

}   ///:~

 

注意，light、 water 和 thermostat 都属于外围类，而这些内部类能够自由地访问那些

成员变量，无需限定条件或特殊许可。而且，大多数 action()方法都涉及对某种硬件的控

制。

 

大多数 Event 类看起来都很相似，但是 Bell 和 Restart 则比较特别。Bell 控制响铃，然后

在事件列表中增加一个 Bell 对象，于是过一会儿它可以再次响铃。你可能注意到了内部类

是多么像的多重继承：Bell 和 Restart 有 Event 的所有方法，并且似乎也拥有外围类

GreenhouseContrlos所有的方法。

 

一个 Event 对象的数组被地交给 Restart，该数组要加到控制器上的。由于 Restart()也

是一个 Event 对象，所以你同样可以将 Restart 对象添加到 Restart.action()中，以使系

统能够有规律的重新启动它自己。

 

下面的类通过创建一个 GreenhouseControls 对象，并添加各种不同的 Event 对象来配

置该系统。这是命令（Command）设计模式的一个例子：

 

//:c08:GreenhouseController.java

// Configureand execute the greenhouse system.

// {Args: 5000}

import c08.controller.*;

 

public   class GreenhouseController {

public   static    void main(String[] args) {

    GreenhouseControls gc = new GreenhouseControls();

// Instead ofhard-wiring, you could parse

//configuration information from a text file here:

    gc.addEvent(gc.new Bell(900));

    Event[] eventList = {

      gc.new ThermostatNight(0),

      gc.new LightOn(200),

      gc.new LightOff(400),

      gc.new WaterOn(600),

      gc.new WaterOff(800),

      gc.new ThermostatDay(1400)

    };

    gc.addEvent(gc.new Restart(2000, eventList));

if(args.length == 1)

      gc.addEvent(

        gc.new Terminate(Integer.parseInt(args[0])));

    gc.run();

  }

}   ///:~

这个类的作用是初始化系统，所以它添加了所有相应的事件。当然，更灵活的方法是避免

对事件进行硬编码，取而代之的是从文件中读取需要的事件。（第十二章的练习会要求你

照此方法修改这个例子。）如果你提供了命令行参数，系统会以它作为毫秒数，决定什么

时候终止程序（这是测试程序时使用的）。

 

这个例子应该能使你更了解内部类的价值，特别是在控制框架中使用内部类的时候。而在

第十四章中，你将看到内部类如何优雅地描述图形用户界面的行为。到那时，你应该就完

全信服内部类的价值了。