内部类。。

什么是内部类？

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

内部类主要有：

实例内部类

静态内部类

匿名内部类

局部内部类

实例内部类

即未被 static 修饰的成员内部类。

class OuterClass{
    public int date1 = 1;

    public static int date2 = 2;

    private int date3 = 3;

    class InnerClass{
        public int date1 = 111;

        public int date4 = 4;
        public static final int date5 = 5;//编译时就确定了
        private int date6 = 6;

        public void test(){
            System.out.println("InnerClass::test()"+date5);
            System.out.println(date1);
            System.out.println(OuterClass.this.date1);
            System.out.println(date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }

    public void test(){
        InnerClass innerClass = new InnerClass();
        System.out.println("OuterClass::test()");

    }
}
public class Test {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.test();
    }
}

对于实例内部类包含两个this。

注：

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类也受 public 、 private 等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this. 同名成员 来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

内部类的字节码文件名称：

静态内部类

被static修饰的内部成员类称为静态内部类。

class Out{
    public int date1 = 1;
    public static int date2 = 2;
    private int date3 = 3;

    static class InnerClass{
        public int date4 = 4;
        public static int date5 = 5;
        private int date6 = 6;

        public void test(){
            Out out = new Out();
            System.out.println("InnerClass::test()");
            System.out.println(out.date1);
            System.out.println(date2);
            System.out.println(out.date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }

    public void test(){
        System.out.println("Out::test()");
    }
}
public class Test {
    public static void main(String[] args) {
        Out.InnerClass innerClass = new Out.InnerClass();
        innerClass.test();
    }
}

相较于实例内部类优点：不需要有外部类对象的引用，可直接引用

注：

1. 在静态内部类中只能访问外部类中的静态成员

2. 创建静态内部类对象时，不需要先创建外部类对象

匿名内部类

interface IA{
    void test();
}

public class Test {
    public static void main(String[] args) {
        IA a = new IA(){

            @Override
            public void test() {
                System.out.println("这是重写的接口的方法！");
            }
        };
        a.test();

         new IA(){

            @Override
            public void test() {
                System.out.println("这是重写的接口的方法！");
            }
        }.test();
    }
}

相当于，有一个类实现了IA接口，重写了test方法。

局部内部类

几乎不用！！！

public class Test2 {
    public void func(){
        class AA{
            public int a;

        }

        AA aa = new AA();
    }
}

注：

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被 public 、 static 等修饰符修饰