Thinking in Java 笔记:Inner Class

http://juiccee.javaeye.com/blog/242201

 将一个类的定义放在另一个类的定义内部,这就是内部类

当你生成一个内部类对象时,该对象必定会保存一个制造他的外围类对象的引用,所以内部类对象可以访问其外围类对象的所有成员,此外内部类拥有外围类所有元素的访问权(包括声明为private的),内部类作为外围类的一个成员,外围类对象也可以访问内部类的所有元素.

在除了外部类的非静态方法之外的任何地方创建某个内部类的对象,必须用:OutClassName.InnerClassName具体的指明这个对象的类型
如果要直接创建一个内部类的对象,必须使用外部类的一个对象和". new"来创建内部类的一个对象
例如:Parcel3.Contents c = p.new Contents();
因此,除非你已经有了一个外围类的对象,否则不可能生成内部类的对象(除非是嵌套类(static inner class)),因为内部类对象需要保存创建它的外围类对象的引用.

使用OutClassName.this可以返回制造这个内部类的那个外围类的引用.

内部类可以声明在方法中,或者是方法中的某个作用域中,,但是出了这个方法或作用域,改类不能再被使用(不能使用其声明或创建对象)

内部类(Inner class) VS 嵌套类(Nested class)
将内部类声明为static通常称为嵌套类,内部类对象隐含地保存了一个引用指向创建它的外围类对象.而要创建嵌套类不需要外围类对象,不能从嵌套类对象中访问非静态的外围类对象.
普通内部类中不能有static的属性和方法,也不能包含嵌套类,而嵌套类可以包含所有的这些东西.
嵌套类可以作为接口的一部分,因为他是static的,只是将嵌套类放在接口的命名空间内.

为什么使用内部类:
非内部类不能声明为protect或private,将内部类声明为private或protect意味着客户端想要访问这些成员将受到严格的限制,对于声明为private的,只有其外围类可以访问,而声明为protect的,只有在一个包中或者从该内部类继承的类才可以访问.但这种隐藏机制并不是使用内部类的目的,毕竟将一个类声明为"包访问"便可以实现很好的代码隐藏.
但如果内部类实现了某个接口或者是从某个基类继承而来,则内部类就有了用武之地.因为这个内部类作为某个接口的实现或某个基类的继承对于其它人来说完全不可见,并且不可用,你所得到的只是一个指向基类或接口类型的一个引用.因为它们是private或protect的,所以你甚至不能将这个引用向下转型(除非你有继承protect内部类的子类),因为它们对你不可见.所以private内部类使用类的设计者可以阻止任何依赖于这些内部类的具体类型的编码,并且完全隐藏了细节,使接口与实现完全分离.此外,从客户端程序员的角度来说,由于不能访问任何原本不属于公共接口的方法,所以扩展接口是没有价值的.

内部类继承自某个类或者实现某个接口,内部类的代码操作创建它的外围类的对象,所以你可以认为内部类提供了一个某种进入其外围类的接口.典型的应用就是迭代子模式.

很多情况下你需要在接口的实现上工作,而每个内部类都能独立地实现一个继承一个接口的实现,无论外围类有没有实现接口,对内部类都没有影响.这样,使用内部类允许你的一个类继承多个非接口类型

Java代码

1. interface A {}   
2. interface B {}   
3.   
4. class X implements A, B {}   
5.   
6. class Y implements A {   
7.   B makeB() {   
8.     // Anonymous inner class:   
9.     return new B() {};   
10.   }   
11. }   
12.   
13. public class MultiInterfaces {   
14.   static void takesA(A a) {}   
15.   static void takesB(B b) {}   
16.   public static void main(String[] args) {   
17.     X x = new X();   
18.     Y y = new Y();   
19.     takesA(x);   
20.     takesA(y);   
21.     takesB(x);   
22.     takesB(y.makeB());   
23.   }   
24. }  

interface A {}
interface B {}

class X implements A, B {}

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

如果上面例子中要继承的是抽象或具体的类,则只能使用内部类来实现多重继承.

闭包与回调
闭包:闭包是一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域.
可以看出,内部类是面向对象的闭包,因为他不仅包含外围类对象的信息,还自动拥有一个指向此外围类对象的引用,在此作用域内,内部类有权操作所用的成员包括private成员.

在这里回调指的是内部类调用外部类的属性和方法,即使用回调可以使一些对象携带一些信息以允许它在稍后的某个时刻调用初始的对象.

回调函数:实际上就是在调用某个函数（通常是API函数）时，将自己的一个函数（这个函数为回调函数）的地址作为参数传递给那个函数。而那个函数在需要的时候，利用传递的地址调用回调函数，这时你可以利用这个机会在回调函数中处理消息或完成一定的操作。

回调机制:
1.系统承诺发生什么事件时会执行什么接口的什么方法.
2.由对事件有兴趣的对象预先实现一个符合接口的具体行为.注册到事件管理系统中,这样系统就有了一个指向这个接口的引用.
3.系统运行时由事件管理系统在事件发生时执行预定义的实现.