Java中的特殊类——内部类、匿名类

内部类

内部类有两种形式，静态内部类和非静态内部类。

非静态内部类

• 非静态内部类是一个类中嵌套着另外一个类，它有访问外部类成员的权限， 通常被称为内部类。
• 由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。

普通非静态内部类

class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

输出的结果为

15

从以上例子可以看出，当需要实例化内部类时，需要先实例化外部类。否则会在编译时出错。

私有非静态内部类

内部类可以使用 private 或 protected来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符

class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}

运行结果

Error:(9, 19) java: OuterClass.InnerClass 在 OuterClass 中是 private 访问控制

以上运行结果产生的原因是InnerClass类被private修饰。在这种情况下，只有在OuterClass类（外部类）中，才能对InnerClass进行访问。对于上述例子，如果main函数实在OuterClass中，则可以成功访问InnerClass。

从内部类访问外部类成员

class OuterClass {
  int x = 10;

  class InnerClass {
    public int myInnerMethod() {
      return x;
    }
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.myInnerMethod());
  }
}

输出结果为

10

静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它。

class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}

输出结果为

5

注意：静态内部类无法访问外部类的成员。

匿名类

• Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化。主要是用于在我们需要的时候创建一个对象来执行特定的任务，可以使代码更加简洁。
• 匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。
• 匿名类通常继承一个父类或实现一个接口，下面分别以这两种情况进行举例。
• 注意：匿名类是表达式形式定义的，所以末尾以分号 ; 来结束。

匿名类继承一个父类

class Polygon {
   public void display() {
      System.out.println("在 Polygon 类内部");
   }
}

class AnonymousDemo {
   public void createClass() {

      // 创建的匿名类继承了 Polygon 类
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("在匿名类内部。");
         }
      };
      p1.display();
   }
}

class Main {
   public static void main(String[] args) {
       AnonymousDemo an = new AnonymousDemo();
       an.createClass();
   }
}

输出结果为

在匿名类内部。

以上程序中，创建了 Polygon 类，该类只有一个方法 display()，创建的另一个类AnonymousDemo类继承了 Polygon类并重写了Polygon 类的 display() 方法。执行以上代码，匿名类的对象 p1 会被创建，该对象会调用匿名类的 display() 方法。

匿名类继承一个接口

继承接口的方式与继承父类相似。

interface Polygon {
   public void display();
}

class AnonymousDemo {
   public void createClass() {

      // 匿名类实现一个接口
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("在匿名类内部。");
         }
      };
      p1.display();
   }
}

class Main {
   public static void main(String[] args) {
      AnonymousDemo an = new AnonymousDemo();
      an.createClass();
   }
}

输出结果为

在匿名类内部。