前言

简单介绍 Java 内部类的分类，以及常见的使用案例。

正文

内部类的分类

内部类可以分为：静态内部类（嵌套类）和非静态内部类。非静态内部类又可以分为：成员内部类、方法内部类、匿名内部类。

静态内部类和非静态内部类的区别

  1. 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。
  2. 静态内部类可以访问外部类的静态变量，而不可访问外部类的非静态变量。
  3. 非静态内部类的非静态成员可以访问外部类的非静态变量。
  4. 静态内部类的创建不依赖于外部类，而非静态内部类必须依赖于外部类的创建而创建。

我们通过一个例子就可以很好的理解这几点区别：

  1. public class ClassOuter {
  3.     private int noStaticInt = 1;
  4.     private static int STATIC_INT = 2;
  6.     public void fun() {
  7.         System.out.println("外部类方法");
  8.     }
  10.     public class InnerClass {
  11.         //static int num = 1; 此时编辑器会报错，非静态内部类则不能有静态成员
  12.         public void fun() {
  13.             // 非静态内部类的非静态成员可以访问外部类的非静态变量。
  14.             System.out.println(STATIC_INT);
  15.             System.out.println(noStaticInt);
  16.         }
  17.     }
  19.     public static class StaticInnerClass {
  20.         static int NUM = 1;//静态内部类可以有静态成员
  22.         public void fun() {
  23.             System.out.println(STATIC_INT);
  24.             //System.out.println(noStaticInt); 此时编辑器会报错，不可访问外部类的非静态变量
  25.         }
  26.     }
  27. }
  29. public class TestInnerClass {
  30.     public static void main(String[] args) {
  31.         // 非静态内部类 创建方式1
  32.         ClassOuter.InnerClass innerClass = new ClassOuter().new InnerClass();
  33.         // 非静态内部类 创建方式2
  34.         ClassOuter outer = new ClassOuter();
  35.         ClassOuter.InnerClass inner = outer.new InnerClass();
  36.         // 静态内部类的创建方式
  37.         ClassOuter.StaticInnerClass staticInnerClass = new ClassOuter.StaticInnerClass();
  38.     }
  39. }

局部内部类

如果一个内部类只在一个方法中使用到了，那么我们可以将这个类定义在方法内部，这种内部类被称为局部内部类，其作用域仅限于该方法。

局部内部类有几点值得我们注意的地方：

  1. 局部内类不能用 public，protected，private 访问修饰符进行声明。
  2. 局部内部类对外完全隐藏，除了创建这个类的方法可以访问它，其他的地方是不允许访问的。

  3. 对比成员内部类，局部内部类还可以访问局部变量，但该变量必须声明为 final，且在内部类中不允许对该变量重新赋值。

    1. public class ClassOuter {
    3.  private int noStaticInt = 1;
    4.  private static int STATIC_INT = 2;
    6.  public void fun() {
    7.      System.out.println("外部类方法");
    8.  }
    10.  public void testFunctionClass(String params) {
    11.      class FunctionClass {
    12.          private void fun() {
    13.              System.out.println("局部内部类的输出");
    14.              System.out.println(STATIC_INT);
    15.              System.out.println(noStaticInt);
    16.              System.out.println(params);
    17.              //params ++ ; // params 不可变所以这句话编译错误
    18.          }
    19.      }
    20.      FunctionClass functionClass = new FunctionClass();
    21.      functionClass.fun();
    22.  }
    23. }

    匿名内部类

  4. 匿名内部类没有访问修饰符。

  5. 匿名内部类必须继承一个抽象类或者实现一个接口。
  6. 匿名内部类中不能存在任何静态成员或静态方法。
  7. 匿名内部类是没有构造方法的，因为它没有类名。

  8. 与局部内部类一样，匿名内部类也可以引用局部变量，该变量也必须声明为 final。

    1. public class Button {
    3.  public void click(final int params) {
    4.      // 匿名内部类，实现的是ActionListener接口
    5.      new ActionListener() {
    6.          public void onAction() {
    7.              System.out.println("click action..." + params);
    8.          }
    9.      }.onAction();
    10.  }
    12.  // 匿名内部类必须继承或实现一个已有的接口
    13.  public interface ActionListener {
    14.      public void onAction();
    15.  }
    17.  public static void main(String[] args) {
    18.      Button button = new Button();
    19.      button.click(1);
    20.  }
    21. }

    使用案例

    使用内部类实现多继承

在 Java 中，一个类只能继承一个父类，不支持多继承。所以，一般多继承是通过接口来实现的。但是使用接口也有不方便的地方。比如实现一个接口就必须实现它里面的所有方法（Java 8 之前）。而有了内部类就不一样了，我们可以通过内部类来实现多继承。比如下面的例子：

  1. public abstract class ClassA {
  3.     public abstract void funA();
  5.     public void funC() {
  6.         System.out.println("ClassA - funC");
  7.     }
  8. }
  10. public abstract class ClassB {
  12.     public abstract void funB();
  13. }
  15. public class MultiInheritanceDemo {
  17.     private class SubClassA extends ClassA {
  18.         @Override
  19.         public void funA() {
  20.             System.out.println("ClassA - funA");
  21.         }
  22.     }
  24.     private class SubClassB extends ClassB {
  25.         @Override
  26.         public void funB() {
  27.             System.out.println("ClassB - funB");
  28.         }
  29.     }
  31.     public void funA() {
  32.         new SubClassA().funA();
  33.     }
  35.     public void funB() {
  36.         new SubClassB().funB();
  37.     }
  39.     public static void main(String[] args) {
  40.         MultiInheritanceDemo multiInheritanceDemo = new MultiInheritanceDemo();
  41.         multiInheritanceDemo.funA();
  42.         multiInheritanceDemo.funB();
  43.     }
  44. }

运行程序，输出：

  1. ClassA - funA
  2. ClassB - funB

通过上面的例子可以看出，虽然 MultiInheritanceDemo 类不能同时继承 ClassA 和 ClassB，但是它可以通过内部类拥有 ClassA 和 ClassB 两个类的继承关系，且无需关注 ClassA 中 funC 方法的实现。

转载

更多内容参考如下两篇文章，在 Java 核心技术 卷1 中描述了内部类编译之后的表现形式，更好的解释了内部类是如何实现访问外部类的。

另外，在搞懂 JAVA 内部类的文章中，提到了内部类会造成程序内存泄漏的问题，可以看看。

作者：殷建卫 链接：https://www.yuque.com/yinjianwei/vyrvkf/pvyq0q 来源：殷建卫 - 架构笔记 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。