内部类

1. 概念和使用场景

如果一个事物内部包含另一个事物，那么这就是一个类内部包含另一个类。因此，内部类就是定义在一个类或方法内部的类。促使我们使用内部类的原因有两个：

  • 内部类可以对同一个包中的其他类隐藏，即如果我们希望一个类只能被某一个具体的类使用，那么就可以将其定义在哪个类内部作为内部类使用。
  • 内部类方法可以访问定义这个类的作用域中的数据，包括原本私有的数据。如果一个普通类想访问某个类的私有成员属性，那么只能通过类的getter()和setter()访问，而内部类可以直接访问它外围类的私有成员属性

2. 分类

2.1 成员内部类

2.1.1 定义格式
  1. // 外部类
  2. 修饰符 class 类名称{
  3.     // 内部类
  4.     修饰符 class 类名称{
  5.         ...
  6.     }
  7.    ...
  8. }

只有类为内部类，它的修饰符才有可能是private

2.1.2 数据字段访问

内部类可以访问自身的数据字段，也可以访问创建它的外部类对象的数据字段，即内部类可以直接通过属性名方法访问外部类的数据字段（这种情况建立在内部类中没有和其重名的变量存在），如

  1. public class Body {
  2.     private String name = "body";
  3.     private String state = "healthy";
  5.     public String getName() {
  6.         return name;
  7.     }
  9.     public void setName(String name) {
  10.         this.name = name;
  11.     }
  13.     public String getState() {
  14.         return state;
  15.     }
  17.     public void setState(String state) {
  18.         this.state = state;
  19.     }
  21.     public void methodBody(){
  22.         System.out.println("outer class...");
  23.         new Heart().beat();
  24.     }
  26.     public class Heart{
  27.         public void beat(){
  28.             System.out.println(state);
  29.             System.out.println("beat...");
  30.         }
  31.     }
  32. }
  34. public class InterClassTest {
  35.     public static void main(String[] args) {
  36.         Body body = new Body();
  37.         body.methodBody(); // outer class...  healthy  beat...
  38.     }
  39. }

在内部类Heart的beat()可直接使用，而不必通过getState()使用.
内部类对外部类数据字段的访问.png

外部用内部，需要内部类对象。外部类使用内部类对象有两种方式：

  • 间接方式：在外部类的方法中使用内部类，然后main()中只调用外部类方法，如上所示
  • 直接方式：使用代码格式为：
    1. 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();


例如直接在main()直接创建内部类对象，通过内部类对象的方法直接方法外部类数据字段

  1. class Body {
  2.     private String name = "body";
  3.     public String getName() {
  4.         return name;
  5.     }
  7.     public void setName(String name) {
  8.         this.name = name;
  9.     }
  11.     public void methodBody(){
  12.         System.out.println("outer class...");
  13.         // 间接调用内部类
  14.         new Heart().beat();
  15.     }
  17.     //成员内部类
  18.     public class Heart{
  19.         public void beat(){
  20.             System.out.println("beat...");
  21.         }
  22.     }
  23. }
  25. public class InterClassTest {
  26.     public static void main(String[] args) {
  27.        // 直接调用内部类
  28.         Body.Heart heart = new Body().new Heart();
  29.         heart.beat(); // beat...
  30.     }
  31. }

2.2 局部内部类

如果一个类是定义在一个方法内部，那么它就是一个局部内部类；只有当前所属方法才能使用它，出了这个方法的范围就不能再用。格式：

  1.  修饰符 class 外部类名称{
  2.      修饰符 返回值类型 外部类名称（参数列表）{
  3.          class 局部内部类名称{
  4.              ...
  5.          }
  6.          ...
  7.      }
  8.      ...
  9.  }

声明局部内部类时不能有访问控制符（即public或private）

代码示例：

  1. class Person{
  2.     public void show(){
  3.         class Teacher{
  4.             public void show(){
  5.                 System.out.println("teacher...");
  6.             }
  7.         }
  8.         Teacher t = new Teacher();
  9.         t.show();
  10.     }
  11. }
  13. public class LocalInterClass {
  14.     public static void main(String[] args) {
  15.         Person p = new Person();
  16.         p.show();  // teacher...
  17.     }
  18. }

局部内部类如果希望访问所在方法的局部变量，那么这个变量必须是有效final的

2.3 匿名内部类

如果接口的实现类（或父类的子类）只需要使用唯一的一次，则可以省略该类的定义，而改为使用匿名内部类。格式：

  1. 接口名称 对象名 = new 接口名称(){
  2.     //覆写所有抽象方法
  3. };

注意事项：对于上面创建匿名内部类的语句来说：

  • new代表创建对象的动作
  • 接口名称是匿名内部类需要实现那个接口
  • {…}是匿名内部类的内容

匿名内部类和匿名对象：

  • 匿名内部类在创建对象的时候，只能使用唯一的一次如果希望希望多次创建多次，而且类的内容完全一样，则只能使用接口的单独实现类
  • 匿名内部类是省略了实现类/子类名称，但匿名对象是省略了对象名称

2.4 静态内部类

内部类的使用是希望只有创建它的外部类使用，对包内其他类具有不可见性。如果同时又希望使用内部类只是将其隐藏在外部类内部，并不需要内部类有外部类对象的一个引用，就可以将内部类类型声明为static，此时内部类就是静态内部类。

例如，创建一个类ArrayGetMaxMin实现获取一次性获取数组中的最大值和最小值，为了保存最值结果，在ArrayGetMaxMin中创建内部类pair实现结果保存。由于pair并不需要有ArrayGetMaxMin对象的引用，因此最好定义为一个静态内部类。

  1. import java.util.Arrays;
  2. import java.util.Random;
  4. public class ArrayGetMaxMin {
  5.     public static Pair getMaxMin(int[] arr, int bound){
  6.         int min = arr[0];
  7.         int max = arr[0];
  9.         for(int i = 1; i < arr.length; i++){
  10.             if (arr[i]< min){
  11.                 min = arr[i];
  12.             }
  13.             if (arr[i] > max){
  14.                 max = arr[i];
  15.             }
  16.         }
  17.         return new Pair(min, max);
  18.     }
  19.     public static class Pair{
  20.         private int first;
  21.         private int second;
  23.         public Pair(int first, int second) {
  24.             this.first = first;
  25.             this.second = second;
  26.         }
  28.         public int getFirst() {
  29.             return first;
  30.         }
  32.         public int getSecond() {
  33.             return second;
  34.         }
  35.     }
  37.     public static void main(String[] args) {
  38.         int[] array = new int[10];
  39.         int bound = 10;
  40.         for (int i = 0; i < array.length; i++) {
  41.             array[i] = new Random().nextInt(bound);
  42.         }
  43.         System.out.println(Arrays.toString(array));
  45.         Pair maxMin = ArrayGetMaxMin.getMaxMin(array, bound);
  46.         System.out.println("min number is: " + maxMin.getFirst() + " and ma x number is: " + maxMin.getSecond());
  47.     }
  48. }

2.5 变量重名问题

通过关键字指定访问的是哪一个变量，如果是当前方法的变量则直接访问；如果是当前类成员变量，需使用this关键字指定访问；如果是外部类的成员变量，需使用外部类名称.this.成员变量名称访问。

  1. class Body {
  2.     private String name = "body";
  4.     //成员内部类
  5.     public class Heart{
  6.         String name = "HEART";
  8.         public void show(){
  9.             String name = "heart";
  10.             // 解决重名变量问题
  11.             System.out.println(name);
  12.             System.out.println(this.name);
  13.             System.out.println(Body.this.name);
  14.         }
  15.     }
  16. }
  18. public class InterClassTest {
  19.     public static void main(String[] args) {
  20.         Body.Heart heart = new Body().new Heart();
  21.         heart.show();
  22.         /*
  23.          * heart
  24.          * HEART
  25.          * body
  26.          */
  27.     }
  28. }

2.6 访问控制修饰符问题

包含有外部类、内部类的访问控制修饰符的使用：

  • 外部类：public、(default)
  • 成员内部类:：public / protected / (default) / private
  • 局部内部类：什么都不能写