Java面向对象4-内部类

类的组成：属性、方法、构造器、代码块、内部类
代码块：分为 普通块、静态块、构造块、同步块
内部类：分为 成员内部类（静态的、非静态的） 和 局部内部类（所在位置：方法内、块内、构造器内）

内部类的定义：一个类TestOuter的内部的类SubTest，叫内部类，外部类：相对于内部类，TestOuter就是外部类

成员内部类
里面属性、方法、构造器等（不建议再套一层内部类，虽然也可以）
修饰符：private, default, protect, public, final, abstract

（1）在内部类中，可以访问外部类的属性、方法，如果是静态内部类，只能访问外部类中被static修饰的内容
注意：内部类和外部类属性重名的时候，访问外部类属性的方式 OuterClass.this.name
（2）在外部类中，不可以访问内部类的属性、方法，如果要访问，必须先创建对象才可以通过对象来访问

package yes.javase.oop.javase_220226_innerclass_test;

public class Test {
/*  类的组成：属性、方法、构造器、代码块、内部类
 *   代码块：分为 普通块、静态块、构造块、同步块
 *   内部类：分为 成员内部类 和 局部内部类，局部内部类所在位置：方法内、块内、构造器内
*/
    //属性
    private int a = 10;
    //方法
    public void b(){
        System.out.println("b");
        {
            //代码块（普通块）
            System.out.println("普通块");
        }
        class E{
            //内部类（局部内部类-方法内）
        }
    }
    //构造器
    public Test(){
        class E{
            //内部类（局部内部类-构造器内）
        }
        //System.out.println(name);
    }
    //代码块（构造块）
    {
        int b;
        class F{
            //内部类（局部内部类-块内）
        }
    }
    //代码块（静态块）
    static {
        int c;
    }
    //内部类（非静态成员内部类）
    class InnerClass{
        String name;
        int a = 20;
        public void method(){
            int a = 30;
            System.out.println(a);//在内部类中可以访问外部类的属性
            b();//在内部类中可以访问外部类的方法
            //内部类和外部类属性重名的时候，访问外部类属性的方式：OuterClass.this.name
            System.out.println(a);//结果为30
            System.out.println(this.a);//结果为20
            System.out.println(Test.this.a);//结果为10
        }
    }
    //内部类（静态成员内部类）
    static class StaticInnerClass{

    }
}
class Main{
    public static void main(String[] args) {
        //创建外部类对象
        Test t = new Test();
        t.b();
        //创建内部类对象
        //创建静态成员内部类
        Test.StaticInnerClass s = new Test.StaticInnerClass();
        //创建非静态成员内部类
        Test t2 = new Test(); //必须先创建外部类对象
        Test.InnerClass i = t2.new InnerClass(); //通过外部类对象进行创建
        i.method();
    }
}

局部内部类

重点：匿名内部类！

（1） 在局部内部类中访问到的变量，必须是被final修饰的
（2）多态的用法，返回实现类
（3）如果类B在项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了，使用完毕立即释放

package yes.javase.oop.javase_220226_innerclass2_test;

public class OuterClass {
    public void method(){
        final int num = 10;
        class A{
            public void a(){
                //1、在局部内部类中访问到的变量，必须是被final修饰的
                System.out.println(num);
            }
        }
    }
    public Comparable method2(){
        //3、如果类B在项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了，使用完毕立即释放
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        //2、多态的用法，返回实现类
        return new B();
    }
    //4、更简化的写法（匿名内部类）
    public Comparable method3(){
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };//直接用接口名来创建（实现类的）对象，没有命名
    }
    //5、更简化的写法2
    public Comparable method4(){
        Comparable com = new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };//直接用接口名来创建对象，没有命名，但用接口com来接收实现类
        System.out.println(com.compareTo("abc"));
        return com;
    }
}