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文件包括：


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