在 Java 中，可以在另一个类中定义一个类，这样的类称为嵌套类。它们使您能够对仅在一个地方使用的类进行逻辑分组，从而增加封装的使用，并创建更具可读性和可维护性的代码。

嵌套类的范围受其封闭类的范围限制。
嵌套类可以访问嵌套类的成员，包括私有成员。然而，反之则不然，即封闭类不能访问嵌套类的成员。
嵌套类也是其封闭类的成员。
作为其封闭类的成员，嵌套类可以声明为private、public、protected或package private（默认）。

嵌套类分为两类：
1. 静态嵌套类： 被声明为嵌套类 的静态被称为静态嵌套类。
2. 内部类： 内部类是非静态嵌套类。

语法：

class OuterClass
{
...
    class NestedClass
    {
        ...
    }
}

静态嵌套类

在普通或常规内部类的情况下，没有外部类对象存在，就不可能有内部类对象。即，内部类的对象总是与外部类对象密切相关。但是在静态嵌套类的情况下，如果不存在外部类对象，则可能存在静态嵌套类对象。即，静态嵌套类的对象与外部类对象没有强关联。

与类方法和变量一样，静态嵌套类与其外部类相关联。和静态类方法一样，静态嵌套类不能直接引用在其封闭类中定义的实例变量或方法：它只能通过对象引用来使用它们。

使用封闭的类名访问它们。

OuterClass.StaticNestedClass

例如，要为静态嵌套类创建对象，请使用以下语法：

OuterClass.StaticNestedClass nestedObject = 
     new OuterClass.StaticNestedClass ();

// 演示访问静态嵌套类的 Java 程序
class OuterClass
{
	// 静态对象
	static int outer_x = 10;
	
	// 实例（非静态）对象
	int outer_y = 20;
	
	// 私有对象
	private static int outer_private = 30;
	
	// 静态嵌套类
	static class StaticNestedClass
	{
		void display()
		{
			// 可以访问外部类的静态成员
			System.out.println("outer_x = " + outer_x);
			
			// 可以访问外部类的显示私有静态成员
			System.out.println("outer_private = " + outer_private);
			
			// 以下语句将给出编译错误
			// 因为静态嵌套类不能直接访问非静态成员
			// System.out.println("outer_y = " + outer_y);
		
		}
	}
}
// 驱动程序类
public class StaticNestedClassDemo
{
	public static void main(String[] args)
	{
		// 访问静态嵌套类
		OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
		
		nestedObject.display();
		
	}
}

输出：

outer_x = 10
outer_private = 30

内部类

要实例化内部类，必须先实例化外部类。然后，使用以下语法在外部对象中创建内部对象：

OuterClass.InnerClass innerObject = externalObject.new InnerClass();

有两种特殊的内部类：

本地内部类
匿名内部类

// 用于演示访问内部类的 Java 程序
class OuterClass
{
	// 静态对象
	static int outer_x = 10;
	
	// 实例（非静态）对象
	int outer_y = 20;
	
	// 私有对象
	private int outer_private = 30;
	
	// 内部类
	class InnerClass
	{
		void display()
		{
			// 可以访问外部类的静态对象
			System.out.println("outer_x = " + outer_x);
			
			// 也可以访问外部类的非静态对象
			System.out.println("outer_y = " + outer_y);
			
			// 也可以访问外部类的私有对象
			System.out.println("outer_private = " + outer_private);
		
		}
	}
}
// 驱动程序类
public class InnerClassDemo
{
	public static void main(String[] args)
	{
		// 访问内部类
		OuterClass outerObject = new OuterClass();
		OuterClass.InnerClass innerObject = outerObject.new InnerClass();
		
		innerObject.display();
		
	}
}

输出：

outer_x = 10
outer_y = 20
outer_private = 30

普通或常规类与静态嵌套类的比较

编号	普通内部类	静态嵌套类
1.	没有外部类对象存在，就不可能有内部类对象。也就是说，内部类对象始终与外部类对象相关联。	如果不存在外部类对象，则可能存在静态嵌套类对象。也就是说，静态嵌套类对象不与外部类对象相关联。
2.	在普通/常规内部类中，不能声明静态成员。	在静态嵌套类中，可以声明静态成员。
3.	由于无法声明 main() 方法，因此无法直接从命令提示符调用常规内部类。	由于可以声明 main() 方法，因此可以直接从命令提示符调用静态嵌套类。
4.	外部类的静态成员和非静态成员都可以直接访问。	只能直接访问外部类的静态成员。

最后

一直想整理出一份完美的面试宝典，但是时间上一直腾不开，这套 一千多道面试题宝典，结合今年金三银四各种大厂面试题，以及 GitHub 上 star 数超 30K+ 的文档整理出来的，我上传以后，毫无意外的短短半个小时点赞量就达到了 13k，说实话还是有点不可思议的。

需要完整版的小伙伴，可以一键三连后，点击这里！

一千道互联网 Java 工程师面试题

内容涵盖：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、Spring、SpringBoot、SpringCloud、RabbitMQ、Kafka、Linux等技术栈（485页）

《Java核心知识点合集（283页）》

内容涵盖：Java基础、JVM、高并发、多线程、分布式、设计模式、Spring全家桶、Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、MongoDB、Redis、MySQL、RabbitMQ、Kafka、Linux、Netty、Tomcat、数据库、云计算等