1.开篇
在 Java 这个面向对象的编程语言中，我们几乎离不开“类”这个概念，在博主之前发布的文章中，全部都是在某一个类中，定义一些成员属性或者是成员方法，实例属性（方法）也好、静态属性（方法）也好，最终都是可以通过规范的代码形式去实现的。那么，我们能否在一个类中创建另一个类呢？答案是：肯定的，这就是这篇博文要讲的内容：内部类！！！
2.内部类的介绍
在 Java 语言中，内部类是指在一个外部类的内部再定义一个类。而对于这个内部类来说，它可以是静态 static 的，也可以用（访问修饰符）public，protected，default 和 private 来修饰。（而包含这个内部类的外部类只能使用 public 和 default来进行修饰）。而在字节码语言中，只有类的概念，没有外部类和内部类的概念，类只能使用 public 和 default 进行访问控制。
注意：内部类是一个编译器现象，JVM 虚拟机并不知道内部类与常规类有什么不同。对于源文件中一个名为 Outer 的外部类和其内部定义的名为 Inner 的内部类，编译成功后会出现 Outer.class 和 Outer$Inner.class 两个字节码文件以及文件中的 Outer 和 Outer$Inner 两个类，编译器会把内部类翻译成用 $ (美元符号)分隔外部类名与内部类名的独立的常规类名，而虚拟机则对此一无所知，虚拟机在运行的时候，会把 Outer$Inner 作为一种常规类来处理的。所以内部类的成员变量/方法名可以和外部类的相同。
3.内部类的分类
上图展示了在 Java 语言中，内部类的具体分类，下面，我主要为大家介绍一下对这四种内部类的理解以及应用，即：成员内部类、静态内部类、局部内部类和匿名内部类。
3.1 成员内部类
3.1.1 概念理解
在外部类的内部，定义的非静态的内部类，叫成员内部类。
① 外部类的所有实例成员对成员内部类可见。成员内部类的实例对象，有外部类的实例对象的引用，所以可以访问外部类实例的所有成员（包括 private 私有的）。
② 外部类的静态成员对成员内部类可见。成员内部类可以访问外部类的所有静态成员（包括 private 私有的）。
③ 外部类对成员内部类可见。在内部类中可以使用 new 生成外部类的实例对象。
④ 成员内部类对外部类可见。因为编译后的内部类至少是包内，其构造器至少是包内，所以在外部类中可以使用 new 生成内部类的实例对象。外部类按常规的类访问方式使用内部类，唯一的差别是外部类可以访问成员内部类的所有方法与属性，包括私有方法与私有属性。
⑤ 成员内部类可以使用 public、protected、default或private 访问修饰符进行访问控制，内部类能够隐藏起来，不为同一包的其它类访问。成员内部类一般当做成员变量设置为 private。
⑥ 成员内部类是非静态的。所以在成员内部类中，不能定义静态字段、静态方法和静态内部类，因为成员内部类需要先创建外部类的实例对象，才能创建自己的对象；但是可以定义非静态字段、非静态方法和非静态内部类。
3.1.2 成员内部类的特殊语法规则
假设外部类为 Cow，其成员内部类为 CowLeg。
①在内部类实例对象的方法中引用外部类实例对象的私有数据域：Cow. this.weight
②在外部类实例对象的方法中创建部类实例对象：CowLeg cl = this.new CowLeg(1.12, "黑白相间");
③如果内部类在外部类作用域之外是可见的，则可以这样引用内部类：Cow.CowLeg
3.1.3 应用举例
public class Cow {
private double weight;//外部类的私有成员变量
public Cow(double weight) {//外部类的构造方法
this.weight=weight;
}
private class CowLeg {//定义一个成员内部类
private double length;//成员内部类的两个实例变量
private String color;
//private static int age;由于成员内部类的实例的创建依赖于外部类的实例的创建，所以成员内部类不可以包含静态成员
public CowLeg(double length,String color) {//成员内部类的构造方法
this.length=length;
this.color=color;
}
//length、color的set和get方法
public void setLength(double length) {
this.length=length;
}
public double getLength() {
return this.length;
}
public void setColor(String color) {
this.color=color;
}
public String getColor() {
return this.color;
}
//成员内部类的方法
public void info() {
System.out.println("当前牛腿颜色是："+this.color+",高："+this.length);
System.out.println("本牛腿所在奶牛重："+Cow.this.weight);//如果不写Cow.this.，编译器将自动添加
//直接访问外部类中private修饰的成员变量weight
//weight引用了创建内部类实例对象的外部类的实例对象的私有数据域。
}
}
public void test() {
//CowLeg类的实例对象是在Cow类的实例方法中创建的。
//所以，在创建CowLeg内部类的实例对象之前，必先创建Cow外部类的实例对象。
CowLeg b=new CowLeg(1.12,"黑白相间");
//如果不写this.编译器将自动添加。
//CowLeg b=this.new CowLeg(1.12,"黑白相间");
b.info();
}
public static void main(String[] args) {
Cow a=new Cow(378.9);//创建外部类Cow的实例对象
a.test();
/*Cow.CowLeg d=new Cow(378.9).new CowLeg(1.12,"黑白相间");//创建内部类CowLeg的实例对象
d.info();*/
}
}
3.2 静态内部类
3.2.1 概念理解
将成员内部类的使用再深入限制一步，假如内部类的实例对象不需要引用外部类的实例对象，只是将一个类隐藏在另外一个类的内部，那么就可以将该内部类静态化。在外部类的内部，定义的静态的内部类，叫静态内部类（或叫嵌套类）。提示：静态内部类在实际工作中用的并不是很多。
① 外部类的静态成员对静态内部类可见。静态内部类可以访问外部类的所有静态成员（包括 private 私有的）。
② 外部类对静态内部类可见。在内部类中可以使用 new 生成外部类的实例对象。
③ 外部类的实例成员对静态内部类不可见。静态内部类的实例对象，没有外部类的实例对象的引用，所以不能访问外部类的实例。
④ 静态内部类对外部类可见。因为编译后的内部类至少是包内，其构造器至少是包内，所以在外部类中可以使用 new 生成内部类的实例对象。
⑤ 静态内部类可以使用 public、protected、default或private 访问修饰符进行访问控制，内部类能够隐藏起来，不为同一包的其它类访问。一般当做成员变量设置为 private。
⑥ 静态内部类是静态的。所以在静态内部类中，可以定义静态字段、静态方法和静态内部类；也可以定义非静态字段、非静态方法和非静态内部类。与成员内部类相比，静态内部类没有编译器自动添加的实例字段和构造器参数。即静态内部类的实例是不可以访问外部类的实例成员。
3.2.2 应用举例
public class StaticInnerClassDemo {
private int a=5;//实例变量
private static int b=9;//静态变量
private static class StaticInnerClass {
private static int number=28;//静态内部类里可以包含静态成员
public int find1() {
//System.out.println(a);报错！！！因为静态内部类无法直接访问外部类的实例变量
return b;
}
public static int find2() {
return number;
}
}
public static void main(String[] args) {
StaticInnerClassDemo m=new StaticInnerClassDemo();//创建外部类的实例对象
//外部类中，a为实例字段，由对象调用；b为静态字段，由类调用
System.out.println("外部类的成员变量的值分别为："+m.a+","+StaticInnerClassDemo.b);
StaticInnerClass d=new StaticInnerClass();//创建静态内部类的实例对象
//静态内部类的实例对象调用实例方法，静态内部类直接调用静态方法
System.out.println("静态内部类的成员变量的值分别为："+d.find1()+","+StaticInnerClass.find2());
}
}
3.3 局部内部类（概念理解）
在外部类的方法中定义的非静态的内部类，叫局部内部类。（因为内部类可以访问外部类方法的形参和局部变量而得此名）可以分为：①在外部类的实例方法内部的局部内部类；②在外部类的静态方法内部的局部内部类。
提示：在实际开发中很少使用局部内部类，只是因为局部内部类的作用域很小，只能在当前方法中使用。
3.3.1 外部类实例方法中的局部内部类（概念理解）
① 实例方法的形参对局部内部类可见。局部内部类的实例对象，可以有外部类的实例方法的形参的字段，可以访问外部类实例方法的形参。这些形参在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
② 实例方法的局部变量对局部内部类可见。局部内部类的实例对象，可以有外部类的实例方法的局部变量的字段，可以访问外部类实例方法的局部变量。这些局部变量在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
③ 外部类的实例成员对局部内部类可见。局部内部类的实例对象，有外部类的实例对象的引用，所以可以访问外部类实例的所有成员（包括 private 私有的）。
④ 外部类的静态成员对局部内部类可见。局部内部类可以访问外部类的所有静态成员（包括 private 私有的）。
⑤ 外部类对局部内部类可见。在内部类中可以使用 new 生成外部类的实例对象。
⑥ 局部内部类对外部类的实例方法可见。因为编译后的内部类至少是包内，其构造器至少是包内，所以在外部类的实例方法中可以使用 new 生成局部内部类的实例对象。
⑦ 局部内部类不能使用 public、protected或private 访问修饰符进行访问控制，它的作用域被限定在声明该局部内部类的方法块中，所以在外部类的方法中不可以使用 new 生成局部内部类的实例对象。除了局部内部类所在的外部类方法，没有任何方法知道内部类的存在。
⑧ 局部内部类是非静态的。所以在局部内部类中，不能定义静态字段、静态方法和静态内部类；但是可以定义非静态字段、非静态方法和非静态内部类。
3.3.2 外部类实例方法中的局部内部类（应用举例）
class InstanceLocalOut {
private int age=12;
public void Print(int x) {//如下是实例方法中的局部内部类
int m=8;
class InstanceLocalIn {//在实例方法中定义一个局部内部类
public void inPrint() {//局部内部类的实例方法
//直接访问外部类的private修饰的成员变量age
System.out.println("局部内部类获取外部类的实例成员："+age);
//直接访问外部类实例方法的形参x
System.out.println("局部内部类获取外部类实例方法的形参："+x);
//直接访问外部类实例方法的局部变量m
System.out.println("局部内部类获取外部类实例方法的局部变量："+m);
}
}
InstanceLocalIn b = new InstanceLocalIn();//创建一个局部内部类的实例对象
b.inPrint();//调用该局部内部类中的实例方法
}
}
public class InstanceLocalInnerClass {
public static void main(String[] args) {
InstanceLocalOut a=new InstanceLocalOut();//创建一个外部类的实例对象
a.Print(3);//通过实例对象调用外部类中的实例方法
}
}
3.3.3 外部类静态方法中的局部内部类（概念理解）
外部类静态方法中的局部内部类除了不能访问外部类的实例外（因为它没有外部类的实例对象的引用），与实例方法中的局部内部类相同。
① 静态方法的形参对局部内部类可见。局部内部类的实例对象，可以有外部类的静态方法的形参的字段，可以访问外部类静态方法的形参。这些形参在 JDK8 之前必须被声明为final，但在 JDK8 中就不需要了。
② 静态方法的局部变量对局部内部类可见。局部内部类的实例对象，可以有外部类的静态方法的局部变量的字段，可以访问外部类静态方法的局部变量。这些局部变量在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
③ 外部类的静态成员对局部内部类可见。局部内部类可以访问外部类的所有静态成员（包括 private 私有的）。
④ 外部类对局部内部类可见。在局部内部类中可以使用 new 生成外部类的实例对象。
⑤ 外部类的实例成员对局部内部类不可见。局部内部类的实例对象，没有外部类的实例对象的引用，所以不可以访问外部类实例的所有成员。
⑥ 局部内部类对外部类的静态方法可见。因为编译后的内部类至少是包内，其构造器至少是包内，所以在外部类的静态方法中可以使用 new 生成内部类的实例对象。
⑦ 局部内部类不能使用public、protected或private访问修饰符进行访问控制，它的作用域被限定在声明该局部内部类的方法块中。
⑧ 局部内部类是非静态的。所以在局部内部类中，不能定义静态字段、静态方法和静态内部类；但是可以定义非静态字段、非静态方法和非静态内部类。
3.3.4 外部类静态方法中的局部内部类（应用举例）
class StaticLocalOut {
private int age=12;
public static void print(int x) {
int m=8;
class StaticLocalIn {
public void inPrint() {
//System.out.println(age);静态方法中的局部内部类不能访问外部类的实例
//直接访问外部类静态方法的形参x
System.out.println("局部内部类获取外部类静态方法的形参："+x);
//直接访问外部类静态方法的局部变量m
System.out.println("局部内部类获取外部类静态方法的局部变量："+m);
}
}
StaticLocalIn a=new StaticLocalIn();//创建一个局部内部类的实例对象
a.inPrint();//调用该局部内部类中的实例方法
}
}
public class StaticLocalInnerClass {
public static void main(String[] args) {
StaticLocalOut.print(3);//该外部类自身去调用其中的静态方法
}
}
3.4 匿名内部类（概念理解）
1. 将局部内部类的使用再深入一步，假如只创建这个类的一个对象，就不必命名了。从使用上讲，匿名内部类和局部内部类的区别是：一个是匿名的，另一个是命名的，其它均相同。（匿名的含义是由编译器自动给内部类起一个内部名称）
2. 在外部类的方法中，定义的非静态的没有类名的内部类，叫匿名内部类。
3. 匿名内部类适合只需要使用一次的类，当创建一个匿名内部类时会立即创建该类的一个实例对象，匿名类不能重复使用。可以分为：在外部类的实例方法内部的匿名内部类，在外部类的静态方法内部的匿名内部类。
3.4.1 外部类实例方法中的匿名内部类（概念理解）
① 实例方法的形参对匿名内部类可见。匿名内部类的实例对象，可以有外部类的实例方法的形参的字段，可以访问外部类实例方法的形参。这些形参在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
② 实例方法的局部变量对匿名内部类可见。匿名内部类的实例对象，可以有外部类的实例方法的局部变量的字段，可以访问外部类实例方法的局部变量。这些局部变量在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
③ 外部类的实例成员对匿名内部类可见。匿名内部类的实例对象，有外部类的实例对象的引用，所以可以访问外部类实例的所有成员（包括 private 私有的）。
④ 外部类的静态成员对匿名内部类可见。匿名内部类可以访问外部类的所有静态成员（包括 private 私有的）。
⑤ 外部类对局部内部类可见。在匿名内部类中可以使用 new 生成外部类的实例对象。
⑥ 匿名内部类对外部类该实例方法可见。因为编译后的内部类至少是包内，其构造器至少是包内，所以在外部类中实例方法可以使用 new 生成内部类的实例对象。
⑦ 匿名内部类不能使用 public、protected或private 访问修饰符进行访问控制，它的作用域被限定在声明该匿名内部类的方法块中。
⑧ 由于构造器的名字必须与类名相同，而匿名类无类名，所以匿名内部类不能有构造器。取而代之的是将构造器参数传递给父类构造器。
⑨ 匿名内部类是非静态的。所以在匿名内部类中，不能定义静态字段、静态方法和静态内部类；但是可以定义非静态字段、非静态方法和非静态内部类。
3.4.2 外部类实例方法中的匿名内部类（应用举例）
class InstanceAnonOut {
private int age=12;
public void Print(int x) {//如下是实例方法中的匿名内部类
int m=8;
(new InstanceAnonOut() {//创建匿名内部类
public void inPrint() {//匿名内部类的实例方法
//直接访问外部类的private修饰的成员变量age
System.out.println("匿名内部类获取外部类的实例成员："+age);
//直接访问外部类实例方法的形参x
System.out.println("匿名内部类获取外部类实例方法的形参："+x);
//直接访问外部类实例方法的局部变量m
System.out.println("匿名内部类获取外部类实例方法的局部变量："+m);
}
}).inPrint();
}
}
public class InstanceAnonInnerClass {
public static void main(String[] args) {
InstanceAnonOut a=new InstanceAnonOut();//创建一个外部类的实例对象
a.Print(3);//通过实例对象调用外部类中的实例方法
}
}
3.4.3 外部类静态方法中的匿名内部类（概念理解）
静态方法中的匿名内部类除了不能访问外部类的实例外（因为它没有外部类的实例对象的引用），与实例方法中的匿名内部类相同。
① 静态方法的形参对匿名内部类可见。匿名内部类的实例对象，可以有外部类的静态方法的形参的字段，可以访问外部类静态方法的形参。这些形参在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
② 静态方法的局部变量对匿名内部类可见。匿名内部类的实例对象，可以有外部类的静态方法的局部变量的字段，可以访问外部类静态方法的局部变量。这些局部变量在 JDK8 之前必须被声明为 final，但在 JDK8 中就不需要了。
③ 外部类的静态成员对匿名内部类可见。匿名内部类可以访问外部类的所有静态成员（包括 private 私有的）。
④ 外部类对匿名局部内部类可见。在局部内部类中可以使用 new 生成外部类的实例对象。
⑤ 外部类的实例成员对匿名内部类不可见。匿名内部类的实例对象，没有外部类的实例对象的引用，所以不可以访问外部类实例的所有成员（包括 private 私有的）。
⑥ 内部类对外部类的静态方法可见。因为编译后的内部类至少是包内，其构造器至少是包内，所以在外部类的静态方法中可以使用 new 生成内部类的实例对象。
⑦ 匿名内部类不能使用 public、protected或private 访问修饰符进行访问控制，它的作用域被限定在声明该匿名内部类的方法块中。
⑧ 匿名内部类不能有构造方法。因为匿名类无类名，所以无法写构造方法。取而代之的是将构造器参数传递给超类构造器。
⑨ 匿名内部类是非静态的。所以在匿名内部类中，不能定义静态字段、静态方法和静态内部类；但是可以定义非静态字段、非静态方法和非静态内部类。
3.4.4 外部类静态方法中的匿名内部类（应用举例）
class StaticAnonOut {
private int age=12;//外部类的实例成员
public static void print(int x) {//如下是静态方法中的匿名内部类
int m=8;
(new StaticAnonOut() {
public void inPrint() {
//System.out.println(age);静态方法中的匿名内部类不能访问外部类的实例
//直接访问外部类静态方法的形参x
System.out.println("匿名内部类获取外部类静态方法的形参："+x);
//直接访问外部类静态方法的局部变量m
System.out.println("匿名内部类获取外部类静态方法的局部变量："+m);
}
}).inPrint();
}
}
public class StaticAnonInnerClass {
public static void main(String[] args) {
StaticAnonOut.print(3);//该外部类自身去调用其中的静态方法
}
}
以上，就是博主在学习过程中，总结的 Java 语言中，四种内部类（成员内部类、静态内部类、局部内部类和匿名内部类）的相关内容，希望对大家的学习和理解有所帮助！！！😁😁😁