JAVA基础系列：内部类

内部类

分为：
1.成员内部类
2.局部内部类（其中，局部内部类中包含匿名内部类）

成员内部类

定义格式：

修饰符 class 外部类名 {
  修饰符 class 内部类名{
    //内部类方法体....
  }
  //外部类方法体...
}

使用格式：
分为直接调用和间接调用

1. 直接调用
   通过在main()方法中直接创建内部类的对象，来使用内部类方法

public class Demo20 {

    public static void main(String[] args) {

	//直接创建内部类对象
        OuterClass.InsertClass inter = new OuterClass().new InsertClass();
        inter.methodInsert();
    }
}

public class OuterClass {//外部类

    int num = 10;

    public class InsertClass {//内部类
        int num = 20;
        public void methodInsert() {
            int num = 30;
            System.out.println("这是内部类的方法");
            //内部类方法中对不同位置变量的调用
            System.out.println(num); //调用内部类方法的局部变量
            System.out.println(this.num);//调用内部类的成员变量
            System.out.println(OuterClass.this.num);//调用外部类的成员变量
        }
    }
}

2. 间接调用
   通过在main()方法中创建外部类对象，再调用外部类方法（方法中有内部类的使用）来实现对内部类方法的使用

public class Demo20 {

    public static void main(String[] args) {
       //间接通过外部类方法调用内部类方法
        new OuterClass().methodOuter();
    }
}

public class OuterClass {//外部类

    int num = 10;

    public class InsertClass {//内部类
        int num = 20;
        public void methodInsert() {
            int num = 30;
            System.out.println("这是内部类的方法");
            //内部类方法中对不同位置变量的调用
            System.out.println(num); //调用内部类方法的局部变量
            System.out.println(this.num);//调用内部类的成员变量
            System.out.println(OuterClass.this.num);//调用外部类的成员变量
        }

    }

    public void methodOuter() {//方法中含有对内部类对象的创建和方法的调用
        InsertClass insert = new InsertClass();
        insert.methodInsert();
    }
}

局部内部类

如果一个类定义在定义在一个方法内部中。那么这就是一个局部内部类。
只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：

修饰符 class 外部类名称{
	修饰符 返回值类型 外部类方法名（参数列表）{
		修饰符 class 内部类名称{
			//内部类方法体...
		}
	}
}

使用格式：
直接通过调用外部类的方法即可

public class Demo21 {

    public static void main(String[] args) {

        OuterClass outerClass = new OuterClass();//直接通过调用外部类的方法即可
        outerClass.methodOuter();
    }
}

public class OuterClass {//外部类

    public void methodOuter() {//外部类方法

        class InsertClass {//局部内部类
            public void methodInsert() {
                System.out.println("局部内部类方法执行");
            }
        }

        InsertClass insertClass = new InsertClass();//直接在外部类方法体中创建内部类对象
        insertClass.methodInsert();//并进行方法调用
    }
}

注意事项：
局部内部类，如果想要访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
原因：（跟生命周期有关）

• new出来的对象存在于堆内存中
• 局部变量是跟着方法走的，在栈内存当中
• 方法运行结束后，便会立即出栈，局部变量也随之立即消失（局部变量生命周期短）
• 但是new出来的对象会在堆内存中持续存在，直至被垃圾回收（对象生命周期较长）
• 若局部变量用final修饰，则会在类加载时被放入常量池，即使方法弹栈，常量池中的常量依旧存在

所以局部变量必须是【有效final的】：用final修饰 或 只被赋值一次。

public class OuterClass {//外部类

    int numOne = 10;

    public void methodOuter() {//外部类方法
        final int numTwo = 20;

        class InsertClass {//局部内部类。 class前不能有权限修饰符
            public void methodInsert() {
                System.out.println("局部内部类方法执行");
                System.out.println(OuterClass.this.numOne);//调用外部类方法的成员变量
                System.out.println(numTwo);//调用所在方法的局部变量
            }
        }

        InsertClass insertClass = new InsertClass();//直接在外部类方法体中创建内部类对象，并进行方法调用
        insertClass.methodInsert();
    }
}

匿名内部类

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

定义格式：

接口名称 对象名 = new 接口名称() {
	//覆盖重写所有的抽象方法
}

使用格式：

public class Demo22 {

    public static void main(String[] args) {
    
        MyInterface obj = new MyInterface() { //左父右子
            //需重写接口所有的抽象方法
            @Override
            public void methodInterface() {
                System.out.println("被匿名内部类重写的接口方法");
            }

//            public void method() {
//                System.out.println("匿名内部类自己独有的方法");
//            }
        };

        obj.methodInterface();
//        obj.method();//错误！ 因为接口中没有该抽象类（编译看左边，运行看右边）
    }
}