第十章内部类

第十章 内部类

可以将一个类的定义放在另一个类的定义内部，这就是内部类

允许你把一些逻辑相关的类组织在一起

10.1 创建内部类

把类的定义置于外围类的里面

外部类有一个方法，该方法返回指向内部类的引用

任意位置创建某个内部类对象

OuterClassName.InnerClassName

public Destination to(String s){
	return new Destination
}

练习1

 Write a class named Outer that contains an inner class named Innet. 
* Add a method to Outer that returns an object of type Inner. In main(),
* create and initialize a reference to an Inner.

public class No1Outer {
    class Inner {
        Inner() { System.out.println("Inner()"); }
    }
    No1Outer() { System.out.println("Outer1()"); }
    // make an Inner from within a non-static method of outer class:
    Inner makeInner() {
        return new Inner();
    }
    public static void main(String[] args) {
        No1Outer o = new No1Outer();
        Inner i = o.makeInner();
    }
}
==========================================================
Outer1()
Inner()

10.2 连接到外部类

内部类似乎只是一种名字隐藏和组织代码模式。当生成一个内部类对象, 此对象与制造它的外围对象就有了一种联系。它能访问外围对象的所有成员，而不需要特殊条件，内部类还拥有其外围类的所有元素的访问权。

这是怎么做到的呢？

​ 当某个外围类的对象创建了一个内部类对象时，此内部类必定会秘密地捕获一个指向那个外围类对象地引用。然后在你访问此外围类地成员时，就是用那个引用来选择外围类的成员。 编译器会帮你处理细节

​ 内部类的对象只能与其外围类的对象相关联的情况下才能被创建（就想你应该看到的，在内部类非static类时）。构建内部类对象时，需要一个指向其外围类对象的引用，如果编译器访问不到这个引用就会报错。不过绝大多数这都无需程序员操心。

练习2

/* Create a class that holds a String, and has a toString() method that
 * displays this String. Add several instances of your new class to a
 * Sequence ojbect, then display them.
 */

class Word {
    private String word;
    public Word(String s) { word = s; }
    public String toString() { return word; }
}

interface Selector {
    boolean end();
    Object current();
    void next();
}

public class No2Sequence {
    private Object[] items;
    private int next = 0;
    public No2Sequence(int size) { items = new Object[size]; }
    public void add(Object x) {
        if(next < items.length)
            items[next++] = x;
    }
    //内部类
    private class SequenceSelector implements Selector {
        private int i = 0;
        public boolean end() { return i == items.length; }
        public Object current() { return items[i]; }
        public void next() { if(i < items.length) i++; }
    }
    public Selector selector() {
        return new SequenceSelector();
    }
    public static void main(String[] args) {
        No2Sequence sequence = new No2Sequence(10);
        for(int i = 0; i < 10; i++)
            sequence.add(new Word(Integer.toString(i)));
        Selector selector = sequence.selector();
        while(!selector.end()) {
            System.out.print(selector.current() + " ");
            selector.next();
        }
        Word w1 = new Word("Peace");
        Word w2 = new Word("Love");
        Word w3 = new Word("Easter");
        No2Sequence message = new No2Sequence(3);
        message.add(w1);
        message.add(w2);
        message.add(w3);
        Selector sel = message.selector();
        while(!sel.end()) {
            System.out.print(sel.current() + " ");
            sel.next();
        }

    }
}
==============================================================
0 1 2 3 4 5 6 7 8 9 Peace Love Easter

练习3

/* Modify Exercise 1 so that Outer has a private String field (initialized
* by the constructor), and Inner has a toString() that displays this field.
* Create an object of type Inner and display it.

package 第十章内部类;

public class No3Innter {
    private String s;
    class Inner3 {
        Inner3() { System.out.println("Inner()"); }
        public String toString() { return s; }
    }
    No3Innter(String s) {
        System.out.println("Outer1()");
        this.s = s;
    }
    Inner3 makeInner3() {
        return new Inner3();
    }
    public static void main(String[] args) {
        No3Innter o = new No3Innter("Hi is risen!");
        Inner3 i = o.makeInner3();
        System.out.println(i.toString());
    }
}
==========================================================================
Outer1()
Inner()
Hi is risen! 

10.3 使用.this 与 .new

.this

如果你需要生成对外部类对象的引用，可以使用外部类的名字后面紧跟 圆点和this。这样产生的自动引用具有正确的类型，这一点在编译器就被知晓并受到检查。因此没有任何运行时开销。

.new

如果你想要告诉其他对象，去创建某个内部类的对象。.new 表达式中提供对其他外部对象的引用。

在拥有外部类对象之前是不可能创建内部类对象的，这是因为内部类对象会暗暗的连接到创建它的外部类对象上，如果你创建的是 ** 嵌套类 （静态内部类），那么它不需要对外部类对象的引用**

练习4

/* Add a method to the class Sequence.SequenceSelector that produces the 
* reference to the outer class Sequence.

package 第十章内部类;
public class No4Sequence {
    private Object[] items;
    private int next = 0;
    // to test SequenceSelector sequence4() in main():
    public void test() { System.out.println("Sequence4.test()"); }
    public No4Sequence(int size) { items = new Object[size]; }
    public void add(Object x) {
        if(next < items.length)
            items[next++] = x;
    }
    private class SequenceSelector implements Selector {
        private int i = 0;
        public boolean end() { return i == items.length; }
        public Object current() { return items[i]; }
        public void next() { if(i < items.length) i++; }
        // method to produce outer class reference:
        public No4Sequence sequence4() { return No4Sequence.this; }//内部类引用外部类对象
    }
    public Selector selector() {
        return new SequenceSelector();
    }
    public static void main(String[] args) {
        No4Sequence sequence = new No4Sequence(10);
        for(int i = 0; i < 10; i++)
            sequence.add(Integer.toString(i));
        Selector selector = sequence.selector();
        while(!selector.end()) {
            System.out.print(selector.current() + " ");
            selector.next();
        }
        // cast and test:
        ((SequenceSelector)selector).sequence4().test();
    }
}
====================================================================
0 1 2 3 4 5 6 7 8 9 Sequence4.test()

练习5

/* Create a class with an inner class. In a separate class, make an
 * instance of the inner class.
 */

class Outer {
    class Inner {
        Inner() { System.out.println("Outer.Inner()"); }
    }
}


public class No6OtherOuter {
    public static void main(String[] args) {
        // must first create outer class object:
        Outer o = new Outer();
        // then create inner class object:
        Outer.Inner oi = o.new Inner();
    }
}
==============================================================
0 1 2 3 4 5 6 7 8 9 Sequence4.test()

10.4 内部类与向上转型

当内部类向上转型为基类，尤其是转型为一个接口的时候，内部类就有了用武之地。

/* Create an interface with at least one method, in its own package. Create
* a class in a separate package. Add a protected inner class that 
* implements the interface. In a third package, inherit from your class and
* inside a method, return an object of the protected inner class, upcasting
* to the interface during the return.
*/

/* // in separate package:
* public interface Ex6Interface {
*	String say();
* }
*
* // and in a second package:
* public class Ex6Base {
*	protected class Ex6BaseInner implements Ex6Interface {
*		// need public constructor to create one in Ex6Base child: 
*		public Ex6BaseInner() { }
*		public String say() { return "Hi"; }
*	}
* }
*/ 

import innerclasses.ex6Interface.*;
import innerclasses.ex6Base.*;

public class Ex6 extends Ex6Base {
	Ex6Interface getBaseInner() { 
		return this.new Ex6BaseInner();
	}
	public static void main(String[] args) {
		Ex6 ex = new Ex6();
		System.out.println(ex.getBaseInner().say());
	}	
=========================================================
    hi    

练习7

/* Create a class with a private field and a private method. Create an
* inner class with a method that modifies the outer-class field and calls
* the outer class method. In a second outer-class method, create an object
* of the inner class and call its method, then show the effect on the
* outer-class object. 
*/

class No7Outer {
    private int oi = 1;
    private void hi() { System.out.println("Outer hi"); }
    class Inner {
        void modifyOuter() {
            oi *= 2;
            hi();
        }
    }
    public void showOi() { System.out.println(oi); }
    void testInner() {
        Inner in = new Inner();
        in.modifyOuter();
    }
    public static void main(String[] args) {
        No7Outer out = new No7Outer();
        out.showOi();
        out.testInner();
        out.showOi();
    }
}
=============================================================
1
Outer hi
2

练习8

 /*Determine whether an outer class has access to the private elements of 
* its inner class. */
class No8Outer {
    class Inner {
        private int ii1 = 1;
        private int ii2 = 2;
        private void showIi2() { System.out.println(ii2); }
        private void hi() { System.out.println("Inner hi"); }
    }
    // Need to create objects to access private elements of Inner:
    int oi = new Inner().ii1;
    void showOi() { System.out.println(oi); }
    void showIi2() { new Inner().showIi2(); }
    void outerHi() { new Inner().hi(); }
    public static void main(String[] args) { 
        No8Outer out = new No8Outer();
        out.showOi();
        out.showIi2();
        out.outerHi();
    }
}
=====================================================================
1
2
Inner hi

10.5 在方法和作用域内的内部类

内部类的语法覆盖了大量其他的更加难以理解的技术。例如：可以在一个方法或者任意作用域内定义内部类。两个原因

• 实现了某类型的接口，于是可以创建并返回对其的引用
• 解决一个复杂问题，创建一个类来辅助你的解决方案，但是又不希望这个类是公共可用的

定义在域中的内部类 只能在类中使用

练习9

/* Create an interface with at least one method, and implement that
* interface by defining an inner class within a method, which returns a
* reference to your interface */

interface Ex9Interface {
    void say(String s);
}

public class No9Ex {
    Ex9Interface f() {
        class Inner implements Ex9Interface {
            public void say(String s) {
                System.out.println(s);
            }
        }
        return new Inner();
    }
    public static void main(String[] args) {
        No9Ex x = new No9Ex();
        x.f().say("hi");
    }
}
=========================================================
hi

练习11

/* Repeat the previous exercise but define the inner class within a
* scope with scope within a method.
*/

interface Ex10Interface {
	void say(String s); 
}

public class Ex10 {	
	Ex10Interface f(boolean b) {//向上转型所以为 基类的类型
		if(b) {
			class Inner implements Ex10Interface {
				public void say(String s) {
					System.out.println(s); 
				}
			}
			return new Inner(); //向上转型
		}
		return null;
	}
	public static void main(String[] args) {
		Ex10 x = new Ex10();
		x.f(true).say("hi");
	} 
}
==========================================================
    hi

练习11

/* Create a private inner class that implements a public interface.
* Write a method that returns a reference to an instance of the private
* inner class, upcast to the interface. Show that the inner class is 
* completely hidden by trying to downcast to it.
*/

/* public interface Ex11Interface {
*	void say(String s); 
* }
*/

class Test {
	private class Inner implements Ex11Interface {
		public void say(String s) {
			System.out.println(s); 
		}
	}
	Ex11Interface f() {
		return new Inner();
	}
}
public class Ex11 {	
	public static void main(String[] args) {
		Test t = new Test();
		t.f().say("hi");
		// Error: cannot find symbol: class Inner:
		// ((Inner)t.f()).say("hello");
	} 
}
================================================
    hi

10.6 匿名内部类

• 方法的返回值的生成与表示这个的类的定义结合在一起。这个类是匿名的，它没有名字。
• 在匿名中定义字段时，还能对其执行初始化操作
• 如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用是final的。
• 通过实例初始化，能够达到为匿名内部类创建一个构造器的效果。

/* Repeat Exercise 7 using an anonymous inner class.
 * (Exercise 7: Create a class with a private field and a private method.
 * Create an inner class with a method that modifies the outer-class field  * and calls the outer class method. In a second outer-class method, create
 * an object of the inner class and call its method, then show the effect on
 * the outer-class object.)
 */

interface Inner12 {
    void modifyOuter();
}

public class No12Outer {
    private int oi = 1;
    private void hi() { System.out.println("Outer hi"); }
    public Inner12 inner() {
        return new Inner12() {
            public void modifyOuter() {
                oi *= 2;
                hi();
            }
        };
    }
    public void showOi() { System.out.println(oi); }
    public static void main(String[] args) {
        No12Outer out = new No12Outer();
        out.showOi();
        out.inner().modifyOuter();
        out.showOi();
    }
}
====================================================================
1
Outer hi
2

练习13

/* Repeat Exercise 9 using an anonymous inner class.
* (Exercise 9: Create an interface with at least one method, and implement
* that interface by defining an inner class within a method, which returns
* a reference to your interface.) 

interface Ex13Interface {
	String say(String s); 
}

public class Outer13 {	
	Ex13Interface f() {
		return new Ex13Interface() {
			public String say(String s) { return s; }
		};
	} 
	public static void main(String[] args) {
		Outer13 o = new Outer13();
		System.out.println(o.f().say("Hi"));
	}
}
============================================================
hi

练习14

/* Modify interfaces/HorrorShow.java to implement DangerousMonster and
 * Vampire using anonymous classes.
 */

interface Monster {
    void menace();
}

interface DangerousMonster extends Monster {
    void destroy();
}

interface Lethal {
    void kill();
}

class DragonZilla implements DangerousMonster {
    public void menace() {}
    public void destroy() {}
}

interface Vampire extends DangerousMonster, Lethal {
    void drinkBlood();
}

class VeryBadVampire implements Vampire {
    public void menace() {}
    public void destroy() {}
    public void kill() {}
    public void drinkBlood() {}
}

public class No14HorrorShow {
    static void u(Monster b) { b.menace(); }
    static void v(DangerousMonster d) {
        d.menace();
        d.destroy();
    }
    static void w(Lethal l) { l.kill(); }
    public DangerousMonster monsterMaker() {
        return new DangerousMonster() {
            public void menace() {
                System.out.println("DangerousMonster Menace"); }
            public void destroy() {
                System.out.println("DangerousMonster Destroy"); }
        };
    }
    public Vampire vampireMaker() {
        return new Vampire() {
            public void menace() {
                System.out.println("Vampire Menace"); }
            public void destroy() {
                System.out.println("Vampire Destroy"); }
            public void kill() {
                System.out.println("Vampire Kill"); }
            public void drinkBlood() {
                System.out.println  ("Vampire DrinkBlood"); }
        };
    }
    public static void main(String[] args) {
        No14HorrorShow show = new No14HorrorShow();
        show.u(show.monsterMaker());
        show.v(show.monsterMaker());
        show.u(show.vampireMaker());
        show.v(show.vampireMaker());
        show.w(show.vampireMaker());
    }
}
======================================================================
DangerousMonster Menace
DangerousMonster Menace
DangerousMonster Destroy
Vampire Menace
Vampire Menace
Vampire Destroy
Vampire Kill

练习15

 /*Create a class with a non-default constructor and no default constructor.
* Create a second class that has a method that returns a reference to an
* object of the first class. Create the object that you return by making an
* anonymous inner class that inherits from the first class. 
*/

class One {
    private String s;
    One(String s) { this.s = s; }
    public String showS() { return s; }
}

public class No15Ex {
    public One makeOne(String s) {
        return new One(s) { };
    }
    public static void main(String[] args) {
        No15Ex x = new No15Ex();
        System.out.println(x.makeOne("hi").showS());
    }
}

10.6.1 在访工厂方法

练习16

/* Modify the solution to Exercise 18 from the Interfaces chapter to use
 * anonymous inner classes.
 * (Exercise 18, Interface: Create a Cycle interface, with implementations
 * Unicycle, Bicycle and Tricycle. Create factories for each type of Cycle,
 * and code that uses these factories.
 */

interface Cycle {
    void ride();
}

interface CycleFactory {
    Cycle getCycle();
}

class Unicycle implements Cycle {
    private Unicycle() {
        System.out.println("Unicycle()"); }
    public void ride() {
        System.out.println("Ride Unicycle"); }
    public static CycleFactory factory =
            new CycleFactory() {
                public Cycle getCycle() { return new Unicycle(); }
            };
}

class Bicycle implements Cycle {
    private Bicycle() {
        System.out.println("Bicycle()"); }
    public void ride() {
        System.out.println("Ride Bicycle"); }
    public static CycleFactory factory =
            new CycleFactory() {
                public Cycle getCycle() { return new Bicycle(); }
            };
}

class Tricycle implements Cycle {
    private Tricycle() {
        System.out.println("Tricycle()"); }
    public void ride() {
        System.out.println("Ride Tricycle"); }
    public static CycleFactory factory =
            new CycleFactory() {
                public Cycle getCycle() { return new Tricycle(); }
            };
}

public class No16Cycle {
    public static void rideCycle(CycleFactory factory) {
        Cycle c = factory.getCycle();//向上转型
        c.ride();//多态
    }
    public static void main(String [] args) {
        rideCycle(Unicycle.factory);
        rideCycle(Bicycle.factory);
        rideCycle(Tricycle.factory);
    }
}
=========================================================================Unicycle()
Bicycle()
Tricycle()

练习17

/* Modify the solution to Exercise 19 from the Interfaces chapter to use
 * anonymous inner classes.
 * (Exercise 19, Interfaces: Create a framework using Factory Methods
 * that performs both coin tossing and dice tossing.
 */
import java.util.*;

interface Games {
    void play();
}

interface GamesFactory {
    Games getGames();
}

class CoinToss implements Games {
    Random rand = new Random();
    public void play() {
        System.out.print("Toss Coin: ");
        switch(rand.nextInt(2)) {
            case 0 :
                System.out.println("Heads"); return;
            case 1 :
                System.out.println("Tails"); return;
            default:
                System.out.println("OnEdge"); return;
        }
    }
    public static GamesFactory factory =
            new GamesFactory() {
                public Games getGames() { return new CoinToss(); }
            };
}

class DiceThrow implements Games {
    Random rand = new Random();
    public void play() {
        System.out.println("Throw Dice: " + (rand.nextInt(6) + 1));
    }
    public static GamesFactory factory =
            new GamesFactory() {
                public Games getGames() { return new DiceThrow(); }
            };
}

public class No17Game {
    public static void playGame(GamesFactory factory) {
        Games g = factory.getGames();
        g.play();
    }
    public static void main(String [] args) {
        playGame(CoinToss.factory);
        playGame(DiceThrow.factory);
    }
}
=======================================================================
Toss Coin: Heads
Throw Dice: 1

10.7 嵌套类

如果不需要内部类对象和外围类对象之间有联系，那么可以将内部类声明为 static。这通常称为 嵌套类。

普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象。当内部类是 static时，就不是这样了

嵌套意味着：

• 要创建嵌套类的对象，并不需要外围类对象
• 不能从嵌套类的 对象中访问非静态地外围类对象

普通内部类 的字段和方法 只能放在类的外部层次上，这些普通的内部类不能有 static数据和static字段，也不能包含嵌套类，但是嵌套类可以包含所有这些东西

联系18

/* Create a class containing a nested class. In main(), create an instance of
* the nested class.
*/
public class No18Ex {
    No18Ex() { System.out.println("Ex18()"); }
    public static class Ex18Nest1 {
        Ex18Nest1() { System.out.println("Ex18Nest1()"); }
    }
    private static class Ex18Nest2 {
        Ex18Nest2() { System.out.println("Ex18Nest2()"); }
    }
    public static void main(String[] args) {
        Ex18Nest1 en1 = new Ex18Nest1();
        Ex18Nest2 en2 = new Ex18Nest2();
    }
}
================================================================
Ex18Nest1()
Ex18Nest2()

练习19

/* Create a class containing an inner class that itself contains an inner
 * class. Repeat this using nested classes. Note the names of the .class files
 * produced by the compiler.
 */

public class No19Ex {
    No19Ex() { System.out.println("Ex19()"); }
    private class Ex19Inner {
        Ex19Inner() { System.out.println("Ex19Inner()"); }
        private class Ex19InnerInner {
            Ex19InnerInner() {
                System.out.println("Ex19InnerInner()");
            }
        }
    }
    private static class Ex19Nested {
        Ex19Nested() { System.out.println("Ex19Nested()"); }
        private static class Ex19NestedNested {
            Ex19NestedNested() {
                System.out.println("Ex19NestedNested()");
            }
        }
    }
    public static void main(String[] args) {
        Ex19Nested en = new Ex19Nested();
        Ex19Nested.Ex19NestedNested enn = new Ex19Nested.Ex19NestedNested();
        No19Ex e19 = new No19Ex();
        No19Ex.Ex19Inner ei = e19.new Ex19Inner();
        No19Ex.Ex19Inner.Ex19InnerInner eii = ei.new Ex19InnerInner();
    }
}

/* compiler produces:
 * Ex19$Ex19Inner$Ex19InnerInner.class
 * Ex19$Ex19Inner.class
 * Ex19$Ex19Nested$Ex19NestedNested.class
 * Ex19$Ex19Nested.class
 * Ex19.class
 */
 ==========================================================================
 Ex19Nested()
Ex19NestedNested()
Ex19()
Ex19Inner()
Ex19InnerInner()

10.7.1 接口内部类

不能再接口内放置任何代码，但嵌套类可以作为接口的一部分。放在接口中的任何类都是自动 public 和 static 的，因为内部类是 static的 所以内部类为嵌套类。 只是将嵌套类置于接口的命名空间内：这并不违反接口规则，甚至可以在内部类中实现其外接口。

可以使用嵌套类来放置 测试 代码

练习20

/* Create an interface containing a nested class. Implement this interface and 
* create an instance of the nested class.
*/
interface In {
    class Nested {
        Nested() { System.out.println("Nested()"); }
        public void hi() { System.out.println("hi"); }
    }
}

public class No20 implements In {
    public static void main(String[] args) {
        In.Nested in = new In.Nested();
        in.hi();
    }
}
===================================================================
Nested()
hi

练习21

/* Create an interface that contains a nested class that has a static method that
* calls the methods of your interface and displays the results. Implement your
* interface and pass an instance of your implementation to the method. 
*/

interface In {
	String f();
	String g(); 
	class Nested {
		static void testIn(In i) { 
			System.out.println(i.f() + i.g());
		}		
	}		
}

public class Ex21 implements In {
	public String f() { return "hello "; }
	public String g() { return "friend"; }
	public static void main(String[] args) {
		Ex21 x = new Ex21();
		In.Nested.testIn(x);						
	}
}
==================================================================
    hello friend

10.7.3 从多层嵌套类中访问外部类的成员

一个内部类被嵌套多少层不重要--他能透明的访问所有他嵌入的外围类的所有成员，即使是private

10.8 为什么需要内部类

内部类继承来自某个类或实现某个接口，内部类的代码操作创建它的外围类对象。所以可以认为内部类提供了某种进入其外围类的窗口。

内部类实现接口和外围类实现接口的区别：

• 外围类不能总是享用外围类带来的方便,有时需要用到接口的实现
• 内部类都能独立地继承一个（接口的）实现，所以无论外围类是否继承了某个（接口的）实现，对于内部类都没有影响。
• 内部类允许继承多个非接口类型（类或抽象类）

一个类实现两个接口，如果没有说指定用那种方式实现，他们没有什么区别，但是要是要求继承的是抽象类或者具体类，只有内部类才能实现多重继承。

• 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立
• 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类
• 创建外围类对象的时刻并不依赖于内部类对象的创建
• 内部类并没有令人迷惑的is a 关系，他就一个独立的实体

练习23

/* Create an interface U with three methods. Create a class A with a method that
 * produces a reference to a U by building an anonymous inner class. Create a second
 * class B that contains an array of U. B should have one method that accepts and
 * stores a reference to U in the array, a second method that sets a reference in
 * the array (specified by the method argument) to null, and a third method that
 * moves through the array and calls the methods in U. In main, create a group of A
 * objects and a single B. Fill the B with U references produced by the A objects.
 * Use the B to call back into all the A objects. Remove some of the U references
 * from the B.
 */

interface U {
    void f();
    void g();
    String toString();
}

class A {
    U buildU() {
        return new U() {
            public void f() { System.out.println("f()"); }
            public void g() { System.out.println("g()"); }
            public String toString() { return "I'm a U"; }
        };
    }
}

class B {
    private U[] us;
    B(int i) {
        us = new U[i];
    }
    void addU(U u, int i) {
        us[i] = u;
    }
    void eraseU(int i) {
        us[i] = null;
    }
    void testUs() {
        for(U u : us) {
            u.f();
            u.g();
            u.toString();
        }
    }
    void showUs() {
        for(U u : us) {
            if(u != null) System.out.println(u.toString());
            else System.out.println("I'm null");
        }
    }
}

public class No23Ex {
    public static void main(String[] args) {
        A a0 = new A();
        A a1 = new A();
        A a2 = new A();
        B b = new B(3);
        b.addU(a0.buildU(), 0);
        b.addU(a1.buildU(), 1);
        b.addU(a2.buildU(), 2);
        b.showUs();
        b.testUs();
        b.eraseU(0);
        b.eraseU(1);
        b.eraseU(2);
        b.showUs();
    }
}
===============================================================================
I'm a U
I'm a U
I'm a U
f()
g()
f()
g()
f()
g()
I'm null
I'm null
I'm null

10.8.1 闭包与回调

闭包（closure）是一个可调用对象，它记录了一些信息，这些信息来自于创建它的作用域。

内部类是面向对象的闭包，不仅包含外部类对象（创建内部类作用域）的信息，还自动拥有一个指向此外围类对象的引用。

回调 （callvack） 通过回调，对象可以携带一些信息，这些信息允许它在稍后再某个时刻调用初始化的对象。

10.8.2 内部类与控制框架

程序设计的关键所在：使变化的事物与不变的事物相互分离

这正是内部类做的：

• 控制框架的完整实现是由单个的类创建的，从而实现的细节被封装了起来。内部类用来表示解决问题所必须的各种不同的action
• 内部类能够很容易地访问外围类地任意成员，所以可以避免这种现实变得笨拙。如果没有这种能力，代码将变得令人讨厌，以至于你肯定会选择别的方法。

使用内部类 可以再单一地类里面产生对同一个基类Event地多种导出版本。

练习24

package 第十章内部类;

import java.util.*;
abstract class Event {
   private long eventTime;
   protected final long delayTime;
   public Event(long delayTime) {
      this.delayTime = delayTime;
      start();
   }
   public void start() { // Allows restarting
   }
   public boolean ready() {
      return System.nanoTime() >= eventTime;
   }
   public abstract void action();
}

 class Controller {
    // A class from java.util to hold Event objects:
    private List<Event> eventList = new ArrayList<Event>();

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

    public void run() {
        while (eventList.size() > 0)
            // Make a copy so you're not modifying the list
            // while you're selecting the elements in it:
            for (Event e : new ArrayList<Event>(eventList))
                if (e.ready()) {
                    System.out.println(e);
                    e.action();
                    eventList.remove(e);
                }
    }
}
class GreenhouseControls24 extends Controller {
    private boolean fan = false;
    public class FanOn extends Event {
        public FanOn(long delayTime) { super(delayTime); }
        public void action() {
            // Put hardware control code here to
            // physically turn on the fan.
            fan = true;
        }
        public String toString() { return "Fan is on"; }
    }
    public class FanOff extends Event {
        public FanOff(long delayTime) { super(delayTime); }
        public void action() {
            // Put hardware control here to
            // physically turn off the fan.
            fan = false;
        }
        public String toString() { return "Fan is off"; }
    }
    private boolean light = false;
    public class LightOn extends Event {
        public LightOn(long delayTime) { super(delayTime); }
        public void action() {
            // Put hardware control code here to
            // physically turn 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 hardware control here to
            // physically turn 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 hardware control 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 hardware control 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 hardware control 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 hardware control code here
            thermostat = "Day";
        }
        public String toString() {
            return "Thermostat on day setting";
        }
    }
    // An example of an action() that inserts a
    // new one of itself 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(Event e : eventList)
                addEvent(e);
        }
        public void action() {
            for(Event e : eventList) {
                e.start(); // Rerun each event
                addEvent(e);
            }
            start(); // Rerun this Event
            addEvent(this);
        }
        public String toString() {
            return "Restarting system";
        }
    }
    public static class Terminate extends Event {
        public Terminate(long delayTime) { super(delayTime); }
        public void action() { System.exit(0); }
        public String toString() { return "Terminating"; }
    }
}
public class No24Controller {
    public static void main(String[] args) {
        GreenhouseControls24 gc = new GreenhouseControls24();
        // Instead of hard-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 FanOn(300),
                gc.new LightOff(400),
                gc.new FanOff(500),
                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(
                    new GreenhouseControls24.Terminate(
                            new Integer(args[0])));
        gc.run();
    }
}
==========================================================================
t is on
Fan is on
Light is off
Fan is off
Greenhouse water is on
Greenhouse water is off
Thermostat on day setting
Restarting system
Bing!

10.9 内部类继承

内部类构造器必须连接到指向其外围类对象的引用，所以在继承内部类的时候，事情就会变得复杂。那个指向外围类对象的“秘密的”引用必须被初始化，而在导出类中不再存在可连接的默认对象。

/* Create a class with an inner class that has a non-default constructor
 * (one that takes arguments). Create a second class with an inner
 * class that inherits from the first inner class.
 */

class FirstOuter {
    public class FirstInner {
        FirstInner(String s) {
            System.out.println("FirstOuter.FirstInner() " + s );
        }
    }
}

public class No26SecondOuter {
    public class SecondInner extends FirstOuter.FirstInner {
        SecondInner(FirstOuter x) {
            x.super("hello");
            System.out.println("SecondOuter.SecondInner()");
        }
    }
    public static void main(String[] args) {
        FirstOuter fo = new FirstOuter();
        //FirstOuter.FirstInner fs = new FirstOuter.FirstInner("s");
        No26SecondOuter so = new No26SecondOuter();
        SecondInner si = so.new SecondInner(fo);
    }
}
====================================================================
FirstOuter.FirstInner() hello
SecondOuter.SecondInner()

10.10 内部类可以被覆盖吗

当继承了某个外围类的时候，重新定义此内部类并不会被覆盖，会产生两个独立的实体。

当然，明确继承某个内部类是可以的。

10.11 局部内部类

代码块里面创建，典型的是 方法里面创建，局部内部类不能有访问说明符，因为它不是外围类的一部分。它可以访问当前代码块内的常量。

局部内部类 和 匿名内部类的实现是一样的 ，唯一的区别是 局部内部了我们需要一个以命名的构造器，或者需要重载构造器，而匿名内部了只能用于实例初始化。

使用局部内部类而不使用匿名内部类的另一个理由：需要不止一个内部类对象

10.12 内部类标识符

内部类的类文件命名 ：

外围类$内部类.class

10.13 总结

内部类，好！！！！！！！！！！！！！！！！难