Java内部类

在Java中，可以将一个类定义在另一个类或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、静态内部类、局部内部类和匿名内部类。

1. 成员内部类

   • 内部类作为外部类的一个成员变量，访问权限可以是任意的权限。
   • 成员内部类中不允许定义静态的成员(静态方法、静态属性)，实例化对象时需要借助外部类的对象完成。
   • 字节码文件名格式: 外部类$内部类.class

   public class OuterClass {
       public String name;
   
       // 定义成员内部类
       class InnerClass {
           public String name;
   
           public void show(String name) {
               System.out.println("参数name: " + name);
               System.out.println("内部类属性name: " + this.name);
               System.out.println("外部类属性name: " + OuterClass.this.name);
           }
       }
   
       public static void main(String[] args) {
           // 1. 实例化外部类对象
           OuterClass outerClass = new OuterClass();
           // 2. 访问外部类对象属性
           outerClass.name = "outerClass";
           // 3. 实例化内部类对象
           InnerClass innerClass = outerClass.new InnerClass();
           // 4. 访问内部类对象属性
           innerClass.name = "innerClass";
           // 5. 调用内部类中的方法
           innerClass.show("parameter");
       }
   }
   

2. 静态内部类:

   • 静态内部类中可以定义静态的成员(静态方法、静态属性)，实例化对象时不需要借助外部类的对象完成。
   • 字节码文件名格式: 外部类$内部类.class

   public class OuterClass {
       public static String name;
   
       // 定义静态内部类
       static class InnerClass {
           // 非静态属性
           public String name;
           // 静态属性
           public static int count;
   
           public void show(String name) {
               System.out.println("参数name: " + name);
               System.out.println("内部类属性name: " + this.name);
               System.out.println("外部类属性name: " + OuterClass.name);
           }
       }
   
       public static void main(String[] args) {
           // 实例化内部类对象，直接实例化即可，不需要借助外部类的对象
           OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
   
           // 也可以通过导包的形式
           //OuterClass.InnerClass innerClass1 = new InnerClass();
   
           OuterClass.name = "outerClass";
           innerClass.name = "innerClass";
           innerClass.show("parameter");
       }
   }
   

3. 局部内部类:

   • 定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。
   • 局部内部类访问外部类当前方法中的局部变量是，因无法保证变量的生命周期与自身相同，变量必须修饰为final
   • 不能使用访问权限修饰符修饰
   • 字节码文件名格式: 外部类$序号内部类.class

   public class OuterClass {
       public static String name;
   
   
       public static void innerClassTest() {
           // 局部内部类中如果使用了局部变量，name这个变量默认会被定义为final
           /*final*/ int a = 10;
           // 定义局部内部类
           class InnerClass {
               public String name;
   
               public void show(String name) {
                   System.out.println("参数name: " + name);
                   System.out.println("内部类属性name: " + this.name);
                   System.out.println("外部类属性name: " + OuterClass.name);
                   System.out.println("a: " + a);
               }
           }
   
           InnerClass innerClass = new InnerClass();
           OuterClass.name = "outerClass";
           innerClass.name = "innerClass";
           innerClass.show("parameter");
       }
   
       public static void main(String[] args) {
           innerClassTest();
       }
   }
   

4. 匿名内部类:

   • 一切特征与局部内部类相同。必须继承一个父类或者一个接口。
   • 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。

   class Program {
       public static void main(String[] args) {
   
           // 1. 借助抽象类，创建匿名内部类并实例化，实例对象完成向上转型
           Person person = new Person() {
               @Override
               public void say() {
                   System.out.println("I am sub......");
               }
           };
           person.say();
   
           // 2. 借助接口，创建匿名内部类并实例化，实例对象完成向上转型
           Calculate calculate = new Calculate() {
               @Override
               public int calculate(int a, int b) {
                   return 0;
               }
           };
           System.out.println(calculate.calculate(2, 3));
       }
   }
   
   abstract class Person {
       public void say() {
           System.out.println("I am spuer......");
       }
   }
   
   interface Calculate {
       int calculate(int a, int b);
   }