5 Java内部类|静态内部类|访问权限控制

1 访问控制(access control)

访问控制符都是针对类型而言的，不是针对对象的，但是访问绝大多数都是通过对象来实现的，这两者因为这个纠缠在一起了，需要捋清楚这之间的关系。

	private	default	protected	public
本类	√	√	√	√
同包内的类，子类或非子类		√	√	√
不同包子类			√	√
不同包内的非子类				√

访问控制符是在设计类时用到，但是很多情况下，只能通过使用实例的时候体现效果的。因为一个类无法直接使用另一个类的成员（静态和内部类除外）。

我这里的第一列分类，和网上流传的有些许区别，分类集合没有交集，更加清晰，能让你明白，能够access的具体原因。

这里举个例子，通过实例访问了私有域，进一步说明了访问控制是针对类型而言的。

public class Private {

    /**
     * 私有域
     */
    private Integer integer;


    public void f() {
        Private p = new Private();
        // 允许通过对象访问私有域，因为还是在本类里
        p.integer = 4;
    }
}

2 静态特点（static）

静态成员存在于方法区（JVM标准区域，要看具体实现方案），随着类的加载而被加载，可以通过类名直接访问，相当于全生命周期可访问。但是如果static和访问控制一起使用，就会有点困惑。关于这一点，需要我们想通。static是从生命周期维度控制，访问控制是从范围维度控制，他们的组合并不奇怪，private static修饰的成员只能在本类使用，其实这样的使用场景并不多，public static这样的场景会多些。

3 内部类

Java是一门纯粹的面向对象编程语言，一般而言，一个类型就是一个java文件，如果将一个类型定义到另一个类型里面，那么两个类型就只有一个Java文件(仅限源代码，编译过后还是一个类型对应一个class文件)。使用内部类的一部分原因就是为了满足面向对象编程+封装思想，有时一个类型中还可以更细粒度的进行封装，这时如果我们将整个能力封装为一个独立的类型，是有过度封装的嫌疑的，那么将这个能力以类型的方式封装到另一个类型中，就完美的中和了这种矛盾。另外，内部类可以继承另外一个类，这样就一定程度上弥补了Java无法多继承的遗憾。还有，内部类在回调函数的编写上也提供了极大的方便。下面我们来讲讲内部类的特性。

根据使用内部类方式，我们将内部类划分为四种，

1、静态内部类

2、非静态内部类

3、局部内部类

4、匿名内部类

内部类具备的通用特性是外部类无法访问内部类，内部类却能访问外部类(甚至私有数据)。我们来说说这里几种内部类的用途。

静态内部类：

静态内部类是一个比较特殊的情况，一旦内部类使用static修饰，那么此时这个内部类就升级为顶级类。static内部类不仅可以在内部定义static元素，而且在构建对象的时候也可以一次完成。从某种意义上说，static内部类已经不算是严格意义上的内部类了，一般而言，静态内部类的访问控制我们都使用默认，也即包访问级别，这个在HashMap实现源码中可以得以证实。

静态内部类的使用不依赖外部类，也就是说你可以直接通过外部类型引用内部类型，如new OuterClass.InnerClass()，同时静态内部类由于是静态，所以无法访问外部类非静态数据，这是静态属性决定的。静态内部类多用于同一个功能的封装需要多个类型来支持，而内部类功能相对单一，所以将其放到外部类中，达到封装和简洁的目的。另外ThreadLocal中就有静态内部类ThreadLocalMap，可以看看官方的使用方式。

非静态成员内部类：

可以和静态内部类对比，

1 非静态内部类的创建需要先创建外部类，非静态内部类独立使用方式是new OuterClass().new InnerClass()

2 内部类可以访问外部类数据(包括私有)，但是外部类无法访问内部类数据

3 可以定义内部接口，且可以定义另外一个内部类实现这个内部接口

4 可以在方法体内定义一个内部类，方法体内的内部类可以完成一个基于虚方法形式的回调操作

5 内部类不能定义static元素

6 内部类可以多嵌套

局部内部类：

局部内部类使用很少，分为两种情况，一种是静态方法中局部类，这时的局部类可以访问外部类的静态数据，如果在非静态方法中，则可以访问外部类的所有数据，包括私有，局部内部类可以访问方法局部变量，但是必须是final修饰的局部变量。局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的

匿名内部类：

这个使用多，匿名说的是隐匿了类型的名字，所以一般需要一个接口或者超类来表示类型，下面就是实例化Runnable接口的子类是就隐匿了子类的名字，使代码变得简单优雅，匿名内部类的使用往往也是为了简化代码，也涉及了回调。

new Thread( new Runnable() {
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}).start();

知道了为什么需要内部类，你就很自然的知道那些时候需要使用内部类了。

回调函数

回调用于层间协作，例如作为一个驱动，是一个底层，他在收到一个数据时，除了完成本层的处理工作外，还将进行回调，将这个数据交给上层应用层来做进一步处理，这在分层的数据通信中很普遍。
其实回调和API非常接近，他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用，一般这个函数对高层都是已知的；而回调正好相反，他是高层提供给底层的调用，对于低层他是未知的，必须由高层进行安装，这个安装函数其实就是一个低层提供的API，安装后低层不知道这个回调的名字，但它通过一个函数指针来保存这个回调，在需要调用时，只需引用这个函数指针和相关的参数指针。其实：回调就是该函数写在高层，低层通过一个函数指针保存这个函数，在某个事件的触发下，低层通过该函数指针调用高层那个函数。在C/C++中，要用回调函数，被调函数需要告诉调用者自己的指针地址，但在JAVA中没有指针，怎么办？我们可以通过接口（interface）来实现定义回调函数。

interface Incrementable {
    void increment();
}

/**
 * 被调者1
 */
class Callee1 implements Incrementable {
    private int i = 0;

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

class MyIncrementable {

    public void increment() {
        System.out.println("Other Operarion");
    }

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

/**
 * 被调者2，往往是一个已经存在的类型，需要改在，然后添加一个内部类，并给出get器暴露出去
 */
class Callee2 extends MyIncrementable {
    private int i = 0;

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

    /**
     * 内部类，闭包，也即回调实现
     */
    private class Closure implements Incrementable {
        @Override
        public void increment() {
            // 调用外部类的方法
            Callee2.this.increment();
        }
    }

    /**
     * 获取回调引用
     *
     * @return
     */
    Incrementable getCallbackReference() {
        return new Closure();
    }
}

/**
 * 调用者
 */
class Caller {
    private Incrementable callbackReference;

    Caller(Incrementable cbn) {
        callbackReference = cbn;
    }

    void go() {
        callbackReference.increment();
    }
}

/**
 *
 */
public class Callbacks {
    public static void main(String[] args) {
        Callee1 c1 = new Callee1();
        Callee2 c2 = new Callee2();
        MyIncrementable.f(c2); // Other Operarion 1
        // 塞一个函数进去
        Caller caller1 = new Caller(c1);
        // 
        Caller caller2 = new Caller(c2.getCallbackReference());
        caller1.go(); // 1
        caller1.go(); // 2
        caller2.go(); // Other Operarion 1
        caller2.go(); // Other Operarion 2
    }


}

这个例子进一步展示了外围类实现一个接口与内部类实现此接口之间的区别。就代码而言，Callee1是简单的解决方式。Callee2继承自MyIncrement，后者已经有了一个不同的increment()方法，并且与Incrementable接口期望的increment()方法完全不相关。所以如果Callee2继承了MyIncrement，就不能为了Incrementable的用途而覆盖increment()方法，于是只能使用内部类独立地实现Incrementable。还要注意，当创建了一个内部类时，并没有在外围内的接口中添加东西，也没有修改外围类的接口。

注意，在Callee2中除了getCallbackReference()以外，其他成员都是private的。要想建立与外部世界的任何连接，interface Incrementable都是必须的。在这里可以看到，interface是如何允许接口与接口的实现完全独立的。

内部类Closure实现了Incrementable，以提供一个返回Callee2的钩子，而且是一个安全的钩子。无论谁获得此Incrementable的引用，都只能调用increment()，除此之外没有其他功能(不像指针那样，允许你做很多事情)。

Caller的构造器需要一个Incrementable的引用作为参数（虽然可以在任意时刻捕获回调引用），然后在以后的某个时刻，Caller对象可以使用此引用回调Callee类。

回调的价值在于它的灵活性，可以在运行时动态地决定需要调用什么方法。这样做的好处在实现GUI功能的时候随处可见，那里到处都用到了回调。