Java 内部类的使用详解

一、内部类的相关介绍

1.什么是内部类

一个类包含另外一个类，内部类编译之后是单独.class文件(格式：外部类名称$内部类名称.class）。

2.内部类的分类

• 成员内部类
• 局部内部类（匿名内部类）

二、内部类的定义与使用

1.成员内部类

在类内部的类

格式

权限修饰符 class 外部类名称{
    权限修饰符 class 内部类名称{
    
    }
}

使用成员内部类

两种方法访问成员内部类内容

• 在外部类的方法内，访问内部类，main调用外部方法
• 直接创建内部类对象，创建内部类对象格式如下
  外部类名称 . 内部类名称 对象名 = new 外部类名称(). new 内部类名称();

//外部类
class External {

    //外部类方法
    public void methodExternal(){
        System.out.println("外部类方法");
        //在外部类方法中创建内部类对象，访问内部类方法
        new Internal().methodInternal();
    }

    //成员内部类
    public class Internal{
        //内部类方法
        public void methodInternal(){
            System.out.println("内部类方法");
        }
    }
}

public class Test{
    public static void main(String[] args) {
        //借助外部类方法，访问内部类方法
        External external = new External();
        external.methodExternal();
        System.out.println("=========");
        
        //直接创建内部类对象使用内部类方法
        External.Internal internal = new External().new Internal();
        internal.methodInternal();
    }
}

运行结果

【tips】

内部类可随意访问外部类内容
外部类访问内部类内容时，必须通过内部类对象来访问
(因为在同时存在多个内部类时，不同内部类的内容可能会重复）

2.局部内部类

局部内部类

在方法内部的内部类

格式

public void test(){
	权限修饰符 class 内部类名称{
    }
}

public class External {
    public void methodExternal(){
    	//外部类成员方法的内部类（有用，代码块后的【tips】会解释）
        [final] int num = 10;
        //在方法内部定义的内部类，叫做局部内部类
        class Internal{
            public void methodInternal(){
            	//内部类使用外部类的局部变量
                System.out.println(num);
            }
        }
    }
}

【tips】
被内部类使用的局部变量，必须保证变量的值事实不可变。

原因如下：
1.new出来的对象在堆内存中
2.局部变量是跟着方法走的，在栈内存中
3.方法运行结束之后，立刻出栈，局部变量也会立刻消失
4.但是new出来的对象会堆内存中持续存在，直到垃圾回收消失

从jdk 8开始，final关键字可以省略，但必须保证局部变量的值不可变。

匿名内部类(重要)

在方法内部没有名字的内部类
匿名内部类可以很方便的作为方法的参数，或者返回值
使用情景分析

如果接口的实现类（或者父类的子类）只需要使用唯一的一次，那么这种情况可以省略该类的定义格式，使用匿名内部类。

格式

//大括号内部才属于匿名内部类
接口名称 对象名 = new 接口名称(){
   //覆盖重写所有抽象方法
}

对格式进行解析：
1.new 代表创建对象的动作
2.接口名称代表匿名内部类需要实现哪个接口
3.{…}才是匿名内部类的内容

interface Interface {
    void method();
}

public class Demo01Main {
    public static void main(String[] args) {
        
        //使用匿名内部类创建对象
        Interface anInterface = new Interface() {
            @Override
            public void method() {
                System.out.println("匿名内部类重写了抽象方法");
            }
        };
        //使用匿名内部类对象，调用method方法
        anInterface.method();


        //使用匿名内部类、匿名对象，调用method方法
        new Interface(){
            @Override
            public void method() {
                System.out.println("匿名内部类重写了抽象方法，并且使用的匿名对象调用");
            }
        }.method();
    }
}

运行结果

【tips】

使用一次匿名内部类只能创建一个对象

匿名对象和匿名内部类的区别

匿名对象：省略了对象名称，创建后只能调用一个方法
匿名内部类：省略了实现类（或者子类），只能创建出一个对象

3.匿名内部类同名变量的访问

public class External {
	//外部类成员变量
    int num = 10;
    public class Internal{
    	//内部类成员变量
        int num = 20;
        public void innerMethod(){
        	//内部类局部变量
            int num = 30;
            System.out.println(num);//就近原则，局部变量
            System.out.println(this.num);//内部类成员变量
            System.out.println(External.this.num);//外部类成员变量
        }
    }
}