n 种内部类

• 内部类：

  • 一个 class类 内可以再定义其他类（内部类）

    • 通过外部类来实例化内部类
    • 获得外部类的私有属性
    • 如果内部类没有 static 修饰，那么内部类的方法和属性都不能用 static 修饰；如果内部类有 static 修饰，那么内部类的方法和属性就可以用 static 修饰；（可以看作是类内的一个方法）

  • 一个Java文件中有多个 class 类，但是只能有一个 public class 类（同级的类）

  • 局部内部类：

    • 跟局部变量一样，在方法里面写的类
    • 不能用 static 修饰类名 以及 类内的属性和方法

  • 匿名内部类：

    • 没有名字去初始化类，不用将实例保存到变量中（重写和 new 一起完成，对象没有名字）

    • 必须继承父类或实现一个接口

    • 接口的匿名内部类：内部实现类，实现接口方法 new UserService() {"Override重写方法"};

• 局部内部类 和 匿名内部类 的区别：

  1）局部类继承接口，有自己的类名，定义完成之后需要再用new关键字实例化才可以使用；

  2）匿名内部类在定义的时候就实例化了，定义完了就可以直接使用；

  3）匿名类是一个表达式，因此在定义的最后用分号 ";" 结束。

• 示例：

  public class Test {
      private static int a = 11;
      public String name = "wanggenji";
  
      //内部类
      class B{
          int B;
          public void printB(){
  
              System.out.println(a);
              System.out.println(name);
          }
      }
  
      //局部内部类
      public static void innerTest(){
  
          //局部内部类
          class C {
              int anInt;
              public void sayHello(){
                  System.out.println("Hello");
              }
          }
          C c = new C();
          c.anInt = 12;
          System.out.println(c.anInt);
          c.sayHello();
  
  
          //匿名内部类、无名对象直接调用方法和属性
          System.out.println("=========匿名内部类测试=======");
          new D().sayD();
  
          //匿名内部类：    抽象类可以直接在这实现并调用
          new A() {
              @Override
              public void sayA() {
                  System.out.println("A");
              }
          }.sayA(); //注意这里有 分号 ;
  
          //匿名内部类：   接口可以直接在这实现并调用
          new UserService() {
              @Override
              public void saySomething() {
                  System.out.println("saySomething()");
              }
  
              @Override
              public void doSomething() {
                  System.out.println("doSomething()");
              }
          }.doSomething(); //注意这里有 分号 ;
      }
  
      public static void main(String[] args) {
  
          //内部类测试
          System.out.println("=========内部类测试=======");
          Test test = new Test();
          B b = test.new B();
          b.printB();
  
  
          //局部内部类测试
          System.out.println("=========局部内部类测试=======");
          innerTest();
  
      }
  }
  
  interface UserService{
      void saySomething();
      void doSomething();
  }
  
  abstract class A{
      public abstract void sayA();
  }
  
  class D{
      public void sayD(){
          System.out.println("D");
      }
  }