本节我们将介绍 Java 中的内部类。通过本节的学习，我们将了解到什么是内部类，内部类的分类和作用。在内部类的分类部分，我们将逐一学习各个类型的内部类如何定义，如何实例化以及各自的特点，要注意区分不同类型内部类的异同。有了这些基础知识之后，我们也会结合示例介绍为什么需要内部类。

1. 概念

在 Java 语言中，可以将一个类定义在另一个类里面或者一个方法里面，我们把这样的类称为内部类。
与之对应的，包含内部类的类被称为外部类。请阅读下面的代码：

  1. // 外部类 Car
  2. public class Car {
  3.     // 内部类 Engine
  4.     class Engine {
  5.         private String innerName = "发动机内部类";
  6.     }
  7. }

代码中，Engine 就是内部类，而 Car 就是外部类。

2. 分类

Java 中的内部类可以分为 4 种：成员内部类、静态内部类、方法内部类和匿名内部类。接下来我们按照分类一一介绍。

2.1 成员内部类

2.1.1 定义

成员内部类也称为普通内部类，它是最常见的内部类。可以将其看作外部类的一个成员。在成员内部类中无法声明静态成员。
如下代码中声明了一个成员内部类：

  1. // 外部类 Car
  2. public class Car {
  3.     // 内部类 Engine
  4.     private class Engine {
  5.         private void run() {
  6.             System.out.println("发动机启动了！");
  7.         }
  8.     }
  9. }

我们在外部类 Car 的内部定义了一个成员内部类 Engine，在 Engine 下面有一个 run() 方法，其功能是打印输出一行字符串：“发动机启动了！”。
另外，需要注意的是，与普通的 Java 类不同，含有内部类的类被编译器编译后，会生成两个独立的字节码文件：

  1. Car$Engine.class
  2. Car.class

内部类 Engine 会另外生成一个字节码文件，其文件名为：外部类类名 $ 内部类类名.class。

2.1.2 实例化

内部类在外部使用时，无法直接实例化，需要借助外部类才能完成实例化操作。关于成员内部类的实例化，有 3 种方法：

  1. 我们可以通过 new 外部类().new 内部类() 的方式获取内部类的实例对象：

    1. // 外部类 Car
    2. public class Car {
    4.  // 内部类 Engine
    5.  private class Engine {
    6.      private void run() {
    7.          System.out.println("发动机启动了！");
    8.      }
    9.  }
    11.  public static void main(String[] args) {
    12.      // 1.实例化外部类后紧接着实例化内部类
    13.      Engine engine = new Car().new Engine();
    14.      // 2.调用内部类的方法
    15.      engine.run();
    16.  }
    17. }

    运行结果： ```java 发动机启动了！

  2. 2. 我们可通过先实例化外部类、再实例化内部类的方法获取内部类的对象实例：
  3. ```java
  4. public static void main(String[] args) {
  5.     // 1.实例化外部类
  6.     Car car = new Car();
  7.     // 2.通过外部类实例对象再实例化内部类
  8.     Engine engine = car.new Engine();
  9.     // 3.调用内部类的方法
  10.     engine.run();
  11. }

编译执行，成功调用了内部类的 run () 方法：

  1. $javac Car.java
  2. java Car
  3. 发动机启动了！

  1. 我们也可以在外部类中定义一个获取内部类的方法 getEngine()，然后通过外部类的实例对象调用这个方法来获取内部类的实例：

    1. // 外部类 Car
    2. public class Car {
    4.  // 获取内部类实例的方法
    5.  public Engine getEngine() {
    6.      return new Engine();
    7.  }
    9.  // 内部类 Engine
    10.  private class Engine {
    11.      private void run() {
    12.          System.out.println("发动机启动了！");
    13.      }
    14.  }
    16.  public static void main(String[] args) {
    17.      // 1.实例化外部类
    18.      Car car = new Car();
    19.      // 2.调用实例方法getEngine(),获取内部类实例
    20.      Engine engine = car.getEngine();
    21.      // 3.调用内部类的方法
    22.      engine.run();
    23.  }
    24. }

    运行结果： ```java 发动机启动了！

  1. 这种设计在是非常常见的，同样可以成功调用执行 run() 方法。
  2. <a name="kTwjm"></a>
  3. #### 2.1.2 成员的访问
  4. 成员内部类可以直接访问外部类的成员，例如，可以在内部类的中访问外部类的成员属性：
  5. ```java
  6. // 外部类 Car
  7. public class Car {
  9.     String name;
  11.     public Engine getEngine() {
  12.         return new Engine();
  13.     }
  15.     // 内部类 Engine
  16.     private class Engine {
  17.         // 发动机的起动方法
  18.         private void run() {
  19.             System.out.println(name + "的发动机启动了！");
  20.         }
  21.     }
  23.     public static void main(String[] args) {
  24.         // 实例化外部类
  25.         Car car = new Car();
  26.         // 为实例属性赋值
  27.         car.name = "大奔奔";
  28.         // 获取内部类实例
  29.         Engine engine = car.getEngine();
  30.         // 调用内部类的方法
  31.         engine.run();
  32.     }
  33. }

观察 Engine 的 run() 方法，调用了外部类的成员属性 name，我们在主方法实例化 Car 后，已经为属性 name 赋值。
运行结果：

  1. 大奔奔的发动机启动了！

相同的，除了成员属性，成员方法也可以自由访问。这里不再赘述。
还存在一个同名成员的问题：如果内部类中也存在一个同名成员，那么优先访问内部类的成员。可理解为就近原则。
这种情况下如果依然希望访问外部类的属性，可以使用外部类名.this.成员的方式，例如：

  1. // 外部类 Car
  2. public class Car {
  4.     String name;
  6.     public Engine getEngine() {
  7.         return new Engine();
  8.     }
  9.     // 汽车的跑动方法
  10.     public void run(String name) {
  11.         System.out.println(name + "跑起来了！");
  12.     }
  14.     // 内部类 Engine
  15.     private class Engine {
  16.         private String name = "引擎";
  17.         // 发动机的起动方法
  18.         private void run() {
  19.             System.out.println("Engine中的成员属性name=" + name);
  20.             System.out.println(Car.this.name + "的发动机启动了！");
  21.             Car.this.run(Car.this.name);
  22.         }
  23.     }
  25.     public static void main(String[] args) {
  26.         // 实例化外部类
  27.         Car car = new Car();
  28.         // 为实例属性赋值
  29.         car.name = "大奔奔";
  30.         // 获取内部类实例
  31.         Engine engine = car.getEngine();
  32.         // 调用内部类的方法
  33.         engine.run();
  34.     }
  35. }

运行结果：

  1. Engine中的成员属性name=引擎
  2. 大奔奔的发动机启动了！
  3. 大奔奔跑起来了！

请观察内部类 run() 方法中的语句：第一行语句调用了内部类自己的属性 name，而第二行调用了外部类 Car 的属性 name，第三行调用了外部类的方法 run()，并将外部类的属性 name 作为方法的参数。

2.2 静态内部类

2.2.1 定义

静态内部类也称为嵌套类，是使用 static 关键字修饰的内部类。如下代码中定义了一个静态内部类：

  1. public class Car1 {
  2.     // 静态内部类
  3.     static class Engine {
  4.         public void run() {
  5.             System.out.println("我是静态内部类的run()方法");
  6.             System.out.println("发动机启动了");
  7.         }
  8.     }
  9. }

2.2.2 实例化

静态内部类的实例化，可以不依赖外部类的对象直接创建。我们在主方法中可以这样写：

  1. // 直接创建静态内部类对象
  2. Engine engine = new Engine();
  3. // 调用对象下run()方法
  4. engine.run();

运行结果：

  1. 我是静态内部类的run()方法
  2. 发动机启动

2.2.3 成员的访问

在静态内部类中，只能直接访问外部类的静态成员。例如：

  1. public class Car1 {
  3.     String brand = "宝马";
  5.     static String name = "外部类的静态属性name";
  7.     // 静态内部类
  8.     static class Engine {
  9.         public void run() {
  10.             System.out.println(name);
  11.         }
  12.     }
  14.     public static void main(String[] args) {
  15.         Engine engine = new Engine();
  16.         engine.run();
  17.     }
  18. }

在 run() 方法中，打印的 name 属性就是外部类中所定义的静态属性 name。编译执行，将会输出：

  1. 外部类的静态属性name

对于内外部类存在同名属性的问题，同样遵循就近原则。这种情况下依然希望调用外部类的静态成员，可以使用外部类名.静态成员的方式来进行调用。这里不再一一举例。
如果想要访问外部类的非静态属性，可以通过对象的方式调用，例如在 run() 方法中调用 Car1 的实例属性 brand：

  1. public void run() {
  2.     // 实例化对象
  3.     Car1 car1 = new Car1();
  4.     System.out.println(car1.brand);
  5. }

2.3 方法内部类

2.3.1 定义

方法内部类，是定义在方法中的内部类，也称局部内部类。
如下是方法内部类的代码：

  1. public class Car2 {
  3.     // 外部类的run()方法
  4.     public void run() {
  5.         class Engine {
  6.             public void run() {
  7.                 System.out.println("方法内部类的run()方法");
  8.                 System.out.println("发动机启动了");
  9.             }
  10.         }
  11.         // 在Car2.run()方法的内部实例化其方法内部类Engine
  12.         Engine engine = new Engine();
  13.         // 调用Engine的run()方法
  14.         engine.run();
  15.     }
  17.     public static void main(String[] args) {
  18.         Car2 car2 = new Car2();
  19.         car2.run();
  20.     }
  21. }

运行结果：

  1. 方法内部类的run()方法
  2. 发动机启动了

如果我们想调用方法内部类的 run() 方法，必须在方法内对 Engine 类进行实例化，再去调用其 run() 方法，然后通过外部类调用自身方法的方式让内部类方法执行。

2.3.2 特点

与局部变量相同，局部内部类也有以下特点：

  • 方法内定义的局部内部类只能在方法内部使用；
  • 方法内不能定义静态成员；
  • 不能使用访问修饰符。

也就是说，Car2.getEngine() 方法中的 Engine 内部类只能在其方法内部使用；并且不能出现 static 关键字；也不能出现任何的访问修饰符，例如把方法内部类 Engine 声明为 public 是不合法的。

2.4 匿名内部类

2.4.1 定义

匿名内部类就是没有名字的内部类。使用匿名内部类，通常令其实现一个抽象类或接口。请阅读如下代码：

  1. // 定义一个交通工具抽象父类，里面只有一个run()方法
  2. public abstract class Transport {
  3.     public void run() {
  4.         System.out.println("交通工具run()方法");
  5.     }
  7.     public static void main(String[] args) {
  8.         // 此处为匿名内部类，将对象的定义和实例化放到了一起
  9.         Transport car = new Transport() {
  10.             // 实现抽象父类的run()方法
  11.             @Override
  12.             public void run() {
  13.                 System.out.println("汽车跑");
  14.             }
  15.         };
  16.         // 调用其方法
  17.         car.run();
  19.         Transport airPlain = new Transport() {
  20.             // 实现抽象父类的run()方法
  21.             @Override
  22.             public void run() {
  23.                 System.out.println("飞机飞");
  24.             }
  25.         };
  26.         airPlain.run();
  28.     }
  29. }

运行结果：

  1. 汽车跑
  2. 飞机飞

上述代码中的抽象父类中有一个方法 run()，其子类必须实现，我们使用匿名内部类的方式将子类的定义和对象的实例化放到了一起，通过观察我们可以看出，代码中定义了两个匿名内部类，并且分别进行了对象的实例化，分别为 car 和 airPlain，然后成功调用了其实现的成员方法 run()。

2.4.2 特点

  • 含有匿名内部类的类被编译之后，匿名内部类会单独生成一个字节码文件，文件名的命名方式为：外部类名称$数字.class。例如，我们将上面含有两个匿名内部类的 Transport.java 编译，目录下将会生成三个字节码文件： ```java Transport$1.class Transport$2.class Transport.class
  2. - 匿名内部类没有类型名称和实例对象名称；
  3. - 匿名内部类可以继承父类也可以实现接口，但二者不可兼得；
  4. - 匿名内部类无法使用访问修饰符、static、abstract 关键字修饰；
  5. - 匿名内部类无法编写构造方法，因为它没有类名；
  6. - 匿名内部类中不能出现静态成员。
  7. <a name="CJNay"></a>
  8. #### 2.4.2 使用场景
  9. 由于匿名内部类没有名称，类的定义可实例化都放到了一起，这样可以简化代码的编写，但同时也让代码变得不易阅读。当我们在代码中只用到类的一个实例、方法只调用一次，可以使用匿名内部类。
  10. <a name="PZMY4"></a>
  11. ## 3. 作用
  12. <a name="aw9V6"></a>
  13. ### 3.1 封装性
  14. 内部类的成员通过外部类才能访问，对成员信息有更好的隐藏，因此内部类实现了更好的封装。
  15. <a name="PObzo"></a>
  16. ### 3.2 实现多继承
  17. 我们知道 Java 不支持多继承，而接口可以实现多继承的效果，但实现接口就必须实现里面所有的方法，有时候我们的需求只是实现其中某个方法，内部类就可以解决这些问题。<br />下面示例中的 SubClass，通过两个成员内部类分别继承 SuperClass1 和 SuperClass2，并重写了方法，实现了多继承：
  18. ```java
  19. // SuperClass1.java
  20. public class SuperClass1 {
  21.     public void method1() {
  22.         System.out.println("The SuperClass1.method1");
  23.     }
  24. }
  26. // SuperClass2.java
  27. public class SuperClass2 {
  28.     public void method2() {
  29.         System.out.println("The SuperClass2.method2");
  30.     }
  31. }
  33. // SubClass.java
  34. public class SubClass {
  35.     // 定义内部类1
  36.     class InnerClass1 extends SuperClass1 {
  37.         // 重写父类1方法
  38.         @Override
  39.         public void method1() {
  40.             super.method1();
  41.         }
  42.     }
  44.     // 定义内部类2
  45.     class InnerClass2 extends SuperClass2 {
  46.         // 重写父类2方法
  47.         @Override
  48.         public void method2() {
  49.             super.method2();
  50.         }
  51.     }
  53.     public static void main(String[] args) {
  54.         // 实例化内部类1
  55.         InnerClass1 innerClass1 = new SubClass().new InnerClass1();
  56.         // 实例化内部类2
  57.         InnerClass2 innerClass2 = new SubClass().new InnerClass2();
  58.         // 分别调用内部类1、内部类2的方法
  59.         innerClass1.method1();
  60.         innerClass2.method2();
  61.     }
  62. }

编译执行 SubClass.java，屏幕将会打印：

  1. $ javac SubClass.java
  2. $ java SubClass
  3. The SuperClass1.method1
  4. The SuperClass1.method2

3.3 解决继承或实现接口时的方法同名问题

请阅读如下代码：

  1. // One.java
  2. public class One {
  3.     public void test() {
  4.     }
  5. }
  6. // Two.java
  7. public interface Two {
  8.     void test();
  9. }
  10. // Demo.java
  11. public class Demo1 extends One implements Two {
  12.     public void test() {
  14.     }
  15. }

此时，我们无法确定 Demo1 类中的 test() 方法是父类 One 中的 test 还是接口 Two 中的 test。这时我们可以使用内部类解决这个问题：

  1. public class Demo2 extends One {
  3.     // 重写父类方法
  4.     @Override
  5.     public void test() {
  6.         System.out.println("在外部类实现了父类的test()方法");
  7.     }
  9.     // 定义内部类
  10.     class InnerClass implements Two {
  11.         // 重写接口方法
  12.         @Override
  13.         public void test() {
  14.             System.out.println("在内部类实现了接口的test()方法");
  15.         }
  16.     }
  18.     public static void main(String[] args) {
  19.         // 实例化子类Demo2
  20.         Demo2 demo2 = new Demo2();
  21.         // 调用子类方法
  22.         demo2.test();
  23.         // 实例化子类Demo2的内部类
  24.         InnerClass innerClass = demo2.new InnerClass();
  25.         // 调用内部类方法
  26.         innerClass.test();
  27.     }
  28. }

运行结果：

  1. 在外部类实现了父类的test()方法
  2. 在内部类实现了接口的test()方法

4. 小结

本小节，我们知道了什么是内部类，也知道了在 Java 中有四种内部类：成员内部类、静态内部类、方法内部类和匿名内部类。对于它们的定义和调用也做了详细讲解，理解内部类的作用是使用好内部类的关键。