Java知识体系之内部类

Java知识体系

内部类

定义在一个类中或者方法中的类称作为内部类。
内部类又可以具体细分为成员内部类、局部内部类、匿名内部类、静态内部类。

成员内部类

public class OutClass2 {
    private int i = 1;
    public static String str = "outclass";
    class InnerClass { // 成员内部类
        private int i = 2;
        public void innerMethod() {
            int i = 3;
            System.out.println("i=" + i);
            System.out.println("i=" + this.i);
            System.out.println("i=" + OutClass2.this.i);
            System.out.println("str=" + str);
        }
    }
}
public class TestClass {
    public static void main(String[] args) {
        //创建内部类对象
        OutClass2.InnerClass in = new OutClass2().new InnerClass();
        //内部类对象调用自己的方法
        in.innerMethod();
    }
}

因为内部类依附于外部类存在，所以需要外部类的实例来创建内部类：

new OutClass2().new InnerClass()

注意：不是new OutClass2.InnerClass()

在内部类中，隐式地持有了外部类的引用，所以成员内部类可以无条件的访问外部类的成员属性和成员方法（包括 private 和 static 类型的成员)。

我们编译上述代码，生成两个 class 文件

OutClass2.class
OutClass2$InnerClass.class

我们来看一下OutClass2$InnerClass.class

package com.example.simon.androidlife.innerclass;
import com.example.simon.androidlife.innerclass.OutClass2;
class OutClass2$InnerClass {
    private int i;
    OutClass2$InnerClass(OutClass2 var1) {
        this.this$0 = var1;
        this.i = 2;
    }
    public void innerMethod() {
        byte var1 = 3;
        System.out.println("i=" + var1);
        System.out.println("i=" + this.i);
        System.out.println("i=" + OutClass2.access$000(this.this$0));
        System.out.println("str=" + OutClass2.str);
    }
}

在这个不完整的反编译字节码中，我们看第8行构造函数，

内部类为什么可以直接访问外部类的内容，因为持有外部类的引用，外部类对象会以参数的形式传进来。

再看第17行，OutClass2.access$000(this.this$0)) 是什么意思呢？

为了帮助内部类访问外部类的数据，编译器会生成这个 access方法，参数是外部类的引用，如果外部类有N个成员，编译器会生成多个access方法，参数是外部类的引用，如果外部类有 N 个成员，编译器会生成多个 access 方法， 符号后面的数字会会随着不同的声明顺序而改变，可以理解为一种桥接方法。

有一个限制是：成员内部类不能创建静态变量/方法。

静态内部类

使用 static 关键字修饰的内部类就是静态内部类，静态内部类和外部类没有任何关系，可以看作是和外部类平级的类。

public class Outclass3 {
    private String name;
    private int age;
    public static class InnerStaticClass {
        private String name;
        public String getName() {
            return name;
        }
        public int getAge() {
            return new Outclass3().age;
        }
    }
}

编译后的静态内部类:

package com.example.simon.androidlife.innerclass;
import com.example.simon.androidlife.innerclass.Outclass3;
public class Outclass3$InnerStaticClass {
    private String name;
    public Outclass3$InnerStaticClass() {
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return Outclass3.access$000(new Outclass3());
    }
}

局部内部类

局部内部类是指在代码块或者方法中创建的类。
它和成员内部类的区别就是：局部内部类的作用域只能在其所在的代码块或者方法内，在其它地方是无法创建该类的对象。

public class OutClass4 {
    private String className = "OutClass";
    {
        class PartClassOne { // 局部内部类
            private void method() {
                System.out.println("PartClassOne " + className);
            }
        }
        new PartClassOne().method();
    }
    public void testMethod() {
        class PartClassTwo { // 局部类内部类
            private void method() {
                System.out.println("PartClassTwo " + className);
            }
        }
        new PartClassTwo().method();
    }
}

package com.example.simon.androidlife.innerclass;
import com.example.simon.androidlife.innerclass.OutClass4;
class OutClass4$1PartClassOne {
    OutClass4$1PartClassOne(OutClass4 var1) {
        this.this$0 = var1;
    }
    private void method() {
        System.out.println("PartClassOne " + OutClass4.access$000(this.this$0));
    }
}
----------------------------------------------------------
package com.example.simon.androidlife.innerclass;
import com.example.simon.androidlife.innerclass.OutClass4;
class OutClass4$1PartClassTwo {
    OutClass4$1PartClassTwo(OutClass4 var1) {
        this.this$0 = var1;
    }
    private void method() {
        System.out.println("PartClassTwo " + OutClass4.access$000(this.this$0));
    }
}

• 可以看到生成的这两个字节码和成员内部类生成的很相似，都持有了外部类的引用。
• 可以把局部内部类理解为作用域很小的成员内部类。

匿名内部类

不创建类对象的引用，而是直接创建的类对象。
一般来说，主要用于方法的参数或者回调。

public class OutClass5 {
    private OnClickListener mClickListener;
    interface OnClickListener {
        void onClick();
    }
    public OutClass5 setClickListener(final OnClickListener clickListener) {
        mClickListener = clickListener;
        return this;
    }
    public void setClickInfo(final String info, int type) {
        // 这里！！！！
        setClickListener(new OnClickListener() {
            @Override
            public void onClick() {
                System.out.println("click " + info);
            }
        });
    }
}

编译后的匿名内部类

class OutClass5$1 implements OnClickListener {
    OutClass5$1(OutClass5 var1, String var2) {
        this.this$0 = var1;
        this.val$info = var2;
    }
    public void onClick() {
        System.out.println("click " + this.val$info);
    }
}

从反编译的代码可以看出：

创建的每个匿名内部类编译器都对应生成一个实现接口的子类，同时创建一个构造函数，构造函数的参数是外部类的引用以及匿名函数中访问的外部类的变量，这个变量还必须final修饰。

小结

外部类会生成一堆access$变量(外部类)的static方法，方便内部类调用。
除了静态内部类，其他三种都持有外部类引用。

• 成员内部类
  
  • new 外部类().new 内部类()
  • 外部类对象会以参数的形式传递给内部类的构造函数。编译器会给我们生成这种构造函数，所以内部类持有外部类的引用。
  • 内部类的地位等同于成员变量
  • 成员内部类不能创建静态变量/方法
• 静态内部类
  
  • 不持有外部类引用
  • 可以理解为一个正常的类
• 局部内部类
  
  • 局部内部类是指在代码块或者方法中创建的类。
  • 可以理解为：作用域缩小的成员内部类
• 匿名内部类
  
  • 没有类名，所以不能有构造函数
  • 不能定义任何静态成员、方法
    匿名内部类是晚于外部类加载的，但是匿名内部类和其对象几乎是同时加载的，但是还是早于对象加载，而静态内容是属于类的，当类加载的时候就开始加载，所以当匿名内部类中有静态内容，就会随着类加载，而这时和对象创建冲突。
  • 外部类的局部变量，必须是final类型
  • 外部类和final修饰的变量，会以参数的形式传递给内部类的构造函数。
  • 编译器会给我们生成这种构造函数，所以内部类持有外部类的引用。

应用场景

成员内部类

在 Java 中普通类（非内部类)是不可以设为 private 或者 protected，只能设置成 public、default。
而内部类则可以，因此我们可以利用 private 内部类禁止其他类访问该内部类，从而做到将具体的实现细节完全隐藏。

例如：

public class MyActivity extends AppCompatActivity {
    public static final String DATA_VIEW_TYPE = "view_type";
    public static final int TYPE_LOGIN = 1;
    public static final int TYPE_REGISTER = 2;
    private TextView mTitleTv;
    private ViewController mViewController;
    @Override
    protected void onCreate(@Nullable final Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);
    }
    private class MyAsyncTask extends AsyncTask {
        .....
        .....
    }
}

单例

public class LocationManager{
    private static class ClassHolder {
        private static final LocationManager instance = new LocationManager();
    }
    public static LocationManager getInstance() {
        return ClassHolder.instance;
    }
}

总的来说，内部类一般用于两个场景：

• 需要用一个类来解决一个复杂的问题，但是又不希望这个类是公共的
• 需要实现一个接口，但不需要持有它的引用

几个问题

为什么非静态内部类不能创建静态变量/方法

内部类其实也可以认为是外部类的一个成员变量，想要访问内部类，必须先实例化外部类，然后通过外部类才能访问内部类。

1、static类型的属性和方法，在类加载的时候就会存在于内存中。
2、要想使用某个类的static属性和方法，那么这个类必须要加载到虚拟机- 中。
3、非静态内部类并不随外部类一起加载，只有在实例化外部类之后才会加载。

现在考虑这个情况：在外部类并没有实例化，内部类还没有加载，这时候如果调用内部类的静态成员或方法，内部类还没有加载，却试图在内存中创建该内部类的静态成员，这明显是矛盾的。所以非静态内部类不能有静态成员变量或静态方法。

为什么匿名内部类中使用到的外部局部变量必须为final？

一个对象引用被传递给方法时，方法中会创建一份本地临时引用，它和参数指向同一个对象，但却是不同的，所以你在方法内部修改参数的内容，在方法外部是不会感知到的。

而匿名内部类是创建一个对象并返回，这个对象的方法被调用的时机不确定，方法中有修改参数的可能，如果在匿名内部类中修改了参数，外部类中的参数是否需要同步修改呢？

因此，Java 为了避免这种问题，限制匿名内部类访问的变量需要使用 final 修饰，这样可以保证访问的变量不可变。

参考

Java 基础巩固：内部类的字节码学习和实战使用场景
https://www.jianshu.com/p/b6ddf26ac211