Java中的Kotlin 内部类原理-Java开发

这篇文章主要介绍了Java中的Kotlin 内部类原理，文章围绕主题展开详细的内容介绍，具有一定的参考价值，感兴趣的小伙伴可以参考一下

Java 中的内部类

这是一个 Java 内部类的简单实现：

public class OutterJava {
    private void printOut() {
        System.out.println("AAA");
    }

    class InnJava {
        public void printInn() {
            printOut();
        }
    }
}

外部类是一个私有方法，内部类为什么可以访问到外部类的私有方法呢？思考这个问题，首先要从它的字节码入手，看看 JVM 到底对 java 文件做了什么。

字节码分析流程是：

javac xxx.java生成 class 文件。
javap -c xxx.class对代码进行反汇编，可以生成可查看的代码内容。

通过 javac 命令生成 class 文件，此时会发现生成了两个 class 文件，一个外部类 OtterJava 的，一个内部类 InnJava 的。

OutterJava.class

OutterJava.class 反汇编后的代码如下所示，这里面除了一个构造方法，多生成了一个

Compiled from "OutterJava.java"
public class java.OutterJava {
  public java.OutterJava();
    Code:
       0: aload_0
       1: invokespecial #2                  // Method java/lang/Object."<init>":()V
       4: return

  private void printOut();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #4                  // String AAA
       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  static void access$000(java.OutterJava);
    Code:
       0: aload_0
       1: invokespecial #1                  // Method printOut:()V
       4: return
}

从反编译出来的内容来看，多了一个静态的access$000(OutterJava)方法，它的内部调用了 printOut()。

InnJava.class

Compiled from "OutterJava.java"
class java.OutterJava$InnJava {
  final java.OutterJava this$0;

  java.OutterJava$InnJava(java.OutterJava);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:Ljava/OutterJava;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printInn2();
    Code:
       0: aload_0
       1: getfield      #1                  // Field this$0:Ljava/OutterJava;
       4: invokestatic  #3                  // Method java/OutterJava.access$000:(Ljava/OutterJava;)V
       7: return
}

在 InnJava 的字节码反编译出来的内容中，主要有两个点需要注意：

构造方法需要一个外部类参数，并把这个外部类实例保存到了this$0中。
调用外部类私有方法，实际上是调用了OutterJava.access$000方法。

小结：

在 Java 中，内部类与外部类的关系是：

内部类持有外部类的引用，作为内部构造参数传入外部类实例，并保存到了内部类的属性this$0中。
内部类调用外部类的私有方法，实际上是外部类生成了内部实际调用私有方法的静态方法access$000，内部类可以通过这个静态方法访问到外部类中的私有方法。

Kotlin 中的内部类

同样的 Java 代码，用 Kotlin 实现：

class Outter {
    private fun printOut() {
        println("Out")
    }

    inner class Inner {
        fun printIn() {
            printOut()
        }
    }
}

这里如果不加inner关键字，printIn()内的printOut()会报错Unresolved reference: printOut 。

不加inner关键字，反编译后的字节码：

public final class java/Outter$Inner {
  // ...
  public <init>()V
   L0
    LINENUMBER 8 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Ljava/Outter$Inner; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
  // ...
}

不加inner关键字，内部类的构造方法是没有外部类实例参数的。如果加上inner，就和 Java 一样：

  // 加上了 inner 的构造方法
  public <init>(Ljava/Outter;)V
   L0
    LINENUMBER 8 L0
    ALOAD 0
    ALOAD 1
    PUTFIELD java/Outter$Inner.this$0 : Ljava/Outter;
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
   L1
    LOCALVARIABLE this Ljava/Outter$Inner; L0 L1 0
    LOCALVARIABLE this$0 Ljava/Outter; L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

而内部类对于外部类私有方法的访问，也是通过静态方法access$XXX来实现的：

  public final static synthetic access$printOut(Ljava/Outter;)V
   L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/Outter.printOut ()V
    RETURN
   L1
    LOCALVARIABLE $this Ljava/Outter; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1