java基础之内部类


内部类：将一个类定义在另一个类的内部。如果这个类是static类型的，我们通常称其为“嵌套类”。

我们首先说一下内部类：

①我们将类置于其他类的内部，可以很容易的实现代码隐藏。

②当我们建立内部类的对象时，这个对象就与制造它的外部对象建立了联系，即内部对象能够访问外围对象的所有成员。

③每个内部类都可以独立的继承一个类，而无论外围类是否已经继承了这个接口或者类。

结合下面的例子我们来进一步分析：

Java代码  收藏代码
  1. interface Incrementable {  
  2.     void increment();  
  3. }  
  4.   
  5. class Callee1 implements Incrementable {  
  6.     private int i = 0;  
  7.     public void increment() {  
  8.         i++;  
  9.         System.out.println(i);  
  10.     }  
  11.     public static class NestedClass{  
  12.         public  static  void increment(){  
  13.             System.out.println("NestedClass.increment()");  
  14.         }  
  15.     }  
  16. }  
  17.   
  18. class MyIncrement {  
  19.     public void increment() {  
  20.         System.out.println("Other operation");  
  21.     }  
  22.   
  23.     static void f(MyIncrement mi) {  
  24.         mi.increment();  
  25.     }  
  26. }  
  27.   
  28. class Callee2 extends MyIncrement {  
  29.     private int i = 0;  
  30.   
  31.     @Override  
  32.     public void increment() {  
  33.         super.increment();  
  34.         i++;  
  35.         System.out.println(i);  
  36.     }  
  37.   
  38.     private class Closure implements Incrementable {  
  39.         public void increment() {  
  40.             Callee2.this.increment();  
  41.         }  
  42.     }  
  43.   
  44.     Incrementable getCallbackReference() {  
  45.         return new Closure();  
  46.     }  
  47. }  
  48.   
  49. class Caller {  
  50.     private Incrementable callbackReference;  
  51.   
  52.     Caller(Incrementable cbh) {  
  53.         callbackReference = cbh;  
  54.     }  
  55.   
  56.     void go() {  
  57.         callbackReference.increment();  
  58.     }  
  59. }  
  60.   
  61. public class Callbacks {  
  62.     public static void main(String[] args) {  
  63.         Callee1 c1 = new Callee1();  
  64.         Callee2 c2 = new Callee2();  
  65.         MyIncrement.f(c2);  
  66.         Caller caller1 = new Caller(c1);  
  67.         Caller caller2 = new Caller(c2.getCallbackReference());  
  68.         caller1.go();  
  69.         caller1.go();  
  70.         caller2.go();  
  71.         caller2.go();  
  72.         Callee1.NestedClass.increment();  
  73.     }  
  74. }  

 

 

 （1）我们可以看出closure内部类实现了接口Incrementable，而且为private类型的内部类，所以对于其他类来说它的完全隐藏的，但其使得外围类具有了接口Incrementable的功能，同时对于外界来说，也不能访问任何新增加的、本不属于公共接口的方法。

 

  （2）闭包(closure) 是一个可调用的对象，它记录了一些信息，这些信息用于创建它的作用域。由于内部类不仅包含外围对象的信息，还自动拥有一个指向此外围类对象的引用，再此作用域内，内部类有权操作所有的成员，包括private成员。这有点类似指针。。

 我们看到Callee2继承了MyIncrement，而MyIncrement已经有了一个increment()方法，Callee2想要在拥有一个不同的Increment()方法，于是通过内部类独立的实现Incrementable。

内部类Closure实现了Incrementable，而且还提供了返回Callee2的hook，而且比较的安全，无论谁获得此Incrementable的引用，都只能调用increment()（不像指针可以做很多的事情）。

 （3）由于内部类具有继承多个类的能力，可以看出内部类有效的实现了“多重继承”，使得Java中的多重继承方案变得更加的完整。

嵌套类：

如果内部类声明为static，通常称为嵌套类。嵌套类与内部类不同的是，它的对象与外围类的对象之间不存在联系。而普通的内部类对象隐式的保存了一个引用，指向它的外围对象。

这一点可以通过反编译内部类与嵌套类的反编译代码看出来：

Callee1$NestedClass.class

Callee2$Closure.class

反编译后发现：

内部类多了一个构造方法

Java代码  收藏代码
  1. class Callee2$Closure  
  2.   implements Incrementable  
  3. {  
  4.   private Callee2$Closure(Callee2 paramCallee2) {}  
  5.    
  6.   public void increment()  
  7.   {  
  8.     this.this$0.increment();  
  9.   }  
  10. }  

 
内部类还具有其他的一些特性

a）内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围对象的信息相互独立。

b）在单个外围类中，可以让多个内部类以不同的方式实现统一接口，或继承同一个类。应用：命令设计模式

c）创建内部类的时刻并不依赖外围类的创建。

 

当然内部类比较的深奥和复杂，现在只是简单的理解它的语法，还需要在实际的应用中不断的思考和理解。

posted @ 2014-08-02 14:57  JAVA之迷  阅读(356)  评论(0)  编辑  收藏  举报