• 定义在类内部的类 就是内部类
  • 成员内部类（实例内部类和静态内部类）字节码文件：外部类类名$内部类类名.class
  • 局部内部类的字节码文件：外部类类名$N内部类类名.class
  • 匿名内部类的字节码文件：外部类类名$N.class
  • 实例内部类
    • 实例内部类内部不允许定义任何静态内容
    • 外部类静态方法中不能直接访问实例内部类数据
    • static final 修饰的变量的值，能在编译器确定值，可以在实例内部类中定义
  • 静态内部类
    • 被static修饰的成员内部类
    • 只有内部类可以被static修饰
  • 匿名内部类
    • 匿名内部类中不能定义构造方法，但是可以定义构造块。

    • 成员内部类 静态内部类 局部内部类

      ```java package cn.java.money.innerclass.demo01;

/**

  • 内部类位置：
  • 成员位置 —- 成员内部类 静态内部类
  • 局部位置 —- 局部内部类 （方法内部类）

  • 内部类的访问特点：
  • 1.0 内部类可以直接访问外部类的成员（成员变量，成员方法），包括私有的。

  • 2.0 外部类要访问内部类的成员，必须创建对象. */ // public 和 default public class Outer { private int num = 10; private static int num2 = 10;

    public void method2() {

    1.  System.out.println("我是外部类的方法 method2");

    }

    public static void method3() {

    1.  System.out.println("我是外部类的静态方法 method3");

    }

    public void method4() {

    1.  // 外部类中访问内部类中的成员，必须创建内部类对象
    2.  // 访问成员内部类中的成员
    3.  Inner inner = new Inner();
    4.  inner.method();
    5.  System.out.println(inner.num);
    7.  // 静态内部类也要创建对象 才能使用
    8.  Inner3 inner3 = new Inner3();
    9.  inner3.method();

    }

    //成员内部类 //成员内部类的修饰符：public private protected default 都可以使用 public class Inner {

    1.  public int num = 11;
    3.  // 内部类中不能有静态成员变量声明
    4.  //public static int num2 = 11;
    5.  public void method() {
    6.      System.out.println("我是成员内部类");
    7.      //成员内部类 可以访问外部的所有变量和方法
    8.      System.out.println(num);
    9.      method2();
    11.      //成员内部类 可以访问外部类的静态变量和静态方法
    12.      System.out.println(num2);
    13.      //每一个内部类对象中都隐含了一个外部类对象
    14.      System.out.println(Outer.this.num2);
    15.      method3();
    16.  }

    }

    //静态内部类: 属于外部类本身，不属于外部类某个对象 public static class Inner3 {

    1.  public void method() {
    2.      System.out.println("我是静态内部类");
    3.      // 编译报错， Inner3 是静态成员类，要访问外部类的非静态变量或方法 都会报错
    4.      //System.out.println(num);
    5.      // 编译报错
    6.      // method2();
    8.      //静态内部类 只能访问外部类静态成员
    9.      System.out.println(num2);
    10.      method3();
    11.  }

    }

    public void method1() {

    1.  // 局部变量:包括方法里的和 代码块里的(静态和非静态), 可以被default(默认不写), final修饰
    2.  final int ii = 0;
    3.  int ii2 = 0;
    5.  //局部内部类
    6.  //方法内部类只能在该方法内部使用，所以不能使用访问控制符（public等）和修饰符（static）；
    7.  //就像是局部变量，在方法外部是无法访问的。
    8.  class Inner2 {
    10.      public void method() {
    11.          System.out.println("我是局部内部类");
    12.          //局部内部类 可以访问外部的所有变量和方法
    13.          System.out.println(num);
    14.          method2();
    16.          //局部内部类 可以访问外部类的静态变量和静态方法
    17.          System.out.println(num2);
    18.          method3();
    20.          //可以访问被声明为final的局部变量.
    21.          // 原因说明：局部变量在栈中，而局部变量new以后在堆上，方法调用完成以后局部变量就释放了，而局部内部类的对象不一定被回收。
    22.          // final修饰局部变量， 局部变量变为一个常量，因此在编译的时候，局部内部类就使用这个常量。
    23.          // jdk 1.8以后， 如果局部内部类使用了方法的局部变量，在编译的时候会自动加上final。
    24.          System.out.println(ii);
    25.          System.out.println(ii2); // jdk1.8 以前必须要显示声明为final,jdk1.8以后不用显示声明
    27.          //Java 中局部内部类和匿名内部类访问的局部变量必须由 final 修饰，以保证内部类和外部类的数据一致性。
    28.          // 但从 Java 8 开始，我们可以不加 final 修饰符，由系统默认添加，当然这在 Java 8 以前的版本是不允许的。
    29.          // Java 将这个功能称为 Effectively final 功能。
    30.      }
    32.  }
    33.  //局部内部类只能在局部范围使用
    34.  Inner2 inner2 = new Inner2();
    35.  inner2.method();

    }

}

  1. ```java
  2. package cn.java.money.innerclass.demo01;
  4. public class TestOuter {
  6.     public static void main(String[] args) {
  7.         //成员内部类 实例化：  外部类.内部类 obj = new 外部类().new 内部类()
  8.         Outer.Inner obj = new Outer().new Inner(); // 因为 Inner 被public修饰，所以可以在外部类以外使用
  9.         // 调用成员内部类的方法
  10.         obj.method();
  11.         System.out.println("--------------------------------------");
  13.         // 调用局部内部类中方法，通过调用外部类的方法，间接的调用
  14.         Outer outer = new Outer();
  15.         outer.method1();
  16.         System.out.println("--------------------------------------");
  18.         //静态内部类 实例化
  19.         Outer.Inner3 obj2 = new Outer.Inner3();
  20.         obj2.method();
  22.         System.out.println("--------------------------------------");
  23.         outer.method4();
  24.     }
  26. }

匿名内部类

  1. package cn.java.money.innerclass.demo01;
  3. // 接口类
  4. interface A {
  5.     void method();
  6. }
  8. // 抽象类
  9. abstract class B {
  10.     B(){
  12.     }
  13.     //有参构造
  14.     B(int n){
  16.     }
  17.     abstract void method();
  18. }
  20. // 普通类
  21. class C{
  22.   public void method (){
  23.       System.out.println("我是普通类的普通方法");
  24.   }
  25. }
  28. public class TestNiMingNeiBuLei {
  30.     // 定义成员变量 执行匿名对象
  31.     // 匿名内部类的本质：接口和抽象类的实现。
  32.     A a = new A() {
  34.         @Override
  35.         public void method() {
  36.             System.out.println("我是匿名内部类 实现接口");
  37.         }
  38.     };
  40.     // 因为接口只有一个方法，因此可以简写为 lambda 表达式
  41.     A a2 = () -> System.out.println("我是匿名内部类，实现接口");
  43.     // b指向b的实现类的对象
  44.     B b = new B() {
  45.         @Override
  46.         void method() {
  47.             System.out.println("我是匿名内部类，实现抽象类");
  48.         }
  49.     };
  51.     //可以是静态的
  52.     static B b2 = new B() {
  53.         @Override
  54.         void method() {
  55.             System.out.println("我是匿名内部类，实现抽象类");
  56.         }
  58.         //这个方法不能被外部 b2 访问，因为匿名内部类没有类名 也就没有类型
  59.         public void ff(){
  60.             System.out.println("匿名内部类自定义的方法");
  61.         }
  63.     };
  65.     // 调用有参构造
  66.     B b3 = new B(45) {
  67.         @Override
  68.         void method() {
  69.             System.out.println("我是匿名内部类，实现抽象类");
  70.         }
  71.     };
  73.     C c = new C() {
  74.         @Override
  75.         public void method (){
  76.             System.out.println("我是普通类的普通方法 在匿名内部类中的重写");
  77.         }
  78.     };
  80.     public static void main(String[] args) {
  81.         TestNiMingNeiBuLei testNiMingNeiBuLei = new TestNiMingNeiBuLei();
  82.         testNiMingNeiBuLei.a.method();
  83.         testNiMingNeiBuLei.a2.method();
  84.         testNiMingNeiBuLei.b.method();
  85.         testNiMingNeiBuLei.c.method();
  87.         //实现接口或抽象类 然后就调用
  88.         new B(){
  89.             @Override
  90.             void method() {
  91.                 System.out.println("我是匿名内部类，实现抽象类， 实现完成立马调用");
  92.             }
  94.         }.method();
  96.         //实现接口或抽象类 然后就调用
  97.         new B(){
  98.             @Override
  99.             void method() {
  100.                 System.out.println("我是匿名内部类，实现抽象类， 实现完成立马调用");
  101.             }
  103.             //这个方法不能被外部访问，因为匿名内部类没有类名 也就没有类型，但是通过 匿名内部类对象自己调用
  104.             public void ff(){
  105.                 System.out.println("匿名内部类自定义的方法");
  106.             }
  108.         }.ff();
  110.     }
  112. }
  1. package cn.java.money.innerclass.demo01;
  3. // 接口类
  4. interface IA {
  5.     void method();
  6. }
  8. // 抽象类
  9. abstract class IB {
  10.     abstract void method();
  11. }
  13. public class TestNiMingNeiBuLei2 extends IB implements IA {
  15.     //IB IA有同名的方法，可以统一给出一个实现
  16.     @Override
  17.     public void method() {
  18.         System.out.println("IB IA有同名的方法，可以统一给出一个实现");
  19.     }
  21.     // IB IA有同名的方法，分别给出实现
  22.     IA a = () -> {
  23.         System.out.println("IA的实现");
  24.     };
  26.     IB b = new IB() {
  27.         @Override
  28.         void method() {
  29.             System.out.println("IB的实现");
  30.         }
  31.     };
  33.     public static void main(String[] args) {
  34.         IA ia = new TestNiMingNeiBuLei2();
  35.         IB ib = new TestNiMingNeiBuLei2();
  36.         ia.method();
  37.         ib.method();
  39.         TestNiMingNeiBuLei2 testNiMingNeiBuLei2 = new TestNiMingNeiBuLei2();
  40.         testNiMingNeiBuLei2.a.method();
  41.         testNiMingNeiBuLei2.b.method();
  42.     }
  44. }