• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。
• 在 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();}
}

匿名内部类

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

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() {@Overridepublic void func() {System.out.println("func()");}};a.func();System.out.println("============");new InterFaceA() {@Overridepublic 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();}
}