9_Java内部类

静态内部类

静态内部类定义在类的内部，与其他成员同级，带有 static 修饰符。

静态内部类除了位置放在其他类内部外，与独立的类差别不大，可以有静态变量、静态方法、成员变量、成员方法、构造方法等。

静态内部类可以访问外部类的类变量和类方法，但不可以访问实例变量和方法。

在类内部，可以直接使用内部静态类。

在类外部，可以通过“外部类．静态内部类”的方式使用 public 静态内部类。

• 静态内部类的实现

源文件编译后实际会生成两个类：外部类和静态内部类。

public class Outer {
  private static int shared = 100;
  
  public static class StaticInner {
    public void innerMethod(){
      System.out.prinln("inner" + shared);
    }
  }
  
  public void test(){
    StaticInner si = new StaticInner();
    si.innerMethod();
  }
}

源码编译后实际会生成两个类 Outer.class 和 Outer$StaticInner 。

public class Outer {
  private static int shared = 100;
  
  public void test(){
    Outer$StaticInner si = new Outer$StaticInner();
    si.innerMethod();
  }
  
  public static int access$0(){
    return shared;
  }
}

public class Outer$StaticInner {
  public void innerMethod(){
      System.out.prinln( "inner" + Outer.access$0() );
    }
}

普通成员内部类（依赖外部类实例）

普通成员内部类不可以定义静态变量和方法（final 变量例外，它等同于常量）。

普通成员内部类可以直接访问外部类的静态、实例变量和方法。

普通成员内部类可以通过外部类.this.xxx的方式引用外部类的实例变量和方法，如 Outer.this. action()，一般在重名的情况下使用。

在类内部，可以直接使用普通成员内部类。

在类外部，不能直接通过new Outer.Inner()的方式创建对象，而是要先将创建一个外部类对象，再通过外部类对象创建，外部类对象．new 内部类()。

• 实例内部类的实现

public class Outer {
  private int a = 100;
  
  public class Inner {
    public void innerMethod() {
      System.out.prinln("outer a " + a);
      Outer.this.action();
    }
  }
  
  private void action() {
    System.out.prinln("action");
  }
  
  public void test(){
    Inner inner = new Inner();
    inner.innerMethod();
  }
}

编译后的代码大概如下：

public class Outer {
  private int a = 100;

  private void action() {
    System.out.prinln("action");
  }
  
  public void test(){
    Outer$Inner inner = new Outer$Inner(this);
    inner.innerMethod();
  }
  
  static int access$0(Outer outer){
    return outer.a;
  }
  
  static void access$1(Outer outer){
    outer.action();
  }
}

public class Outer$Inner {
  final Outer outer;
  
  public Outer$Inner(Outer outer){
    this.outer = outer;
  } 
  
  public void innerMethod(){
     System.out.prinln("outer a " + Outer.access$0(outer));
     Outer.access$1(outer);
  }
}

方法内部类 / 局部内部类

方法内部类定义在外部类的方法中。方法内部类只能在定义的方法内被使用。

如果方法是实例方法，则内部类可以直接访问外部类的静态变量和方法、实例变量和方法。

如果方法是静态方法，则内部类只能访问外部类的静态变量和方法。

方法内部类还可以访问方法的参数和方法中的局部变量，不过，这些变量必须被声明为 final。

• 方法内部类的实现

与成员内部类类似，方法内部类也有一个实例变量指向外部类对象，在构造方法中被初始化，对外部类私有实例变量的访问也是通过编译时外部类生成的静态的访问方法。

方法内部类可以访问方法中的参数和局部变量，这是通过在构造方法中传递参数来实现的。

匿名内部类

常做参数使用。

new 父类(参数列表){
  
}

new 接口(){
  
}

匿名内部类没有单独的类定义，在创建对象的同时定义类。

匿名内部类只能被使用一次，用来创建一个对象。它没有名字，没有构造方法，但可以根据参数列表，调用对应的父类构造方法。

• 匿名内部类的实现

匿名内部类编译时被生成为一个独立的类，类的名字为外部类加数字编号。

与方法内部类类似，外部实例 this、局部变量、方法参数传递给了内部类构造方法。

参考：《Java编程的逻辑》 马俊昌

标签：部类,Outer,内部,Java,outer,方法,public
来源： https://www.cnblogs.com/knhap/p/16218093.html