java实名内部类详解

实名内部类是个很神奇的东西，当有static修饰class时，可以具有静态成员域和静态成员方法，当没有static修饰时，不能具有静态成员方法和静态成员域，但却可以具有static final修饰的成员域（常量池中有字面量的成员域）。为什么？为什么非static修饰的实名内部类可以应用外部类的成员域和成员方法呢？为什么不可以具有静态成员函数？为什么不可以具有静态代码块？

 

 

先来说说实名内部类的一些个人理解，以下会涉及一些JVM的相关知识。

 

 

非静态实名内部类：

在编译后，会生成两个.class文件，一个是非静态实名内部类，一个是外部类，当我们想要new一个非静态实名内部类时，必须通过外部类的实例对象，为什么？因为内部类可以引用外部类的成员域和成员函数，所以外部类必须具有实例对象，其实将内部类的.class文件反编译后，我们看到，非静态实名内部类含有外部类的this指针，代码如下

 

class A
{
    class B
    {
     
    }
}
public class Try {
    public static void main(String[] args) {
    } 
}

反编译内部类的class文件后：

 

 

  MD5 checksum e6c1ec0fd79c3c8b920ced2090ea57df
  Compiled from "Try.java"
class A$B
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Fieldref           #3.#13         // A$B.this$0:LA;
   #2 = Methodref          #4.#14         // java/lang/Object."<init>":()V
   #3 = Class              #16            // A$B
   #4 = Class              #19            // java/lang/Object
   #5 = Utf8               this$0
   #6 = Utf8               LA;
   #7 = Utf8               <init>
   #8 = Utf8               (LA;)V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               SourceFile
  #12 = Utf8               Try.java
  #13 = NameAndType        #5:#6          // this$0:LA;
  #14 = NameAndType        #7:#20         // "<init>":()V
  #15 = Class              #21            // A
  #16 = Utf8               A$B
  #17 = Utf8               B
  #18 = Utf8               InnerClasses
  #19 = Utf8               java/lang/Object
  #20 = Utf8               ()V
  #21 = Utf8               A
{
  final A this$0;
    descriptor: LA;
    flags: ACC_FINAL, ACC_SYNTHETIC


  A$B(A);
    descriptor: (LA;)V
    flags:
    Code:
      stack=2, locals=2, args_size=2
         0: aload_0
         1: aload_1
         2: putfield      #1                  // Field this$0:LA;
         5: aload_0
         6: invokespecial #2                  // Method java/lang/Object."<init>":()V
         9: return
      LineNumberTable:
        line 3: 0
}
SourceFile: "Try.java"
InnerClasses:
     #17= #3 of #15; //B=class A$B of class A

在构造函数处（即A$B(A))，我们看到有个参数A，即为A的this指针。看下面的代码：

 

 final A this$0;
    descriptor: LA;
    flags: ACC_FINAL, ACC_SYNTHETIC

说明非静态实名内部类含有一个指向外部类的final指针。在编译时，会自动加上一句：

 

 

final A this$0=this//this为外部类的指针

 

关于内部类与外部类加载顺序问题，可以看看我的另一篇博客：点击打开链接，另外，当我们第一次且只创建外部类的对象时，只会加载外部类的class文件，不会加载内部类的class文件。

 

 

 

静态实名内部类：

静态实名内部类编译后也会生成两个.class文件，与非静态实名内部类不同的是，当我们想要new一个静态实名内部类时，并不需要外部类的实例对象，当我们将静态内部类的.class文件反编译后，我们看到，静态实名内部类不含有外部类的this指针，代码如下：

 

class A
{
   static class B
   {
   
   }
}
public class Try {
    public static void main(String[] args) {
    } 
}

反编译内部类的class文件后：

 

 

  Last modified 2018-2-3; size 222 bytes
  MD5 checksum 87c132b08b7190c022efda55b7f554bf
  Compiled from "Try.java"
class A$B
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Methodref          #3.#10         // java/lang/Object."<init>":()V
   #2 = Class              #12            // A$B
   #3 = Class              #15            // java/lang/Object
   #4 = Utf8               <init>
   #5 = Utf8               ()V
   #6 = Utf8               Code
   #7 = Utf8               LineNumberTable
   #8 = Utf8               SourceFile
   #9 = Utf8               Try.java
  #10 = NameAndType        #4:#5          // "<init>":()V
  #11 = Class              #16            // A
  #12 = Utf8               A$B
  #13 = Utf8               B
  #14 = Utf8               InnerClasses
  #15 = Utf8               java/lang/Object
  #16 = Utf8               A
{
  A$B();
    descriptor: ()V
    flags:
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
}
SourceFile: "Try.java"
InnerClasses:
     static #13= #2 of #11; //B=class A$B of class A

看构造函数，并没有A类型的参数传入，同时也没有A类型的指针，原因很简单，因为this指针是对象相关的，而static是对象无关的。第一次创建静态实名内部类不一定会加载外部类的class文件。

 

 

 

为什么非静态实名内部类不能具有静态成员域？

以下是我自己的理解：

静态变量本质是实例不相关的，因为可以通过类名直接访问，从JVM的角度来说，在加载类时，静态变量会在类加载的准备阶段赋予数据类型零值，在初始化阶段（此时不会有实例对象的产生）赋予java代码的值，所以可以直接使用类名访问（静态变量在方法区中，具有唯一性）。假设非静态实名内部类具有static变量，由于非静态实名内部类具有外部类的指针，想要访问就必须实例化一个外部类，然后通过该外部类进行访问，而静态变量的设计初衷之一就是可以不必通过实例对象进行访问，静态变量是不需要实例化任何一个对象就可以访问的，然而想要访问内部类必须实例化外部类，这就与设计初衷相违背了。

 

 

为什么非静态实名内部类可以具有static  final修饰常量池中具有字面量的成员域？

 

以下常量均指在常量池中具有字面量的成员域。

 

为了提高效率。不用static修饰，则每个类对象在堆中的内存都会有该常量，占用堆内存，且每个类对象调用<init>时都会初始化该常量，降低效率。关于static final修饰类型的理解可以查看我的另一篇博客：点击打开链接

 

 

为什么非静态实名内部类不可以具有静态成员函数？
 

原因和不能有静态成员类似，设计静态成员函数是希望可以不实例化一个对象就直接执行，由于内部类必须通过外部类的实例对象访问，与使用目的矛盾。

 

为什么非静态实名内部类不可以具有静态代码块？

 

静态代码块在类加载的初始化阶段会被<clinit>方法执行，静态代码块也具有实例无关性，与不能定义static成员域原因相同。

 

在非静态实名内部类中下列代码在编译时也会出错：

 

static final int n=new Integer(1);

原因是在编译时，这一句代码会被当成静态代码块执行。