Java编程思想——第十章

第十章：内部类
创建内部类：类里面再定义一个类。如果从外部类的非静态方法之外的任意位置创建某个内部类的对象，必须要具体指明这个对象的类型：OutClassName.InnerClassName

链接到外部类：内部类能访问外围对象的所有成员，不需要任何特殊条件。内部类拥有外围类的所有元素的访问权。内部类可以访问外围类的方法和字段，就像其自己拥有似的。说明：在外围的类的对象创建时，内部类的引用会秘密捕获一个外围类的对象的引用，当访问外围类的成员时，就是用这个引用来选择外围类的成员，这是一般是编译器的事，我们可以简单忽略。

使用.this与.new：生成对外部类对象的引用使用外部类的名字后加.this。告诉某些其他对象去创建其某个内部类的对象，用.new语法。
package innerclasses;
public class DotThis {
void f() { System.out.println("DotThis.f()"); }
public class Inner {
public DotThis outer() {
return DotThis.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();
}
}

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

内部类与向上转型：将内部类向上转型为其基类，尤其是一个接口时，有用，因为此内部类-某个接口的实现能够完全不可见，且不可用，只得到接口或基类的引用，隐藏实现细节。看懂下例：
package innerclasses;
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) {
System.out.println(1);
return new PDestination(s);
}
public Contents contents() {
return new PContents();
}
}
public class TestParcel {
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Contents c = p.contents();
Destination d = p.destination("Tasmania");
}
}
interface Destination {
String readLabel();
}
interface Contents {
int value();
}
此例注：只有Parcel4能访问PContents，只有与Parcel4，其子类，包类(同一个包中的类)，能访问PDestination，客户端程序员访问这些类是受限制的，甚至不能向下(书上写向下，我理解为向上，我没懂，以后这里要修改，我不知道我怎么错了)转型成private内部类，因为不能访问其名字。所以可以完全阻止任何依赖于此类型的编码，并完全隐藏实现细节，客户端程序员不能访问任何新增加的、原本不属于公共接口的方法，接口扩展没有价值。

在方法和作用域的内部类：
定义内部类的理由：1、实现某类型的接口，创建返回对其引用，2、创建一个非公共可用的类来协助解决复杂问题。

匿名内部类：
public class Parcel7 {
public Contents contents() {
return new Contents() { // Insert a class definition
private int i = 11;
public int value() {
return i;
}
};
}
public static void main(String[] args) {
Parcel7 p = new Parcel7();
Contents c = p.contents();
}
}
interface Contents {
int value();
}
interface Destination {
String readLabel();
}
正要创建一个Contents对象，插入了一个类的定义——匿名内部类也！相当于下面代码：
public class Parcel7b {
class MyContents implements Contents {
private int 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();
}
}
如果定义一个内部类，希望它使用一个在其外部定义的对象，编译器要求其参数引用为final。如果参数不是外部对象且不被使用可以不是final，若使用这是final。