java基础之内部类

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

我们首先说一下内部类：

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

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

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

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

interface Incrementable {
    void increment();
}

class Callee1 implements Incrementable {
    private int i = 0;
    public void increment() {
        i++;
        System.out.println(i);
    }
    public static class NestedClass{
        public  static  void increment(){
            System.out.println("NestedClass.increment()");
        }
    }
}

class MyIncrement {
    public void increment() {
        System.out.println("Other operation");
    }

    static void f(MyIncrement mi) {
        mi.increment();
    }
}

class Callee2 extends MyIncrement {
    private int i = 0;

    @Override
    public void increment() {
        super.increment();
        i++;
        System.out.println(i);
    }

    private class Closure implements Incrementable {
        public void increment() {
            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();
        Callee1.NestedClass.increment();
    }
}

 

 

 （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

反编译后发现：

内部类多了一个构造方法

class Callee2$Closure
  implements Incrementable
{
  private Callee2$Closure(Callee2 paramCallee2) {}

  public void increment()
  {
    this.this$0.increment();
  }
}

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

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

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

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

 

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