Java编程的逻辑 (21) - 内部类的本质

本系列文章经补充和完善，已修订整理成书《Java编程的逻辑》，由机械工业出版社华章分社出版，于2018年1月上市热销，读者好评如潮！各大网店和书店有售，欢迎购买，京东自营链接：http://item.jd.com/12299018.html

---

内部类

之前我们所说的类都对应于一个独立的Java源文件，但一个类还可以放在另一个类的内部，称之为内部类，相对而言，包含它的类称之为外部类。

为什么要放到别的类内部呢？一般而言，内部类与包含它的外部类有比较密切的关系，而与其他类关系不大，定义在类内部，可以实现对外部完全隐藏，可以有更好的封装性，代码实现上也往往更为简洁。

不过，内部类只是Java编译器的概念，对于Java虚拟机而言，它是不知道内部类这回事的, 每个内部类最后都会被编译为一个独立的类，生成一个独立的字节码文件。

也就是说，每个内部类其实都可以被替换为一个独立的类。当然，这是单纯就技术实现而言，内部类可以方便的访问外部类的私有变量，可以声明为private从而实现对外完全隐藏，相关代码写在一起，写法也更为简洁，这些都是内部类的好处。

在Java中，根据定义的位置和方式不同，主要有四种内部类：

• 静态内部类
• 成员内部类
• 方法内部类
• 匿名内部类

方法内部类是在一个方法内定义和使用的，匿名内部类使用范围更小，它们都不能在外部使用，成员内部类和静态内部类可以被外部使用，不过它们都可以被声明为private，这样，外部就使用不了了。

接下来，我们逐个介绍这些内部类的语法、实现原理以及使用场景。

静态内部类

语法

静态内部类与静态变量和静态方法定义的位置一样，也带有static关键字，只是它定义的是类，示例代码如下：

public class Outer {
    private static int shared = 100;

    public static class StaticInner {
        public void innerMethod(){
            System.out.println("inner " + shared);
        }
    }

    public void test(){
        StaticInner si = new StaticInner();
        si.innerMethod();
    }
}

外部类为Outer，静态内部类为StaticInner，带有static修饰符。语法上，静态内部类除了位置放在别的类内部外，它与一个独立的类差别不大，可以有静态变量、静态方法、成员方法、成员变量、构造方法等。

静态内部类与外部类的联系也不大（与后面其他内部类相比）。它可以访问外部类的静态变量和方法，如innerMethod直接访问shared变量，但不可以访问实例变量和方法。在类内部，可以直接使用内部静态类，如test()方法所示。

public静态内部类可以被外部使用，只是需要通过"外部类.静态内部类"的方式使用，如下所示：

Outer.StaticInner si = new Outer.StaticInner();
si.innerMethod();

实现原理

以上代码实际上会生成两个类，一个是Outer，另一个是Outer$StaticInner，它们的代码大概如下所示：

public class Outer {
    private static int shared = 100;

    public void test(){
        Outer$StaticInner si = new Outer$StaticInner();
        si.innerMethod();
    }

    static int access$0(){
        return shared;
    }
}

public class Outer$StaticInner {
    public void innerMethod() {
        System.out.println("inner " + Outer.access$0());
    }
}

内部类访问了外部类的一个私有静态变量shared，而我们知道私有变量是不能被类外部访问的，Java的解决方法是，自动为Outer生成了一个非私有访问方法access$0，它返回这个私有静态变量shared。

使用场景

静态内部类使用场景是很多的，如果它与外部类关系密切，且不依赖于外部类实例，则可以考虑定义为静态内部类。

比如说，一个类内部，如果既要计算最大值，也要计算最小值，可以在一次遍历中将最大值和最小值都计算出来，但怎么返回呢？可以定义一个类Pair，包括最大值和最小值，但Pair这个名字太普遍，而且它主要是类内部使用的，就可以定义为一个静态内部类。

我们也可以看一些在Java API中使用静态内部类的例子：

• Integer类内部有一个私有静态内部类IntegerCache，用于支持整数的自动装箱。
• 表示链表的LinkedList类内部有一个私有静态内部类Node，表示链表中的每个节点。
• Character类内部有一个public静态内部类UnicodeBlock，用于表示一个Unicode block。

以上这些类我们在后续文章再介绍。

成员内部类

语法
成员内部类没有static修饰符，少了一个static修饰符，但含义却有很大不同，示例代码如下：

public class Outer {
    private int a = 100;

    public class Inner {
        public void innerMethod(){
            System.out.println("outer a " +a);
            Outer.this.action();
        }
    }

    private void action(){
        System.out.println("action");
    }

    public void test(){
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

Inner就是成员内部类，与静态内部类不同，除了静态变量和方法，成员内部类还可以直接访问外部类的实例变量和方法，如innerMethod直接访问外部类私有实例变量a。成员内部类还可以通过"外部类.this.xxx"的方式引用外部类的实例变量和方法，如Outer.this.action()，这种写法一般在重名的情况下使用，没有重名的话，"外部类.this."是多余的。

在外部类内，使用成员内部类与静态内部类是一样的，直接使用即可，如test()方法所示。与静态内部类不同，成员内部类对象总是与一个外部类对象相连的，在外部使用时，它不能直接通过new Outer.Inner()的方式创建对象，而是要先将创建一个Outer类对象，代码如下所示：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.innerMethod();

创建内部类对象的语法是"外部类对象.new 内部类()"，如outer.new Inner()。

与静态内部类不同，成员内部类中不可以定义静态变量和方法 (final变量例外，它等同于常量），下面介绍的方法内部类和匿名内部类也都不可以。Java为什么要有这个规定呢？具体原因不得而知，个人认为这个规定不是必须的，Java这个规定大概是因为这些内部类是与外部实例相连的，不应独立使用，而静态变量和方法作为类型的属性和方法，一般是独立使用的，在内部类中意义不大吧，而如果内部类确实需要静态变量和方法，也可以挪到外部类中。

实现原理

以上代码也会生成两个类，一个是Outer，另一个是Outer$Inner，它们的代码大概如下所示：

public class Outer {
    private int a = 100;

    private void action() {
        System.out.println("action");
    }

    public void test() {
        Outer$Inner inner = new Outer$Inner(this);
        inner.innerMethod();
    }

    static int access$0(Outer outer) {
        return outer.a;
    }

    static void access$1(Outer outer) {
        outer.action();
    }
}

public class Outer$Inner {

    final Outer outer;

    public Outer$Inner(Outer outer){
        ths.outer = outer;
    }

    public void innerMethod() {
        System.out.println("outer a "
                + Outer.access$0(outer));
        Outer.access$1(outer);
    }
}

Outer$Inner类有个实例变量outer指向外部类的对象，它在构造方法中被初始化，Outer在新建Outer$Inner对象时传递当前对象给它，由于内部类访问了外部类的私有变量和方法，外部类Outer生成了两个非私有静态方法，access$0用于访问变量a，access$1用于访问方法action。
使用场景
如果内部类与外部类关系密切，且操作或依赖外部类实例变量和方法，则可以考虑定义为成员内部类。

外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能使用内部类实现这个接口，这个内部类可以被设为private，对外完全隐藏。

比如说，在Java API 类LinkedList中，它的两个方法listIterator和descendingIterator的返回值都是接口Iterator，调用者可以通过Iterator接口对链表遍历，listIterator和descendingIterator内部分别使用了成员内部类ListItr和DescendingIterator，这两个内部类都实现了接口Iterator。关于LinkedList，后续文章我们还会介绍。

方法内部类

语法

内部类还可以定义在一个方法体中，示例代码如下所示：

public class Outer {
    private int a = 100;

    public void test(final int param){
        final String str = "hello";
        class Inner {
            public void innerMethod(){
                System.out.println("outer a " +a);
                System.out.println("param " +param);
                System.out.println("local var " +str);
            }
        }
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

类Inner定义在外部类方法test中，方法内部类只能在定义的方法内被使用。如果方法是实例方法，则除了静态变量和方法，内部类还可以直接访问外部类的实例变量和方法，如innerMethod直接访问了外部私有实例变量a。如果方法是静态方法，则方法内部类只能访问外部类的静态变量和方法。

方法内部类还可以直接访问方法的参数和方法中的局部变量，不过，这些变量必须被声明为final，如innerMethod直接访问了方法参数param和局部变量str。

实现原理

系统生成的两个类代码大概如下所示：

public class Outer {
    private int a = 100;

    public void test(final int param) {
        final String str = "hello";
        OuterInner inner = new OuterInner(this, param);
        inner.innerMethod();
    }

    static int access$0(Outer outer){
        return outer.a;
    }
}

public class OuterInner {
    Outer outer;
    int param;

    OuterInner(Outer outer, int param){
        this.outer = outer;
        this.param = param;
    }

    public void innerMethod() {
        System.out.println("outer a "
                + Outer.access$0(this.outer));
        System.out.println("param " + param);
        System.out.println("local var " + "hello");
    }
}

与成员内部类类似，OuterInner类也有一个实例变量outer指向外部对象，在构造方法中被初始化，对外部私有实例变量的访问也是通过Outer添加的方法access$0来进行的。

方法内部类可以访问方法中的参数和局部变量，这是通过在构造方法中传递参数来实现的，如OuterInner构造方法中有参数int param，在新建OuterInner对象时，Outer类将方法中的参数传递给了内部类，如OuterInner inner = new OuterInner(this, param);。在上面代码中，String str并没有被作为参数传递，这是因为它被定义为了常量，在生成的代码中，可以直接使用它的值。

这也解释了，为什么方法内部类访问外部方法中的参数和局部变量时，这些变量必须被声明为final，因为实际上，方法内部类操作的并不是外部的变量，而是它自己的实例变量，只是这些变量的值和外部一样，对这些变量赋值，并不会改变外部的值，为避免混淆，所以干脆强制规定必须声明为final。

如果的确需要修改外部的变量，可以将变量改为只含该变量的数组，修改数组中的值，如下所示：

public class Outer {
    public void test(){
        final String[] str = new String[]{"hello"};
        class Inner {
            public void innerMethod(){
                str[0] = "hello world";
            }
        }
        Inner inner = new Inner();
        inner.innerMethod();
        System.out.println(str[0]);
    }
}

str是一个只含一个元素的数组。

使用场景

方法内部类都可以用成员内部类代替，至于方法参数，也可以作为参数传递给成员内部类。不过，如果类只在某个方法内被使用，使用方法内部类，可以实现更好的封装。

匿名内部类

语法

匿名内部类没有名字，在创建对象的同时定义类，语法如下：

new 父类(参数列表) {
   //匿名内部类实现部分
}

或者

new 父接口() {
   //匿名内部类实现部分
}

匿名内部类是与new关联的，在创建对象的时候定义类，new后面是父类或者父接口，然后是圆括号()，里面可以是传递给父类构造方法的参数，最后是大括号{}，里面是类的定义。

看个具体的代码：

public class Outer {
    public void test(final int x, final int y){
        Point p = new Point(2,3){                

            @Override
            public double distance() {
                return distance(new Point(x,y));
            }
        };                                       

        System.out.println(p.distance());
    }
}

创建Point对象的时候，定义了一个匿名内部类，这个类的父类是Point，创建对象的时候，给父类构造方法传递了参数2和3，重写了distance()方法，在方法中访问了外部方法final参数x和y。

匿名内部类只能被使用一次，用来创建一个对象。它没有名字，没有构造方法，但可以根据参数列表，调用对应的父类构造方法。它可以定义实例变量和方法，可以有初始化代码块，初始化代码块可以起到构造方法的作用，只是构造方法可以有多个，而初始化代码块只能有一份。

因为没有构造方法，它自己无法接受参数，如果必须要参数，则应该使用其他内部类。

与方法内部类一样，匿名内部类也可以访问外部类的所有变量和方法，可以访问方法中的final参数和局部变量

实现原理

每个匿名内部类也都被生成为了一个独立的类，只是类的名字以外部类加数字编号，没有有意义的名字。上例中，产生了两个类Outer和Outer$1，代码大概如下所示：

public class Outer {
    public void test(final int x, final int y){
        Point p = new Outer$1(this,2,3,x,y);
        System.out.println(p.distance());
    }
}

public class Outer$1 extends Point {
    int x2;
    int y2;
    Outer outer;

    Outer$1(Outer outer, int x1, int y1, int x2, int y2){
        super(x1,y1);
        this.outer = outer;
        this.x2 = x2;
        this.y2 = y2;
    }

    @Override
    public double distance() {
        return distance(new Point(this.x2,y2));
    }
}

与方法内部类类似，外部实例this，方法参数x和y都作为参数传递给了内部类构造方法。此外，new时的参数2和3也传递给了构造方法，内部类构造方法又将它们传递给了父类构造方法。

使用场景

匿名内部类能做的，方法内部类都能做。但如果对象只会创建一次，且不需要构造方法来接受参数，则可以使用匿名内部类，代码书写上更为简洁。

在调用方法时，很多方法需要一个接口参数，比如说Arrays.sort方法，它可以接受一个数组，以及一个Comparator接口参数，Comparator有一个方法compare用于比较两个对象。

比如说，我们要对一个字符串数组不区分大小写排序，可以使用Arrays.sort方法，但需要传递一个实现了Comparator接口的对象，这时就可以使用匿名内部类，代码如下所示：

public void sortIgnoreCase(String[] strs){
    Arrays.sort(strs, new Comparator<String>() {

        @Override
        public int compare(String o1, String o2) {
            return o1.compareToIgnoreCase(o2);
        }
    });
}

Comparator后面的<Stirng>与泛型有关，表示比较的对象是字符串类型，后续文章会讲解泛型。

匿名内部类还经常用于事件处理程序中，用于响应某个事件，比如说一个Button，处理点击事件的代码可能类似如下：

Button bt = new Button();
bt.addActionListener(new ActionListener(){
    @Override
    public void actionPerformed(ActionEvent e) {
        //处理事件
    }
});

调用addActionListener将事件处理程序注册到了Button对象bt中，当事件发生时，会调用actionPerformed方法，并传递事件详情ActionEvent作为参数。

以上Arrays.sort和Button都是上节提到的一种针对接口编程的例子，另外，它们也都是一种回调的例子。所谓回调是相对于一般的正向调用而言，平时一般都是正向调用，但Arrays.sort中传递的Comparator对象，它的compare方法并不是在写代码的时候被调用的，而是在Arrays.sort的内部某个地方回过头来调用的。Button中的传递的ActionListener对象，它的actionPerformed方法也一样，是在事件发生的时候回过头来调用的。

将程序分为保持不变的主体框架，和针对具体情况的可变逻辑，通过回调的方式进行协作，是计算机程序的一种常用实践。匿名内部类是实现回调接口的一种简便方式。

小结

本节，我们谈了各种内部类的语法、实现原理、以及使用场景，内部类本质上都会被转换为独立的类，但一般而言，它们可以实现更好的封装，代码上也更为简洁。

我们一直没有讨论一个重要的问题，类放在哪里？类文件是如何组织的？本节中，自动生成的方法如access$0没有可见性修饰符，那可见性是什么？这些都与包有关，让我们下节来探讨。

----------------

未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，从入门到高级，深入浅出，老马和你一起探索Java编程及计算机技术的本质。用心写作，原创文章，保留所有版权。

-----------

更多相关原创文章

计算机程序的思维逻辑 (13) - 类

计算机程序的思维逻辑 (14) - 类的组合

计算机程序的思维逻辑 (15) - 初识继承和多态

计算机程序的思维逻辑 (16) - 继承的细节

计算机程序的思维逻辑 (17) - 继承实现的基本原理

计算机程序的思维逻辑 (18) - 为什么说继承是把双刃剑

计算机程序的思维逻辑 (19) - 接口的本质

计算机程序的思维逻辑 (20) - 为什么要有抽象类？