Java的内部类

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。
• 在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类

静态内部类(被static修饰的成员内部类)–可以实例化!

获取静态内部类对象(把它当成外部类的成员)

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

class Outer {
    //静态内部类
    static class InnerClass {
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.InnerClass inn = new Outer.InnerClass();
    }
}

class Outer {
    //静态内部类
    static class InnerClass {
    }
    InnerClass inn = new InnerClass();
}

静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法

静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能直接访问外部类的非静态成员变量,但是普通内部类可以访问任意外部类的成员变量和方法

• 因为外部类对象的非静态成员,依赖外部类对象
• 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问,方便在没有创建对象的情况下进行调用(方法/变量)

class Outer {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    //静态内部类
    static class InnerClass {
        public int data4 = 4;
        public static int data5 = 5;

        public void test() {
            Outer outer = new Outer();
            System.out.println(outer.data1);
            System.out.println(outer.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
        }
    }
}


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

class Outer {
    //静态内部类
    static class InnerClass {
        public static int data = 5;
        public static void test() {
            System.out.println(data);
        }
    }
}


public  class Test {
    public static void main(String[] args) {
        Outer.InnerClass.test();
        System.out.println(Outer.InnerClass.data);
    }
}

实例内部类(未被static修饰的成员内部类)

一般实例内部类不能有被static修饰的成员变量和方法,但是成员变量加上final后可以变成常量(常量在编译的时候确定)

1. 外部类中的任何成员都可以在实例内部类方法中直接访问
2. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象

实例化实例内部类(先将外部类实例化)

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

两种方式:

class Outer {
    class InnerClass {
    }
}

public class Test {
    public static void main(String[] args) {
        Outer out = new Outer();
        Outer.InnerClass innerClass = out.new InnerClass();
        Outer.InnerClass innerClass2 = new Outer().new InnerClass();
    }
}

实例内部类中包含了2个this(一个是外部类,一个是实例内部类自己)

class Outer {
    public int data1 = 1;
    public static int data2 = 2;
    class InnerClass {
        public int data1 = 111;
        public static final int data3 = 3;
        public void test() {
            System.out.println(Outer.this.data1);
            System.out.println(this.data1);
            System.out.println(data1);
            System.out.println(data2);
            System.out.println(data3);
        }
    }

    public void func() {
        InnerClass innerClass = new InnerClass();
        innerClass.test();
    }
}

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

匿名内部类(参考此文)

注意：

1、匿名内部类不能定义任何静态成员、方法。

2、匿名内部类中的方法不能是抽象的；

3、匿名内部类访问的外部类成员变量或成员方法必须用static修饰；

4、匿名内部类因为没有类名，可知匿名内部类不能定义构造器。

5、因为在创建匿名内部类的时候，会立即创建它的实例，可知匿名内部类不能是抽象类，必须实现接口或抽象父类的所有抽象方法。

6、匿名内部类会继承一个父类（有且只有一个）或实现一个接口（有且只有一个），实现父类或接口中所有抽象方法，可以改写父类中的方法，添加自定义方法。

7、当匿名内部类和外部类有同名变量（方法）时，默认访问的是匿名内部类的变量（方法），要访问外部类的变量（方法）则需要加上外部类的类名。

匿名对象(运用的场景是只使用一次对象)

public class Test {
    public void func() {
        System.out.println("func()");
    }
    public static void main(String[] args) {
       new Test().func();
    }
}

匿名内部类

抽象类和接口可以接收具体对象

interface InterFaceA {
    void func();
}
public class Test {
    public static void main(String[] args) {
        InterFaceA a = new InterFaceA() {
            @Override
            public void func() {
                System.out.println("func()");
            }
        };
        a.func();
        System.out.println("============");
        new InterFaceA() {
            @Override
            public void func() {
                System.out.println("func()");
            }
        }.func();
    }
}

局部内部类(定义在方法里面)

只能在方法里面实例化对象.
不能被public、static等访问限定符修饰
局部内部类只能在所定义的方法体内部使用
编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

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