Thinking in Java from Chapter 10

From Thinking in Java 4th Edition

内部类

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);
		System.out.println(d.readLable());
	}

	public static void main(String[] args) {
		Parcel1 p = new Parcel1();
		p.ship("Tasmania");
	}
} /* Output:
Tasmania
*/

更典型的情况是，外部类将有一个方法，该方法返回一个指向内部类的引用

public class Parcel2 {
	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;}
	}

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

	public Contents contents() {
		return new Contents();
	}

	public void ship(String dest) {
		Contents c = contents();
		Destination d = to(dest);
		System.out.println(d.readLabel());
	}

	public static void main(String[] args) {
		Parcel2 p = new Parcel2();
		p.ship("Tasmania");
		Parcel2 q = new Parcel2();

		// Defining references to inner classes:
		Parcel2.Contents c = q.contents();
		Parcel2.Destination d = q.to("Borneo");
	}
} /* Output:
Tasmania
*/

当生成一个内部类的对象时，此对象与制造它的外围对象之间就有了联系，它能访问其外围对象的所有成员。内部类拥有其外围类的所有元素的访问权：

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

public class Sequence {
	private Object[] items;
	private int next = 0;

	public Sequence(int size) { item = 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){
		Sequence sequence = new Sequence(10);
		for(int i = 0; i < 10; ++i)
			sequence.add(Integer.toString(i));

		Selector selector = sequence.selector();
		while(!selector.end()){
			System.out.println(selector.current() + " ");
			selector.next();
		}
	}
} /* Output:
0 1 2 3 4 5 6 7 8 9
*/

要生成对外部类对象的引用，可以使用外部类的名字后面紧跟圆点和this：

public class DotThis {
	void f() { System.out.println("DotThis.f()");}

	public class Inner {
		public DotThis outer() {
			return DotThis.this;
			// A plain "this" would be Inner's "this"
		}
	}

	public Inner inner() { return new Inner();}

	public static void main(String[] args){
		DotThis dt = new DotThis();
		DotThis.Inner dti = dt.inner();
		dti.outer().f();
	}
} /* Output:
DotThis.f()
*/

要告知某个其他对象，去创建其某个内部类的对象，你必须在new表达式中提供对其他外部类对象的引用，这需要使用.new语法：

public class DotNew {
	public class Inner {}

	public static void main(String[] args){
		DotNew dn = new DotNew();
		DotNew.Inner dni = dn.new Inner();
	}
}

要直接创建内部类的对象，你不能按照想象的方式，去引用外部类的名字DotNew，而必须使用外部类的对象来创建该内部类对象.

在拥有外部类对象之前是不可能创建内部类对象的。这是因为内部类对象会暗暗地连接到创建它的外部类对象上。

但如果你创建的是嵌套类（静态内部类），那就不需要对外部类对象的引用：

public class Parcel3 {
	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;}
	}

	public static void main(String[] args){
		Parcel3 p = new Parcel3();

		// Must use instance of outer class
		// to create an instance of the inner class:
		Parcel3.Contents c = p.new Contents();
		Parcel3.Destination d = p.new Destination("Tasmania");
	}
}

内部类与向上转型

示例接口：

public interface Destination {
	String readLabel();
}

public interface Contents {
	int value();
}

当取得一个指向基类或接口的引用时，甚至可能无法找出它的确切类型：

class Parcel4 {
	private class PContents implements 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 destination(String s){
		return new PDestination(s);
	}

	public Contents contents(){
		return PContents();
	}
}

public class TestParcel {
	public static void main(String[] args){
		Parcel4 p = new Parcel4();
		Contents c = p.contents();
		Destination d = p.destination("Tasmania");

		// Illegal -- can't access private class
		//! Parcel4.PContents pc = p.new PContents();
	}
}

可以在一个方法里或者在任意的作用域内定义内部类。

在方法的作用域内创建一个完整的内，称作局部内部类：

public class Parcel5{
	public Destination destination(String s) {
		class PDestination implements Destination {
			private String label;

			private PDestination(String whereTo) {
				label = whereTo;
			}
			public String readLabel() { return label;}
		}

		return new PDestination(s);
	}

	public static void main(String[] args)}{
		Parcel5 p = new Parcel5();
		Destination d = p.destination("Tasmania");
	}
}

1. PDestination类是destination()方法的一部分，所以在destination()方法之外不能访问PDestination。注意出现在return后的向上转型。

2. 在destination()方法内定义内部类，并不意味着在destination()方法执行完毕之后，PDestination就不可用了。

3. 可以在同一个子目录下的任意类中，对某个内部类用标示符PDestination命名，这并不会有名字冲突。

在任意的作用域内嵌入一个内部类：

public class Parcel6 {
	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("X");
			String s = ts.getSlip();
		}

		// Can't use it here! Out of scope:
		//! TrackingSlip ts = new TrackingSlip("X");
	}

	public void track() { internalTracking(true); }

	public static void main(String[] args){
		Parcel6 p = new Parcel6();
		p.track();
	}
}

TrackingSlip类被嵌入if语句，并不是说该类的创建是有条件的：

1. 它其实是与别的类一起被编译过了

2. 在定义TrackingSlip的作用域之外，它是不可用的

匿名内部类

public class Parcel7 {
	public Contents contents() {
		return new Contents() {	// Insert a class definition
			private int i = 11;
			public int value() { return i;}
		};	// Semicolon required in this case
	}

	public static void main(String[] args){
		Parcel7 p = new Parcel7();
		Contents c = p.contents();
	}
}

这里，Contents是之前定义的接口。这种奇怪的语法指的是：“创建一个继承自Contents的匿名类的对象”，通过new表达式返回的引用被向上转型为对Contents的引用，上述匿名内部类的语法是下述形式的简化形式：

public class Parcel7b {
	class MyContents implements Contents {
		private i = 11;
		public int value() { return i;}
	}

	public Contents contents() { return new MyContents();}

	public static void main(String[] args){
		Parcel7b p = new Parcel7b();
		Contents c = p.contents();
	}
}

在匿名内部类中使用了默认的构造器来生成Contents，下面展示，如果你的基类需要一个有参数的构造器应该怎么办：

public class Wrapping {
 private int i;
 public Wrapping(int x) { i = x;}
 public int value() { return i;}
}

public class Parcel8 {
	public Wrapping wrapping(int x) {
		// Base constructor call:
		return new Wrapping(x) {	// Pass constructor argument
			public int value(){
				return super.value() * 47;
			}
		};	// Semicolon required
	}

	public static void main(Sring[] args){
		Parcel8 p = new Parcel8();
		Wrapping w = p.wrapping(10);
	}
}

如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用是final的：

public class Parcel9 {
	// Argument must be final to use inside
	// anonymous inner class:
	public Destination destination(final String dest) {
		return new Destination() {
			private String label = dest;
			public String readLabel() { return label;}
		};
	}

	public static void main(String[] args){
		Parcel9 p = new Parcel9();
		Destination d = p.destination("Tasmania");
	}
}

如果想做一些类似构造器的行为，在匿名类中不可能有命名构造器（因为它根本没有名字！），但通过实例初始化，就能够达到匿名内部类创建一个构造器的效果。

目标效果：

public class AnonymousConstructor {
	public static Base getBase(int i){
		return new Base(i){
			{
				print("Inside instance initializer");
			}

			public void f(){
				print("In anonymous f()");
			}
		};
	}

	public static void main(String[] args){
		Base base = new getBase(47);
		base.f();
	}
} /* Output:
Base constructor, i = 47
Inside instance initializer
In anonymous f()
*/

实例初始化的“parcel” 形式：

public class Parcel10 {
	public Destination destination(final String dest, final float price){
		return new Destination() {
			private int cost;

			// Instance initialization for each object:
			{
				cost = Math.round(price);
				if(cost > 100)
					System.out.println("Over budget!")
			}

			private String label = dest;
			public String readLabel() { return label;}
		};
	}

	public static void main(String[] args){
		Parcel10 p = new Parcel10();
		Destination d = p.destination("Tasmania", 101.395F);
	}
} /* Output:
Over budget!
*/

运用匿名内部类实现工厂方法：

import static net.mindview.util.Print.*;

interface Service {
	void method1();
	void method2();
}

interface ServiceFactory {
	Service getService();
}

class Implementation1 implements Service {
	private Implementation1() {}

	public method1 { print("Implementation1 method1");}
	public method2 { print("Implementation1 method2");}

	public static ServiceFactory factory =
		new ServiceFactory() {
			public Service getService(){
				return new Implementation1();
			}
		}
}

class Implementation2 implements Service {
	private Implementation2() {}

	public method1 { print("Implementation2 method1");}
	public method2 { print("Implementation2 method2");}

	public static ServiceFactory factory =
		new ServiceFactory(){
			public getService(){
				return new Implementation2();
			}
		}
}

public class Factories {
	public static void serviceConsumer(ServiceFactory fact){
		Service s = fact.getService();
		s.method1();
		s.method2();
	}

	public static void main(String[] args){
		serviceConsumer(Implementation1.factory);
		// Implementations are completely interchangeable:
		serviceConsumer(Implementation2.factory);
	}
} /* Output:
Implementation1 method1
Implementation1 method2
Implementation2 method1
Implementation2 method2
*/

Game类也可以经由同样的改进：

import static net.mindview.util.Print.*;

interface Game { boolean move();}
interface GameFactory { Game getGame();}

class Checkers implements Game {
	private Checkers() {}

	private int moves = 0;
	private static final int MOVES = 3;

	public boolean move() {
		print("Checkers move " + moves);
		return ++moves != MOVES;
	}

	public static GameFactory factory = new GameFactory() {
		public Game getGame() { return new Checkers(); }
	};
}

class Chess implements Game {
	private Chess() {}
	private int moves = 0;
	private static final int MOVES = 4;

	public boolean move() {
		print("Chess move " + moves);
		return ++moves != MOVES;
	}

	public static GameFactory factory = new GameFactory() {
		public Game getGame() { return new Chess();}
	};
}

public class Games {
	public static void playGame(GameFactory factory) {
		Game s = factory.getGame();
		while(s.move());
	}

	public static void main(String[] args){
		playGame(Checkers.factory);
		playGame(Chess.factory);
	}
} /* Output:
Checkers move 0
Checkers move 1
Checkers move 2
Chess move 0
Chess move 1
Chess move 2
Chess move 3
*/

嵌套类

1. 要创建嵌套类的对象，并不需要其外围类的对象

2. 不能从嵌套类中访问非静态的外围类对象

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

public class Parcel11 {
	private static class ParcelContents implements Contents {
		private int i = 11;
		public int value() { return i;}
	}

	protected static class ParcelDestination implements Destination {
		private String label;
		private ParcelDestination(String whereTo){
			label = whereTo;
		}
		public String readLabel() { return label;}

		// Nested classes can contain other static elements:
		public static void f() {}
		static int x = 10;
		static class AnotherLevel {
			public static void f() {}
			static int x = 10;
		}
	}

	public static Destination destination(String s){
		return new ParcelDestination(s);
	}

	public static Contents contents(){
		return new ParcelContents();
	}

	public static void main(String[] args){
		Contents c = new contents();
		Destination d = destination("Tasmania");
	}
}

正常情况下，不能在接口内放置任何代码，但嵌套类可以作为接口的一部分。放到接口中的任何类都是public和static的。因为类是static的，所以这并不违反接口的规则。甚至，可以在内部类中实现其外围的接口：

//: innerclasses/ClassInInterface.java
// {main: ClassInInterface$Test}

public interface ClassInInterface {
	void howdy();

	class Test implements ClassInInterface {
		public void howdy(){
			System.out.println("Howdy!");
		}

		public static void main(String[] args){
			new Test().howdy();
		}
	}
} /* Output:
Howdy!
*/

要运行以上代码，执行java ClassInInterface$Test即可，在Unix/Linux中，符号$必须转义。

可以使用嵌套类来放置测试代码：（运行这个程序，执行java TestBed$Tester即可。）

//: innerClasses/TestBed.java
// Putting test code in a nested class.
// {main: TestBed$Tester}

public class TestBed {
	public void f() { System.out.println("f()");}

	public static class Tester {
		public static void main(String[] args){
			TestBed t = new TestBed();
			t.f();
		}
	}
} /* Output:
f()
*/

这生成了一个独立的类TestBed$Tester。 可以使用这个类来做测试，但不必在发布的产品中包含它，在将产品打包前可以简单地删除TestBed$Tester.class文件。

一个内部类被嵌套多少层并不重要，它能透明地访问所有它所嵌入的外围类的所有成员：

class MNA {
	private void f() {}

	class A {
		private void g() {}

		public class B {
			void h(){
				g();
				f();
			}
		}
	}
}

public class MultiNestingAccess {
	public static void main(String[] args){
		MNA mna = new MNA();
		MNA.A mnaa = mna.new A();
		MNA.A.B mnaab = mnaa.new B();
		mnaab.h();
	}
}

内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。也就是说，内部类允许继承多个非接口类。让我们考虑这样一种情形：必须在一个类中以某种方式实现两个接口。有两种方式：

1. 使用单一类

2. 使用内部类

package innerclasses;

interface A {}
interface B {}

// 1. Use only one class
class X implements A, B {}

// 2. Use inner class
class Y implements A {
	B makeB(){
		// Anonymous inner class:
		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());
	}
}

如果拥有的是抽象的类或具体的类，而不是接口， 那就只能选择内部类实现多重继承：

// With concrete or abstract classes, inner
// classes are the only way to produce the effect
// of "multiple implementation inheritance."
package innerclasses;

class D {}
abstract class E {}

class Z extends D {
	E makeE() { 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.makeE());
	}
}

闭包(closure)是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。可以看出，内部类是面向对象的闭包。

通过内部类提供闭包的功能是优良的解决方案， 它比指针更灵活、更安全：

// Using inner class for callbacks
package innerclasses;
import static net.mindview.util.Print.*;

interface Incrementable {
	void increment();
}

// Very simple to just implement the interface:
class Callee1 implements Incrementable {
	private int i = 0;

	public void increment() {
		++i;
		print(i);
	}
} 

class MyIncrement {
	public void increment() { print("Other operation");}
	static void f(MyIncrement mi) { mi.increment();}
}

// If your class must implement increment() in
// some other way, you must use an inner class:
class Callee2 extends MyIncrement {
	private int i = 0;
	public void increment(){
		super.increment();
		++i;
		print(i);
	}

	private class Closure implements Incrementable {
		public void increment() {
			// Specify outer-class method, otherwise
			// you'd get an infinite recursion:
			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);

		Caller caller1 = new Caller(c1);
		Caller caller2 = new Caller(c2.getCallbackReference());

		caller1.go();
		caller1.go();

		caller2.go();
		caller2.go();
	}
} /* Output:
Other operation
1
1
2
Other operation
2
Other operation
3
*/

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

要运用某个应用程序框架，通常是继承一个类或多个类，并覆盖某些方法。

控制框架(control framework)是一类特殊的应用程序框架，它用来解决响应事件的需求。主要用来响应事件的系统被称为事件驱动系统。

下面的例子包含了某些实现：

// The common methods for any control event.
package innerclasses.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.nanoTime() + delayTime;
	}

	public boolean ready() {
		return System.nanoTime() >= eventTime;
	}

	public abstract void action();
}

下面的文件包含了一个用来管理并触发事件的实际控制框架：

// The reusable framework for control system.
package innerclasses.controller;
import java.util.*;

public 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);
				}
			}

		}
	}
}

使用内部类，可以在单一的框架里面产生对同一个基类Event的多种导出版本。对于温室系统的每一种行为，都继承一个新的Event内部类，并在要实现的action()中编写控制代码。

温室控制系统：

// 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.
import innerclasses.controller.*;

public class GreenhouseControls extends Controller {
	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 code 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";}
	}
}

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

// Configure and execute the greenhouse system.
// {Args: 5000}
import innerclasses.controller.*;

public class GreenhouseController {
	public static void main(String[] args){
		GreenhouseControls gc = new GreenhouseControls();

		// 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 LightOff(400),
			gc.new WaterOn(600),
			gc.new WaterOff(800),m
			gc.new ThermostatDay(1400)
		};

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

		if(args.length == 1)
			gc.addEvent(
				new GreenhouseControls.Terminate(
					new Integer(args[0])
				)
			);

		gc.run();
	}
} /* Output:
Bing!
Thermostat on night setting
Light is on
Light is off
Greenhouse water is on
Greenhouse water is off
Thermostat on day setting
Restarting system
Terminating
*/

内部类的继承

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

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 i1 = new InheritInner(wi);
	}
}

InheritInner只能继承自内部类，且必须在构造器内使用如下语法：enclosingClassReference.super();，这样才能提供必要的引用，然后程序才能编译通过。

“覆盖”内部类就好像它是外围类的一个方法，其实并不起作用。

import static net.mindview.util.Print.*;

class Egg {
	private Yolk y;
	protected class Yolk {
		public Yolk() { print("Egg.Yolk()");}
	}

	public Egg() {
		print("New Egg()");
		y = new Yolk();
	}
}

public class BigEgg extends Egg {
	public class Yolk {
		public Yolk() { print("BigEgg.Yolk()");}
	}

	public static void main(String[] args){
		new BigEgg();
	}
} /* Output:
New Egg()
Egg.Yolk()
*/

这个例子说明了，当继承了某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的两个实体，各自在自己的命名空间内。

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

import static net.mindview.util.Print.*;

class Egg2 {
	protected class Yolk {
		public Yolk() { print("Egg2.Yolk()");}
		public void f() { print("Egg2.Yolk.f()");}
	}

	private Yolk y = new Yolk();

	public Egg2() { print("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() { print("BigEgg2.Yolk()");}
		public void f() { print("BigEgg2.Yolk.f()");}
	}

	public BigEgg2() { insertYolk(new Yolk());}

	public static void main(String[] args){
		Egg2 e2 = new BigEgg2();
		e2.g();
	}
} /* Output:
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()
*/

局部内部类（在方法体里面创建）

1. 局部内部类不能有访问说明符

2. 可以访问当前代码块内的所有常量

3. 可以访问外围类的所有成员

局部内类与匿名内部类创建的比较：

// Holds a sequence of Objects.
import static net.mindview.util.Print.*;

interface Counter {
	int next();
}

public class LocalInnerClass {
	private int count = 0;

	Counter getCounter(final String name) {
		// A local inner class:
		class LocalCounter implements Counter {
			public LocalCounter() {
				// Local inner class can have a constructor
				print("LocalCounter()");
			}

			public int next() {
				printnb(name);	// Access local final
				return count++;
			}
		}

		return new LocalCounter();
	}

	// The same thing with an anonymous inner class:
	Counter getCounter2(final String name) {
		return new Counter() {
			// Anonymous inner class cannot have a named
			// constructor, only an instance initializer:
			{
				print("Counter()");
			}

			public int next(){
				printnb(name);	// Access local final
				return count++;
			}
		};
	}

	public static void main(String[] args){
		LocalInnerClass lic = new LocalInnerClass();
		Counter
			c1 = lic.getCounter("Local inner "),
			c2 = lic.getCounter2("Anonymous inner ");

		for(int i = 0; i < 5; ++i)
			print(c1.next());
		for(int i = 0; i < 5; ++i)
			print(c2.next());
	}
} /* Output:
LocalCounter()
Counter()
Local inner 0
Local inner 1
Local inner 2
Local inner 3
Local inner 4
Anonymous inner 5
Anonymous inner 6
Anonymous inner 7
Anonymous inner 8
Anonymous inner 9
*/

每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息（此信息中产生一个"meta-class"，叫做class对象）。

内部类也必须产生一个.class文件以包含它们的信息。它们的命名规则是：外围类的名字加上“$”，再加上内部类的名字。

例如，LocalInnerClass.java生成的.class文件包括：

Counter.class

LocalInnerClass$1.class

LocalInnerClass$1LocalCounte.class

LocalInnerClass$1LocalCounter.class

LocalInnerClass.class

以上中，如果内部类是匿名的，编译器会简单地产生一个数字作为其标示符。