java内部类

内部类

可以访问外部类的所有属性

1.局部内部类

局部内部类写在方法或代码块中

其本质为局部变量，也是一个完整的类

其访问和作用域遵循类和局部变量的规则

如果局部内部类有一个和外部类同名的属性，不加修饰词使用时，用的是局部内部类的属性

如果想使用外部类的属性则要用 外部类名.this.属性名

 public class LocalInnerClass {
     public static void main(String[] args) {
         Test test = new Test();
         test.f1();
     }
 }
 ​
 class Test {
     private int number = 10;
     private static int man = 20;
 ​
     public Test() {
 ​
     }
 ​
     public void f0() {
         System.out.println("黑猫警长");
     }
 ​
     public void f1() {
         class Inner {
             private int number = 100;
             // private static int man = 20;
             // 上面的语句是错误的,局部内部类中不能有静态变量
             // 应为局部内部类实在代码块或者方法中的,所以它需要有实例对象
             // 而静态变量是不依赖于实例变量的
             // 或者可以这样想局部内部类相当于一个局部变量,而静态变量不能是局部变量
             public Inner() {
 ​
             }
 ​
             public void f0() {
                 System.out.println("一只耳");
                 System.out.println("number = " + number);
                 System.out.println("外部类number = " + Test.this.number);
                 System.out.println("man = " + man);
                 System.out.println("外部man = " + Test.man);
                 Test.this.f0(); // 调用外部类的函数
             }
         }
         Inner inner = new Inner();
         inner.f0();
     }
 }

2匿名内部类

匿名内部类写在方法或代码块中

其本质为局部变量，也是一个完整的类

基于接口的匿名内部类

 public class AnonymousInnerClass {
     public static void main(String[] args) {
          Human jackyChen = new Human() {
             private String name = "jackyChen";
             @Override
             public void eat() {
                 System.out.println("吃大米");
             }
             public void print() {
                 System.out.println("name = " + name);
                 System.out.println("Chinese.this.name" + name);
             }
         };
         jackyChen.eat();
         // jackyChen.print();
     }
 }
 ​
 interface Human {
     public void eat();
 }
 ​
 class Chinese {
     private String name;
     
     public Chinese(name) {
         this.name = name;
     }
 }

jackyChen的编译类型为Human，运行类型为AnonymousInnerClass$1

匿名内部类的创建过程：

 class AnonymousInnerClass$1 {
     private String name = "jackyChen";
     @Override
     public void eat() {
         System.out.println("吃大米");
     }
     public void print() {
         System.out.println("name = " + name);
         System.out.println("Chinese.this.name" + name);
     }
 }

先创建AnonymousInnerClass$1类，然后将AnonymousInnerClass$1的实例返回给jackyChen

jackyChen的编译类型为Human，而Human中没有print()方法，所以jackyChen.print();是错的

基于类的匿名内部类

 public class AnonymousInnerClass {
     public static void main(String[] args) {
          Chinese jackyChen = new jackyChen("jackyChen") {
              @Override
              public void sayHi() {
                  System.out.println("你好，我是jackyChen");
              }
          };
     }
 }
 ​
 class Chinese {
     private String name;
     
     public Chinese(name) {
         this.name = name;
     }
     
     public void sayHi() {
         System.out.println("你好");
     }
 }

jackyChen的编译类型为Chinese，运行类型为AnonymousInnerClass$2

而AnonymousInnerClass$1extends Chinese

成员内部类和静态内部类

二者的性质就是成员变量 + 类

 class Food {
     private String name;
     class Fish{
         private String name;
         public Fish() {
             
         }
     }
     public Food() {
         
     }
 }

外部类使用成员内部类方法：

1. 使用方法

2.  Food food = new Food();
    food.Fish fish = new food.Fish();