内部类的那些事

什么是内部类

• 顾名思义，就是一个OuterTest的内部的类SubTest叫内部类。
  （内部类：SubTest，外部类：OuterTest）
• 类的组成：属性，方法，构造器，代码块（普通款，构造块，静态块，同步块），内部类组成

内部类的组成

• 内部类：成员内部类（静态和非静态的）和局部内部类（方法内，构造器内和代码块内）
• 成员内部类：包含属性，方法，构造器等
  修饰符：public，protected，default，private，final，abstract

非静态成员内部类

public class TestOuter {
    //非静态的成员内部类：
    public class D{
        int age = 20;
        String name;
        public void method(){
            //内部类可以访问外部类的内容
            /*System.out.println(age);
            a();*/
            int age = 30;
            //内部类和外部类属性重名的时候，如何进行调用：
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age);//10
        }
    }
    //属性：
    int age = 10;
    //方法：
    public void a(){
        //外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        D d = new D();
        System.out.println(d.name);
        d.method();
    }
    //构造器：
    public TestOuter(){
        class C{
        }
    }
    public TestOuter(int age) {
        this.age = age;
    }
}

总结：

1. 内部类可以访问外部类的内容，直接调用属性或方法就行（如上代码所示）
2. 内部类和外部类属性重名的时候，根据不同类层级来调用（如上代码所示）
3. 外部类想要访问内部类的东西（外部类包含内部类），需要创建内部类的对象然后进行调用
   （如上代码所示）

静态成员内部类

public class TestOuter {
    //静态成员内部类：
    static class E{
        public void method(){
            //静态内部类中只能访问外部类中被static修饰的内容
            /*System.out.println(age);
            a();*/
        }
    }
}

总结：静态内部类中只能访问外部类中被static修饰的内容

class Demo{
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建外部类的对象：
        TestOuter to = new TestOuter();
        to.a();
        //创建内部类的对象：
        //静态的成员内部类创建对象：
        TestOuter.E e = new TestOuter.E();
        //非静态的成员内部类创建对象：
        //错误：TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d = t.new D();
    }
}

总结：测试类访问内部类

• 创建静态成员内部类的对象（如上代码所示）
• 创建非静态成员内部类的对象（如上代码所示）

局部内部类

public class TestOuter {
    //在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
        final int num = 10;
        class A{
            public void a(){
                //num = 20;
                System.out.println(num);
            }
        }
    }
    //如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
    public Comparable method2(){
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }
}

总结：

• 在局部内部类中访问到的变量必须是被final修饰的
• 如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了

匿名内部类

public class TestOuter {
    public Comparable method3(){
        //匿名内部类
        return new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }
    public void teat(){
        Comparable com = new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
        System.out.println(com.compareTo("abc"));
    }
}