为什么需要内部类

闭包和回调

内部类和控制框架

继承内部类

内部类的重写（并不能）

局部内部类

内部类标识符

本笔记参考自：《On Java 中文版》

为什么需要内部类

在一些情况下，我们无法享受接口带来的便利，有时却还是需要处理多个实现。这就引出了使用内部类的理由之一：

每个内部类都可以单独地继承自一个实现。因此，外部类是否已经继承了某个实现，对内部类并没有限制。

内部类的存在完善了多重继承问题的解决方案。因为内部类实际上支持的是“多重实现继承”，也就是说，内部类实际上支持我们继承多个非接口类型。例如：现在需要在一个类中以某种方式实现两个接口。这时有两个选择，① 一个单独的类；② 一个内部类。

（假设无论使用哪种方法，得到的代码结构都会有意义。）

package mui;interface A {}interface B {}// 方法1：使用单独的类进行实现
class X implements A, B {}// 方法2：使用内部类进行实现
class Y implements A {B makeB() {return new B() {};}
}public class MultiInterfaces {static void takesA(A a) {}static void takesB(B b) {}public static void main(String[] args) {X x = new X();Y y = new Y();takesA(x);takesA(y);takesB(x);takesB(y.makeB());}
}

若没有其他限制，从实现的角度而言，上述的方法没有太大区别，都可以使用。

但若使用的是抽象类或是具体类，而不是接口。此时仍然要求某个类必须以某种方式实现这两者，此时就只能使用内部类了：

class D {}abstract class E {}class Z extends D {E makE() { // 通过内部类，可以实现“多重实现继承”return new E() {};}
}public class MultiImplementation {static void takesD(D d) {}static void takesE(E e) {}public static void main(String[] args) {Z z = new Z();takesD(z);takesE(z.makE());}
}

总结内部类的功能：

内部类可以有多个实例，其中的每个实例都有自己的状态信息，独立鱼外围类对象的信息。
一个外围类中可以有多个内部类，这些内部类可以通过不同的方式实现同一个接口。
内部类对象的创建时机不会与外围类对象的创建捆绑在一起。
内部类不存在可能引起混淆的“is-a”关系，它是独立的实体。

闭包和回调

闭包是一个可调用的对象，它保留了来自它被创建时所在的作用域的信息。内部类就是面向对象的闭包，因为它不仅包含了外围类对象的每一条信息，而且自动持有着对整个外围类的引用。

有人认为Java应该拥有某种指针机制，以此来支持回调。但Java出于谨慎，没有向语言中引入指针。

||| 回调的概念：对象获得某种信息，在之后的某段时间，凭借信息调用回原始的对象。

内部类为闭包通过了一个解决方案，这种方案比指针更加灵活和安全：

interface Incrementable {void increment();
}// 简单地实现Incrementable接口
class Callee1 implements Incrementable {private int i = 0;@Overridepublic void increment() {i++;System.out.println("Callee1类的方法increment()，i = " + i);}
}class MyIncrement {public void increment() {System.out.println("这个increment()方法来自于其他的类（MyIncrement）");}static void f(MyIncrement mi) {mi.increment();}
}// 由于MyIncrement已经实现了一个increment()方法
// 所以若需要通过其他方式实现increment()方法，就必须使用内部类
class Callee2 extends MyIncrement {private int i = 0;@Overridepublic void increment() {super.increment();i++;System.out.println("Callee2类的方法increment()，i = " + i);}private class Closure implements Incrementable {@Overridepublic void increment() {// 此处需要指定调用外围类的方法，否则会无限递归Callee2.this.increment();}}Incrementable getCallbackReference() {return new Closure();}
}class Caller {private Incrementable callbackReference;Caller(Incrementable cbh) {callbackReference = cbh;}void go() {callbackReference.increment();}
}public class Callbacks {public static void main(String[] args) {Callee1 c1 = new Callee1();Callee2 c2 = new Callee2();MyIncrement.f(c2);System.out.println();Caller caller1 = new Caller(c1);Caller caller2 = new Caller(c2.getCallbackReference());caller1.go();caller1.go();System.out.println();caller2.go();caller2.go();}
}

程序执行的结果是：

上述程序显示了在外围类中实现接口和在内部类中实现接口的区别。

就代码而言，Callee1显然更加简单。Callee2继承自MyIncrement类，基类中已经存在一个increment()方法，但这个increment()和Increment接口期望的不一样。而因为MyIncrement已经被Callee2继承，此时increment()无法再为满足Increment接口的需要而重写。这时就需要内部类提供单独的实现。

Callee2与外部建立联系离不开Incrementable，这里体现了接口支持的接口与实现的完全分离。

注意：Closure和Caller都实现了回调这一功能，它们都通过保存或使用一个安全的引用来限制这种回调的风险。

||| 回调的价值在于其的灵活性，它允许我们在运行时动态地决定调用哪些方法。

内部类和控制框架

应用框架是为了解决某一特定类型的问题而设计的一个或一组类。通过应用框架提供的通用的解决方案，我们可以在重写方法时通过定制来解决特定的问题。这就是模板方法设计模式的一个例子。

通过设计方案将变化的事物和不变的事物分离，此时模板方法就是不变的事物，可重写的方法则是变化的事物。

控制框架是一种特殊类型的应用框架，主要用于满足对事件做出响应这样的需求。通过内部类，可以简化控制框架的创建和使用。

例如：存在一个框架，其作用是当事件“就绪”时执行相应时间（“就绪”可以指代任何事物，下面的例子中“就绪”指代时间）。现在有一个用于描述控制事件的接口，是一个abstract类，其默认行为是基于时间来执行控制的，它有部分实现：

package controller;import java.time.Instant;
import java.time.Duration;public abstract class Event {private Instant evenTime;protected final Duration delayTime;public Event(long millisecondDelay) {delayTime = Duration.ofMillis(millisecondDelay);start();}public void start() {evenTime = Instant.now().plus(delayTime);}public boolean ready() {return Instant.now().isAfter(evenTime);}public abstract void action();
}

上述代码中的action()方法，用来处理所控制的事物。与其有关的信息在继承时实现。

start()被时间为单独的方法，而没有直接实现在构造器中。这种做法允许我们在事件结束完毕后重启计时器，复用Event对象。
ready()用于控制action()方法的运行时机，可以在子类中进行重写，使Event可以通过时间之外的要素触发。

下面编写用于管理和触发事件的真正的控制框架。

package controller;import java.util.ArrayList;
import java.util.List;// 用于控制系统的可复用框架
public class Controller {// Event对象被保存在一个List<Event>类型的集合对象中（读作List of Event）private List<Event> eventList = new ArrayList<>();public void addEvent(Event c) {eventList.add(c); // add()用于将一个Event添加到List的末尾}public void run() {while (eventList.size() > 0) // size()用于得到列表中的实体数量for (Event e : new ArrayList<>(eventList))// 此处创建了一个副本，这样在选择列表中的元素时就不需要改动列表了if (e.ready()) {System.out.println(e);e.action();eventList.remove(e); // 用于移除指定的Event}}
}

这段代码设计的一个关键在于，我们不知道也不需要知道Event到底是用来做什么的，换句话说，这种设计“将变化的事物与保持不变的事物分离开来”。

接下来就是内部类登场的时候了，内部类允许：

控制框架的整个实现是在一个单独的类中完成的，这封装了其实现的所有特点。而内部类用来表达解决问题所需的不同的action()。
内部类简化了上述的这种需求，因为它可以轻松访问外围类的任何成员。

下方出现的应用框架ManyController就继承自Controller：

import controller.Controller;
import controller.Event;public class ManyControlls extends Controller {// 控制灯private boolean light = false;public class LightOn extends Event {public LightOn(long delayTime) {super(delayTime);}@Overridepublic void action() {// 此处处理硬件控制代码light = true;}@Overridepublic String toString() {return "灯开了";}}public class LightOff extends Event {public LightOff(long delayTime) {super(delayTime);}@Overridepublic void action() {light = false;}@Overridepublic String toString() {return "灯关了";}}// 控制闹铃public class Bell extends Event {public Bell(long delayTime) {super(delayTime);}// action（）的一个例子，向事件中插入一个新的相同事件@Overridepublic void action() {addEvent(new Bell(delayTime.toMillis()));}@Overridepublic String toString() {return "闹铃响了";}}// 重启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);}@Overridepublic void action() {for (Event e : eventList) {e.start(); // 重新运行每个事件addEvent(e);}start(); // 重新运行该事件addEvent(this);}@Overridepublic String toString() {return "重启";}}public static class Terminate extends Event {public Terminate(long delayTime) {super(delayTime);}@Overridepublic void action() {System.exit(0);}@Overridepublic String toString() {return "结束";}}
}

上述框架中，light属于外围类ManyControlls，但内部类可以无需限定条件或是特殊权限，即可直接访问这些字段。

内部类和多重继承很像：Bell和Restart拥有Event的所有方法，而且看起来也有外围类ManyControlls的所有方法。

接下来就需要配置系统了：创建一个ManyControlls对象，在加入不同的Event对象，这就是命令设计模式的一个例子，eventList中的每一个对象都被封装为对象的请求：

import controller.Event;public class ManyController {public static void main(String[] args) {ManyControlls ms = new ManyControlls();// 也可以从文本文件中解析配置信息ms.addEvent(ms.new Bell(900));Event[] eventList = {ms.new LightOn(900),ms.new LightOff(900),};ms.addEvent(ms.new Restart(2000, eventList));ms.addEvent(new ManyControlls.Terminate(5000));ms.run();}
}

程序执行的结果如下：

若从文件中读取事件，而不是通过编码，会更加灵活。

继承内部类

内部类的构造器需要依附于一个指向其包围类的对象的引用，这使得继承内部类变得更加复杂了。因为外部类的引用必须初始化，但子类中不存在默认的对象允许内部类进行依附。所以需要使用特殊的语法指出这种关联：

class WithInner {class Inner {}
}public class InheritInner extends WithInner.Inner {// InheritInner() {} // 无法使用这种方式进行初始化，编译器认为没有可以依附的复习InheritInner(WithInner wi) {wi.super(); // 提供一个必须的引用}public static void main(String[] args) {WithInner wi = new WithInner();InheritInner ii = new InheritInner(wi);}
}

在这里，InheritInner类继承了一个内部类。对这个子类而言，默认构造器是行不通的。而如果只传递一个外围类的参数WithInner wi，也还是不够。必须在构造器中使用如下的语法：

外围类的引用.super(); // 提供必须的引用

内部类的重写（并不能）

已知，若一个类继承了一个基类，这个类就应该可以重写基类中的方法。那么若继承了一个包含内部类的外围类，我们是否可以“重写”整个内部类了？

不过，把内部类当作外围类中的其他方法一样进行重写，并没有什么实际意义。

// 内部类不能像方法一样进行重写class Egg {private Yolk y;protected class Yolk {public Yolk() {System.out.println("Egg.Yolk()");}}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();}
}

程序执行的结果是：

虽然上述代码的main()函数创建的是一个BigEgg的引用，但是实际输出的Yolk()方法确实属于基类Egg的。

从中可以得出一个结论：当继承外围类时，内部类不会有任何额外的特殊之处（与其他外围类的方法相比）。内部类是完全独立的实体，有属于自己的命名空间。

不过可以显式地继承一个内部类：

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();Egg2() {System.out.println("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 构造器");}@Overridepublic 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();}
}

程序执行的结果如下：

insertYolk()方法允许BigEgg2将其的Yolk对象向上转型为Egg2中的y引用。所以g()调用的y.f()是f()的重写版本。另外，对Egg2.Yolk()的第二次调用，是BiggEgg2.Yolk调用基类构造器时触发的。

局部内部类

局部内部类不是外围类的组成部分，因此不能对它使用访问权限修饰符。但它可以访问当前代码块中的常量，以及外围类的所有成员。

通过一个例子比较局部内部类和匿名内部类的区别：

interface Counter {int next();
}public class LocalInnerClass {private int count = 0;Counter getCounter1(final String name) {// 这是一个局部内部类：class LocalCounter implements Counter {LocalCounter() {// 局部内部类可以有一个构造器System.out.println("LocalCounter()");}@Overridepublic int next() {System.out.print(name); // 可以访问局部的final变量return count++;}}return new LocalCounter();}// 这是有同样功能的一个匿名内部类：Counter getCounter2(final String name) {return new Counter() {// 匿名内部类没有显式的构造器// 只有实例初始化{System.out.println("Counter()");}@Overridepublic int next() {System.out.print(name); // 也可以访问局部的final变量return count++;}};}public static void main(String[] args) {LocalInnerClass lic = new LocalInnerClass();Counter c1 = lic.getCounter1("局部内部类"),c2 = lic.getCounter2("匿名内部类");System.out.println();for (int i = 0; i < 5; i++)System.out.println(c1.next());System.out.println();for (int i = 0; i < 5; i++)System.out.println(c2.next());}
}

程序执行的结果是：

上述的局部内部类和匿名内部类有相同的行为和功能。二者有这样的一些区别：

局部内部类	匿名内部类
名字无法在方法外使用。	是匿名的。
允许构造器的定义，及其的重载。	只能进行实例初始化。
允许我们创建多个对象。	通常用于返回该类的一个实例。