一：基本介绍

一个类的内部又完整的嵌套了另一个类结构，被嵌套的类成为内部类
嵌套其他类的类称为外部类（ outer class ）。是类的第五大成员。 :::danger 类的五大成员！！！！！
属性，方法，构造器，代码块，内部类 ::: 内部类的最大特点是可以直接访问私有属性，迫切可以直接提现类与类之间的包含关系
在看底层源码时，有大量的内部类

1：内部类的分类

  • 定义在外部类局部位置上
    • 局部内部类
    • 匿名内部类
  • 定义在外部类的成员位置上
    • 成员内部类（没用static修饰）
    • 静态内部类（使用static修饰）

      四：局部内部类的使用

      :::danger 局部内部类是定义在外部类的局部位置，比如方法中，并且有类名 :::
  1. 可以直接访问外部类的所有成员,包含私有的
  2. 不能添加访问修饰符，但是可以使用final修饰，因为局部变量也可以使用final
  3. 作用域：仅仅在定义他的方法或者代码中
  4. 局部内部类可以直接访问外部类的成员
  5. 外部类 —> 访问 —> 局部内部类的成员
    1. 访问方式：创建对象，再访问，（注意必须在作用域中）作用域：定义的方法或者代码块中。

  6. 外部其他类不能访问局部内部类（因为局部内部类是一个局部变量） ```java public class InnerCLass { public static void main(String[] args) {

    1.  Outer outer = new Outer();
    3.  outer.Sakura();
    4.  //执行sakura()方法时，在方法体内定义局部内部类
    5.  //定义完之后再执行下面的创建对象

    }

} class Outer { //外部类 private int n1 = 10; //属性

  1. private void Test(){ //私有方法
  2.     System.out.println("Test方法");
  3. }
  5. public void Sakura(){ //方法
  7.     //可以用final修饰
  8.     final class Inner{  //局部内部类
  9.         private int  n1 = 100;
  11.         public void F(){
  12.             //局部内部类：访问-->  外部类的成员 
  13.             //[  访问方式：直接访问 ]
  14.             System.out.println(n1);
  15.             Test();
  17.             //如果有重名的，就近原则
  18.             //若想访问外部类的成员使用：外部类名.this.成员
  19.             //因为外部类名.成员 只有在静态的时候才这样
  20.             //非静态，非共有。需要加this表明是这个对象的属性
  21.             System.out.println("内部类的成员"+ n1);
  22.             System.out.println("外部类的的n1" + Outer.this.n1);
  23.         }
  24.     }
  25.     //外部类在局部内部类作用域(定义局部内部类-的方法体或者代码块)
  26.     //中，可以创建对象，然后调用方法即可
  27.     Inner inner = new Inner();
  28.     inner.F();
  29. }

}

  1. <a name="Bxmuj"></a>
  2. ### 五：匿名内部类
  3. <a name="kbDUw"></a>
  4. #### 1：基本使用
  6. 1. 本质是类
  7. 2. 内部类
  8. 3. 该类没有名字
  9. 4. 同时还是一个对象
  10. :::danger
  11. 说明：匿名内部类是定义在外部类的局部位置，比如方法中并且没有类名
  12. :::
  13. ```java
  14. public class AnonymousInnerClass {
  15.     public static void main(String[] args) {
  16.         outer outer = new outer();
  17.         outer.method();
  18.     }
  19. }
  20. class outer{
  21.     private int n1 = 10;
  22.     public void method(){
  23.         //需求：使用A接口，并创建对象
  24.         //传统写法：创建类实现接口，创建对象调用方法
  25.         // A cat = new cat();
  26.         //cat.cry();
  28.         //需求：类只使用一次，后面不在使用
  29.         //使用匿名内部类
  30.         //编译类型：A        运行类型：匿名内部类  Onter&1
  31.         //底层
  32.         /*
  33.         class Outer04$1 implements IA {
  35.             @Override public void cry() {
  36.                 System.out.println("猫叫了");
  37.             }
  38.         }
  39.          */
  40.         //jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例
  41.         //并且把地址返回给 tiger
  42.         A cat = new A(){
  43.             @Override
  44.             public void cry() {
  45.                 System.out.println("猫叫了");
  46.             }
  47.         };
  48.         //通过getclass来查看当前的运行类型
  49.         System.out.println("Cat的运行类型："+ cat.getClass());
  50.         cat.cry();
  51.     }
  52. }
  53. interface A{
  54.     public void cry();
  56. }
  57. /*class cat implements A{
  58.     @Override
  59.     public void cry() {
  60.         System.out.println("猫叫了");
  61.     }
  62. }*/
  63. class father{
  64.     public father(String name) {
  65.         System.out.println("接收到name"+ name);
  66.     }
  67. }

2：匿名内部类的细节

  • 匿名内部类即时一个类的定义，同时也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征。

    1. public class TestClass {
    2.   public static void main(String[] args) {
    3.       Test T = new Test();
    4.       T.A();
    5.   }
    6. }
    7. class Test{
    9.   //创建一个基于类的匿名对象
    10.   public void A(){
    11.       //第一种匿名内部类创建方法
    12.       Person person =  new Person(){
    13.           @Override
    14.           public void speak() {
    15.               System.out.println("重写Person里的speak方法");
    16.           }
    17.       };
    18.       person.speak();  //动态绑定 运行类型是Test&1
    20.       //第二种匿名内部类创建方法
    21.       //底层 class 匿名内部类 extends Person
    22.       new Person(){
    23.           @Override
    24.           public void speak() {
    25.               System.out.println("重写Person里的speak方法");
    26.           }
    27.           @Override
    28.           public void eat(String name) {
    29. //                super.eat(name); 调用父类也就是Person的eat方法
    30.               System.out.println(name+"吃饭了");
    31.           }
    32.       }.eat("sakura");
    33.   }
    34. }
    35. class Person{
    36.   public void speak(){
    37.       System.out.println("人说话");
    38.   }
    39.   public void eat(String name){
    40.       System.out.println("人吃饭");
    41.   }
    42. }

    :::danger 其他和局部内布类一样：

  • 可以直接访问外部类的所有成员，包含私有的

  • 不能添加访问修饰符，因为它的地位就是一个局部变量
  • 作用域：仅仅在定义它的方法或代码块
  • 匿名内部类—-访问——>外部类成员
  • 外部其他类—- 不能访问——->匿名内部类（因为匿名内部类地位是一个局部变量)

  • 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问 :::

    六：匿名内部类的最佳实践

    1：当做实惨传递

    ```java public class Test00 { public static void main(String[] args) {

    1.   //当做实惨直接传递，简洁高效
    2.   Test(new AA() {
    3.       @Override
    4.       public void eat() {
    5.           System.out.println("人吃饭");
    6.       }
    7.   });
    9.   //传统方法
    10.   Test(new Person());

    }

    public static void Test(AA aa){

    1.   aa.eat();

    } }

interface AA{ public void eat(); }

//传统方法 class Person implements AA{ @Override public void eat() { System.out.println(“吃饭吃饭吃饭”); } }

  1. <a name="Inq7H"></a>
  2. ##### 2：
  3. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/2595924/1660632068047-a99a4e4b-623b-4027-9081-76956a4e9cb5.png#clientId=u7e033b8d-da80-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=268&id=u644d0e86&margin=%5Bobject%20Object%5D&name=image.png&originHeight=268&originWidth=594&originalType=binary&ratio=1&rotation=0&showTitle=false&size=241819&status=done&style=none&taskId=u4592abb6-d889-418f-bba1-83dfeb76050&title=&width=594)
  4. ```java
  5. public class Test01 {
  6.     public static void main(String[] args) {
  8.         Cellphone cellphone = new Cellphone();
  10.         //1. 传递的是实现了 Bell 接口的匿名内部类 InnerClassExercise02$1
  11.         // 2. 重写了 ring
  12.         //Bell bell = nee Bell(){
  13.         //  @Override
  14.         //  public void Ring() {
  15.         //      System.out.println("起床了");
  16.         //  }
  17.         //}
  18.         cellphone.alarmClock(new Bell() {
  19.             @Override
  20.             public void Ring() {
  21.                 System.out.println("起床了");
  22.             }
  23.         });
  24.         cellphone.alarmClock(new Bell() {
  25.             @Override
  26.             public void Ring() {
  27.                 System.out.println("不起床");
  28.             }
  29.         });
  31.     }
  33. }
  35. interface Bell {
  36.     public void Ring();
  37. }
  38. class Cellphone{
  40.     public void alarmClock(Bell bell){
  41.         bell.Ring();
  42.     }
  43. }

七：成员内部类的使用

:::danger 说明：成员内部类定义在外部类的的成员位置，并且没有static修饰 :::

  1. 可以直接访问外部类的所有成员，包含私有的属性
  2. 可以添加任意访问修饰符
  3. 作用域
    1. 和外部类的其他成员一样，为整个类体。
  4. 成员内部类访问外部类对象（比如：属性）
    1. 访问方式：直接访问
  5. 外部类访问成员内部类
    1. 访问方式：创建对象，再访问

  6. 外部其他类访问 ```java public class Test02 { public static void main(String[] args) {

    1.  Outer outer = new Outer();
    2.  outer.UseInnerClass();
    4.  //外部其他类访问成员内部类的三种方式
    5.  //(前提要先创建外部类)
    6.  //第一种
    7.  outer.new Inner();//new Inner()当做是 outer 成员
    8.  Outer.Inner inner = outer.new Inner();
    10.  //第二种 在外部类中编写一个方法，可以返回Inner对象
    11.  //接收通过InnerInstance返回的Inner对象 
    12.  Outer.Inner innerInstance = outer.getInnerInstance();

    } }

class Outer{ //外部类 private int Num = 10; private void Test(){ System.out.println(“外部类的Test方法”); } public class Inner{ //成员内部类 //可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员 private int Num = 100; public void Say(){ System.out.println(“外部类的Num：”+ Outer.this.Num); System.out.println(“成员内部类Num:” + Num); } } //使用成员内部类 //通过写方法，创建成员内部类的对象，然后使用相关的方法 public void UseInnerClass(){ Inner inner = new Inner(); inner.Say(); } public Inner getInnerInstance(){ //返回一个Inner实例，但是没有对象接收 return new Inner(); } }

  1. <a name="SLwM1"></a>
  2. ### 七：静态内部类的使用
  3. :::danger
  4. **_说明：静态内部类是定义在外部类的成员位置，并且有static修饰_**
  5. :::
  7. 1. **_可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员_**
  8. 2. **_可以添加任意访问修饰符（pubic，protected，默认，private）因为它的地位就是一个成员_**
  9. 3. **_作用域：_**
  10.    1. **_同其他的成员一样，为整个类体_**
  11. 4. **_静态内部类访问外部类（比如：静态属性）_**
  12.    1. **_访问方式：直接访问所有静态成员_**
  13. 5. **_外部类访问静态内部类_**
  14. 6. **_外部其他类范文静态内部类_**
  15. 7. **_如果外部类和静态内部类的成员，泽可以使用（外部类。成员）去访问_**
  16. ```java
  17. public class Tets00 {
  18.     public static void main(String[] args) {
  19.         Outer outer = new Outer();
  20.         outer.UseInnerClass();
  22.         //第一种：
  23.         //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
  24.         Outer.Inner inner = new Outer.Inner();
  26.         //第二种
  27.         //编写一个方法，可以返回静态内部类的对象实例.
  28.         Outer.Inner inner1 = outer.getInner();
  29.     }
  30. }
  31. class Outer{ //外部类
  32.     private static int Num = 10;
  33.     private void Test(){
  34.         System.out.println("外部类的Test方法");
  35.     }
  36.     public static class Inner{ //成员内部类
  38.         //可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
  39.         private  int Num = 100;
  40.         public void Say(){
  41.             System.out.println("外部类的Num："+ Outer.Num);
  42.             System.out.println("成员内部类Num:" + Num);
  43.         }
  44.     }
  45.     //外部类访问静态内部类
  46.     //通过写方法，创建成员内部类的对象，然后使用相关的方法
  47.     public void UseInnerClass(){
  48.         Inner inner = new Inner();
  49.         inner.Say();
  50.     }
  51.     public Inner getInner(){
  52.         //返回一个Inner实例，但是没有对象接收
  53.         return new Inner();
  54.     }
  55. }

:::danger 非静态成员内部类创建对象
new Inner( )当做是 outer 成员
Outer.Inner inner1 = outer.new Inner( );
静态成员内部类创建对象
因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
Outer.Inner inner2 = new Outer.Inner( ); :::

七：练习

  1. public class Test {//外部类
  4.     public Test() {//构造器
  5.          Inner s1 = new Inner();
  6.          s1.a = 10;
  7.          Inner s2 = new Inner();
  8.          System.out.println(s2.a);
  9. }
  10. class Inner { //内部类，成员内部类
  11.         public int a = 5;
  12. }
  13.     public static void main(String[] args) {
  14.         Test t = new Test();//5
  15.         //正常情况是要应该是Test.Inner
  16.         Inner r = t.new Inner();
  17.         System.out.println(r.a);//5
  18.     }
  20. }