02-深入内部类
一、前言
可将一个类定义置入另一个类定义中,这就叫作“内部类”。内部类对我们非常有用，因为利用它可对那些逻辑上相互联系的类进行分组，并可控制一个类在另一个类里的“可见性”
二、内部类的定义：
public class Parcel1 { class Contents { private int i = 11; public int value() { return i; } } class Destination { private String label; Destination(String whereTo) { label = whereTo; } String readLabel() { return label; } } // Using inner classes looks just like // using any other class, within Parcel1: public void ship(String dest) { Contents c = new Contents(); Destination d = new Destination(dest); } public static void main(String[] args) { Parcel1 p = new Parcel1(); p.ship("Tanzania");
Parcel1.Contents c = p.new Contents() ; } } // /:~
注意创建内部类对象的方式
三、在方法或者作用域中使用内部类
3.1在一个方法或者任意的作用域中使用内部类一般有两个目的：
1：准备实现某种形式的接口，使自己的程序能创建或者返回一个句柄
2: 要解决一个复杂的问题，并希望创建一个类用来辅助自己的程序方案 同时又不愿意把它公开
为目的1来一个例子：
//: Parcel3.java // Returning a handle to an inner class package c07.parcel3; abstract class Contents { abstract public int value(); } interface Destination { String readLabel(); } public class Parcel3 { private class PContents extends Contents { private int i = 11; public int value() { return i; } } protected class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new PDestination(s); } public Contents cont() { return new PContents(); } } class Test { public static void main(String[] args) { Parcel3 p = new Parcel3(); Contents c = p.cont(); Destination d = p.dest("Tanzania"); // Illegal -- can't access private class: // ! Parcel3.PContents c = p.new PContents(); } } // /:~
3.2 在一个方法内创建内部类
为例子的需要先创建两个接口：
//: Destination.java package c07.innerscopes; interface Destination { String readLabel(); } ///:~ //: Contents.java package c07.innerscopes; interface Contents { int value(); } ///:~ //: Wrapping.java package c07.innerscopes; public class Wrapping { private int i; public Wrapping(int x) { i = x; } public int value() { return i; } } ///:~
在一个方法中定义一个内部类 ：
//: Parcel4.java // Nesting a class within a method package c07.innerscopes; public class Parcel4 { public Destination dest(String s) { //在方法的一个作用域内定义的类 class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; //TODO handle label } public String readLabel() { return label; } } return new PDestination(s); } public static void main(String[] args) { Parcel4 p = new Parcel4(); Destination d = p.dest("Tanzania"); System.out.println(d.readLabel()); ; } } // /:~
方法dest需要返回一个Destination 类型的对象，通常的操作是在方法外部（在同一个类中定义一个内部类或者新增加一个类）实现一个Destination 接口的类 然后在dest方法中返回该类对象
这样子做的话很显然会将该类的实现暴漏在dest方法外部 如果操作只对dest方法可见（或者说是唯一针对该方法的操作） 那么在类中定义一个内部类很有必要。当然，不能由于类PDestination 的名字置于
dest()内部，就认为在dest()返回之后PDestination 不是一个有效的对象。
3.3在任意的作用域内定义内部类
//: Parcel5.java // Nesting a class within a scope package c07.innerscopes; public class Parcel5 { private void internalTracking(boolean b) { if (b) { class TrackingSlip { private String id; TrackingSlip(String s) { id = s; } String getSlip() { return id; } } TrackingSlip ts = new TrackingSlip("slip"); String s = ts.getSlip(); System.out.println(s); } // Can't use it here! Out of scope: // ! TrackingSlip ts = new TrackingSlip("x"); } public void track() { internalTracking(true); } public static void main(String[] args) { Parcel5 p = new Parcel5(); p.track(); } } // /:~
TrackingSlip 类嵌套于一个if 语句的作用域内。这并不意味着类是有条件创建的——它会随同其他所有东西得到编译。然而，在定义它的那个作用域之外，它是不可使用的。除这些以外，它看起来和
一个普通类并没有什么区别。
3.4 匿名内部类
//: Parcel6.java // A method that returns an anonymous inner class package c07.innerscopes; public class Parcel6 { public Contents cont() { return new Contents() { private int i = 11; public int value() { return i; } }; // Semicolon required in this case } public static void main(String[] args) { Parcel6 p = new Parcel6(); Contents c = p.cont(); System.out.println(c.value()); } } // /:~
在匿名内部类中，Contents 是用一个默认构建器创建的，那么如果需要基础类中构造方法含有参数又如何是实现呢？
//: Parcel7.java // An anonymous inner class that calls the // base-class constructor package c07.innerscopes; public class Parcel7 { public Wrapping wrap(int x) { // Base constructor call: return new Wrapping(x) { public int value() { return super.value() * 47; } }; // Semicolon required } public static void main(String[] args) { Parcel7 p = new Parcel7(); Wrapping w = p.wrap(10); } } // /:~
要注意的是：匿名内部类既然是匿名的 那么肯定是没有构造方法的（匿名内部类没有构造方法） 那么一个新的问题又来了，没有构造方法 如何初始化呢？
//: Parcel8.java // An anonymous inner class that performs // initialization. A briefer version // of Parcel5.java. package c07.innerscopes; public class Parcel8 { // Argument must be final to use inside // anonymous inner class: public Destination dest(final String dest) { return new Destination() { private String label = dest; public String readLabel() { return label; } }; } public static void main(String[] args) { Parcel8 p = new Parcel8(); Destination d = p.dest("Tanzania"); } } // /:~
通过上面的例子知道： 可在定义自己的字段时进行初始化，但想使用在匿名内部类外部定义的一个对象，则编译器要求外部对象为final属性。不过新的问题又来了 按照上面的初始化只能对简单
类的属性进行初始化 ，如果要想进行一些逻辑操作的话 上面那种方法显然不适用，此时又如何处理？ 联系到第一节讲的初始化顺序 可以通过一个普通代码块来模拟一个构造代码块
//: Parcel9.java // Using "instance initialization" to perform // construction on an anonymous inner class package c07.innerscopes; public class Parcel9 { public Destination dest(final String dest, final float price) { return new Destination() { private int cost; // Instance initialization for each object: { //普通代码块来模拟一个构造代码块 System.out.println("Instance initialization for each object:"); cost = Math.round(price); if (cost > 100) //逻辑判断 System.out.println("Over budget!"); } private String label = dest; public String readLabel() { System.out.println(label); return label; } }; } public static void main(String[] args) { Parcel9 p = new Parcel9(); Destination d = p.dest("Tanzania", 101.395F); } } // /:~
四、 访问外部类
前面的例子都展示的是通过内部类来影藏或者代码组织的方法 ，但似乎并不特别引人注目。然而，我们还忽略了另一个重要的事实。创建自己的内部类时，那个类的对象同时拥有指向封装对象（这些对象封装或生成了内部类）的一个链接。所以它们能访问那个封装对象的成员——毋需取得任何资格。除此以外，内部类拥有对封装类所有元素的访问权限。
//: Sequence.java // Holds a sequence of Objects interface Selector { boolean end(); Object current(); void next(); } public class Sequence { private Object[] o; private int next = 0; public Sequence(int size) { o = new Object[size]; } public void add(Object x) { if (next < o.length) { o[next] = x; next++; } } private class SSelector implements Selector { int i = 0; public boolean end() { return i == o.length; } public Object current() { return o[i]; } public void next() { if (i < o.length) i++; } } public Selector getSelector() { return new SSelector(); } public static void main(String[] args) { Sequence s = new Sequence(10); for (int i = 0; i < 10; i++) s.add(Integer.toString(i)); Selector sl = s.getSelector(); while (!sl.end()) { System.out.println((String) sl.current()); sl.next(); } } } // /:~
五、内部类的继承问题
由于内部类构建器必须同封装类对象的一个句柄联系到一起，所以从一个内部类继承的时候，情况会稍微变得有些复杂。这儿的问题是封装类的“秘密”句柄必须获得初始化，而且在衍生类中不再有一个默认的对象可以连接。解决这个问题的办法是采用一种特殊的语法，明确建立这种关系
//: InheritInner.java // Inheriting an inner class class WithInner { class Inner {} } public class InheritInner extends WithInner.Inner { //! InheritInner() {} // Won't compile InheritInner(WithInner wi) { wi.super(); } public static void main(String[] args) { WithInner wi = new WithInner(); InheritInner ii = new InheritInner(wi); } } ///:~
如果继承一个父类，父类中定义了一个内部类，那么在子类中能覆盖内部类吗?
//: BigEgg.java // An inner class cannot be overriden // like a method class Egg { protected class Yolk { public Yolk() { System.out.println("Egg.Yolk()"); } } private Yolk y; public Egg() { System.out.println("New Egg()"); y = new Yolk(); } } public class BigEgg extends Egg { public class Yolk { public Yolk() { System.out.println("BigEgg.Yolk()"); } } public static void main(String[] args) { new BigEgg(); } } // /:~
默认构建器是由编译器自动合成的，而且会调用基础类的默认构建器。大家或许会认为由于准备创建一个BigEgg，所以会使用Yolk 的“被覆盖”版本。但实际情况并非如此。输出如下：
New Egg()
Egg.Yolk()
这个例子简单地揭示出当我们从外部类继承的时候，没有任何额外的内部类继续下去。然而，仍然有可能“明确”地从内部类继承：
//: BigEgg2.java // Proper inheritance of an inner class class Egg2 { protected class Yolk { public Yolk() { System.out.println("Egg2.Yolk()"); } public void f() { System.out.println("Egg2.Yolk.f()"); } } private Yolk y = new Yolk(); public Egg2() { System.out.println("New Egg2()"); } public void insertYolk(Yolk yy) { y = yy; } public void g() { y.f(); } } public class BigEgg2 extends Egg2 { public class Yolk extends Egg2.Yolk { public Yolk() { System.out.println("BigEgg2.Yolk()"); } public void f() { System.out.println("BigEgg2.Yolk.f()"); } } public BigEgg2() { insertYolk(new Yolk()); } public static void main(String[] args) { Egg2 e2 = new BigEgg2(); e2.g(); } } // /:~
new BigEgg2() 执行分析：
* BigEgg2 extends Egg2 因此需要先执行Egg2中的变量初始化 + 构造方法：
* 初始化y 打印Egg2.Yolk() 构造方法打印：New Egg2()
* -->接着执行 BigEgg2的构造方法 调用 new Yolk() 此时的new Yolk 调用的是BigEgg2中的Yolk类的构造方法（覆盖了父类的方法）
* 是调用该构造方法的时候要先调用父类的构造方法 打印Egg2.Yolk() 然后调用本身Yolk构造方法打印 BigEgg2.Yolk()
* 调用 e2.g() 打印的是BigEgg2中的 Yolk的f() 打印 BigEgg2.Yolk.f()
* 因此打印结果如下：
* Egg2.Yolk()
* New Egg2()
* Egg2.Yolk()
* BigEgg2.Yolk()
* BigEgg2.Yolk.f()
六、控制框架
一个“应用程序框架”是指一个或一系列类，它们专门设计用来解决特定类型的问题。为应用应用程序框架，我们可从一个或多个类继承，并覆盖其中的部分方法。我们在覆盖方法中编写的代码用于定制由那些
应用程序框架提供的常规方案，以便解决自己的实际问题。“控制框架”属于应用程序框架的一种特殊类型受到对事件响应的需要的支配；主要用来响应事件的一个系统叫作“由事件驱动的系统”。在应用程序设
计语言中，最重要的问题之一便是“图形用户界面”（GUI），它几乎完全是由事件驱动的。 AWT 属于一种控制框架，它通过内部类完美地解决了GUI 的问题。为理解内部类如何简化控制框架的创建与使用，
可认为一个控制框架的工作就是在事件“就绪”以后执行它们。 请认识到针对控制框架需要控制的东西，框架内并未包含任何特定的信息。首先，它是一个特殊的接口，描述了所有控制事件。它可以是一个抽
象类，而非一个实际的接口。
//: Event.java
// The common methods for any control event
package c07.controller;
abstract public class Event {
private long evtTime;
public Event(long eventTime) {
evtTime = eventTime;
}
public boolean ready() {
return System.currentTimeMillis() >= evtTime;
}
abstract public void action();
abstract public String description();
} // /:~
//: Controller.java // Along with Event, the generic // framework for all control systems: package c07.controller; // This is just a way to hold Event objects. class EventSet { private Event[] events = new Event[100]; private int index = 0; private int next = 0; public void add(Event e) { if (index >= events.length) return; // (In real life, throw exception) events[index++] = e; } public Event getNext() { boolean looped = false; int start = next; do { next = (next + 1) % events.length; //可以循环遍历下去 // See if it has looped to the beginning: if (start == next) looped = true; // If it loops past start, the list // is empty: if ((next == (start + 1) % events.length) && looped) return null; } while (events[next] == null); return events[next]; } public void removeCurrent() { events[next] = null; } } public class Controller { private EventSet es = new EventSet(); public void addEvent(Event c) { es.add(c); } public void run() { Event e; while ((e = es.getNext()) != null) { if (e.ready()) { e.action(); System.out.println(e.description()); es.removeCurrent(); } } } } // /:~
设计了Event类我们仍然不能准确地知道一个“事件”要做什么。这正是整个设计的关键，它怎样“将发生变化的东西同没有变化的东西区分开”？或者用我的话来讲，“改变的意图”造成了各类Event 对象
的不同行动。我们通过创建不同的Event 子类，从而表达出不同的行动。这里正是内部类大显身手的地方。
它们允许我们做两件事情：
(1) 在单独一个类里表达一个控制框架应用的全部实施细节，从而完整地封装与那个实施有关的所有东西。内部类用于表达多种不同类型的action()，它们用于解决实际的问题。除此以外，后续的例子
使用了private 内部类，所以实施细节会完全隐藏起来，可以安全地修改。
(2) 内部类使我们具体的实施变得更加巧妙，因为能方便地访问外部类的任何成员。若不具备这种能力，代码看起来就可能没那么使人舒服，最后不得不寻找其他方法解决。
具体实施方式，它设计用来控制温室（Greenhouse）功能 每个行动都是完全不同的：控制灯光、供水以及温度自动调节的开与关，控制响铃，以及重新启动系统。但控
制框架的设计宗旨是将不同的代码方便地隔离开。对每种类型的行动，都要继承一个新的Event 内部类，并在action() 内编写相应的控制代码。
//: GreenhouseControls.java // This produces a specific application of the // control system, all in a single class. Inner // classes allow you to encapsulate different // functionality for each type of event. package c07.controller; public class GreenhouseControls extends Controller { private boolean light = false; private boolean water = false; private String thermostat = "Day"; private class LightOn extends Event { public LightOn(long eventTime) { super(eventTime); } public void action() { // Put hardware control code here to // physically turn on the light. light = true; } public String description() { return "Light is on"; } } private class LightOff extends Event { public LightOff(long eventTime) { super(eventTime); } public void action() { // Put hardware control code here to // physically turn off the light. light = false; } public String description() { return "Light is off"; } } private class WaterOn extends Event { public WaterOn(long eventTime) { super(eventTime); } public void action() { // Put hardware control code here water = true; } public String description() { return "Greenhouse water is on"; } } private class WaterOff extends Event { public WaterOff(long eventTime) { super(eventTime); } public void action() { // Put hardware control code here water = false; } public String description() { return "Greenhouse water is off"; } } private class ThermostatNight extends Event { public ThermostatNight(long eventTime) { super(eventTime); } public void action() { // Put hardware control code here thermostat = "Night"; } public String description() { return "Thermostat on night setting"; } } private class ThermostatDay extends Event { public ThermostatDay(long eventTime) { super(eventTime); } public void action() { // Put hardware control code here thermostat = "Day"; } public String description() { return "Thermostat on day setting"; } } // An example of an action() that inserts a // new one of itself into the event list: private int rings; private class Bell extends Event { public Bell(long eventTime) { super(eventTime); } public void action() { // Ring bell every 2 seconds, rings times: System.out.println("Bing!"); if (--rings > 0) addEvent(new Bell( System.currentTimeMillis() + 2000)); } public String description() { return "Ring bell"; } } private class Restart extends Event { public Restart(long eventTime) { super(eventTime); } public void action() { long tm = System.currentTimeMillis(); // Instead of hard-wiring, you could parse // configuration information from a text // file here: rings = 5; addEvent(new ThermostatNight(tm)); addEvent(new LightOn(tm + 1000)); addEvent(new LightOff(tm + 2000)); addEvent(new WaterOn(tm + 3000)); addEvent(new WaterOff(tm + 8000)); addEvent(new Bell(tm + 9000)); addEvent(new ThermostatDay(tm + 10000)); // Can even add a Restart object! addEvent(new Restart(tm + 20000)); } public String description() { return "Restarting system"; } } public static void main(String[] args) { GreenhouseControls gc = new GreenhouseControls(); long tm = System.currentTimeMillis(); gc.addEvent(gc.new Restart(tm)); gc.run(); } } // /:~
