嵌套类分类
静态内部类（静态嵌套类/静态成员类/静态类） 内部类（非静态嵌套类）内部成员类
本地内部类
匿名内部类
嵌套接口
静态内部类
重要的结论：如果一个类被声明为static(即static修饰class)，只有一种情况，该类是静态内部类。
1. 静态内部类中能声明哪些类，变量和方法？
没有限制，可以声明各种类型的类，变量，方法和静态代码块，细分为：
类：
枚举类 静态内部类 内部类 接口变量：
静态变量 实例变量方法：
静态方法 实例方法 静态代码块
2. 静态内部类能访问外围类的哪些变量和方法？
静态内部类可以访问外围类的任何成员，包括外围类中声明为private的成员，分为：
外围类的静态变量和方法(含私有)：直接访问 外围类的实例变量和方法(含私有)：通过外围类的实例对象进行访问 静态内部类类似类的静态变量，不需要依赖外围类的实例对象而存在，可以看作是顶层类，可以直接通过外围类来访问。
3. 继承方面
在继承方面，静态内部类与外围类没什么分别，在访问权限允许的情况下：任何类都可以继承静态内部类，静态内部类也可以继承任何类(类没有声明为final)或实现任何接口。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
public class OuterClass { // 静态变量 final static boolean FLAG_VALUE = true ; private static String name = "Outer Class" ; // 实例变量 private int age; // 静态方法 private static String getName() { return name; } // 实例方法 private void setAge( int age) { this .age = age; } // 静态内部类 public static class StaticInner { // 声明静态变量 final static int x = 1 ; static int y = 2 ; // 声明实例变量 int a; // 声明静态代码块 static { } // 声明枚举类 enum InnerEnum { } // 声明静态内部类 static class Inner2 { } // 声明接口 interface Inner3 { } // 声明内部类 class Inner4 { } // 声明静态方法 static void OperateStatic() { System.out.println( "静态内部类直接访问外围类的静态变量：name = " + name + ", FLAG_VALUE = " + FLAG_VALUE); System.out.println( "静态内部类直接访问外围类的静态方法：getName : " + getName()); // 静态内部类不能直接访问外围类的实例变量和方法 //age = 30; //setAge(30); // 通过声明外围类对象，访问外围类对象的实例变量和方法 OuterClass outerClass = new OuterClass(); outerClass.age = 30 ; outerClass.setAge( 30 ); } //加入Java开发交流君样：756584822一起吹水聊天 // 声明实例方法 void operate() { System.out.println( "静态内部类直接访问外围类的静态变量：name = " + name + ", FLAG_VALUE = " + FLAG_VALUE); System.out.println( "静态内部类直接访问外围类的静态方法：getName : " + getName()); // 静态内部类不能直接访问外围类的实例变量和方法 //age = 30; //setAge(30); // 通过声明外围类对象，访问外围类对象的实例变量和方法 OuterClass outerClass = new OuterClass(); outerClass.age = 30 ; outerClass.setAge( 30 ); } } } |
内部类
1. 细分类
内部成员类
本地内部类（本地类/局部类）
匿名内部类（匿名类）
2. 内部类中能声明哪些类，变量和方法？
内部类可以声明实例变量，实例方法，final类型的静态变量。
内部类不可以声明静态成员：包括静态变量，静态方法，静态内部类，嵌套接口，静态初始化块。
细分为：
类：
只能声明内部类 不能声明枚举类，静态内部类，接口变量：
只能声明实例变量，final类型静态变量 不能声明静态变量方法：
只能声明实例方法 不能声明静态方法 不能声明静态代码块
3. 内部类能访问外围类的哪些变量和方法？
没有限制，外围类的所有变量和方法(含私有)都可以直接访问。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
public class OuterClass { // 静态变量 final static boolean FLAG_VALUE = true ; private static String name = "Outer Class" ; // 实例变量 private int age; // 静态方法 private static String getName() { return name; } // 实例方法 private int getAge() { return age; } // 内部类 public class Inner { // 内部类不能声明静态变量 //private static String innerName = "Inner Class"; // 内部类只能声明实例变量和final类型静态变量 private int a; final static int x = 1 ; // 内部类不能声明静态代码块，枚举类，静态内部类，接口(枚举类型和接口类型总是静态的) //static { } //enum InnerEnum { } //static class Inner2 { } //interface Inner3 { } // 内部类声明内部类 class Inner4 { } // 内部类不能声明静态方法 //static void OperateStatic() { } // 内部类只能声明实例方法 void operate() { System.out.println( "内部类访问外围类的静态变量：name = " + name); System.out.println( "内部类访问外围类的静态final变量：FLAG_VALUE = " + FLAG_VALUE); System.out.println( "内部类访问外围类的实例变量：age = " + (age = 40 )); System.out.println( "内部类访问外围类的静态方法：getName() = " + getName()); System.out.println( "内部类访问外围类的实例方法：getAge() = " + getAge()); } //加入Java开发交流君样：756584822一起吹水聊天 } } |
4. 内部类是怎样绑定外围对象？
总结： 创建内部类对象(调用内部类的构造器)时，编译器会隐式地在内部类中声明一个final的外围类类型的成员变量，然后将外围类的对象，通过内部类的构造器传递给该final成员变量，用来将内部类对象绑定到外围类对象。
|
1 2 3 4 5 6 7 8 9 10 11 |
public class Outer { public class Inner { // 编译器自动隐式生成的外围类类型的成员变量 final Outer this $ 0 ; // 通过内部类构造器将外围类的对象传递给this$0成员变量，实现内部类与外围类对象的绑定 public Inner(Outer outer) { this $ 0 = outer; super (); } } } |
创建内部类对象，如下：
|
1 2 |
Outer outer = new Outer(); Outer.Inner inner = outer. new Inner(); |
创建内部类对象时，系统会自动将外围类的对象(outer)作为参数传入内部类的构造器中，可认为是下面的方式：
|
1 |
Outer.Inner inner = outer. new Inner(outer); |
5. 继承方面
在访问权限允许的情况下：内部类可以继承任何类，也可以由任何类继承。
问：那内部类与静态内部类在继承方面有什么区别呢？
答：内部类的对象总是要依赖于外部对象，因此一个类A继承了一个内部类，则类A也必须要与内部类的外围类对象相绑定，否则产生编译错误。
1.反例：产生编译错误
|
1 2 3 4 5 |
public class A extends Outer.Inner { }
class Outer { class Inner { } } |
2.错误原因：想要创建A类对象，即A a = new A(); 会调用A类构造器，A类继承内部类(Outer.Inner)，则会调用内部类的构造器
这时没有有效的外围类对象，则无法实现内部类对象与外围类对象的绑定，产生编译错误。
3.修正
方法一 ：在A类构造器中传递一个外围类的引用，通过外围类对象来调用内部类的构造器，就相当于将外围类的对象传递给了内部类的构造器，实现了内部类对象与外围类对象的绑定。
|
1 2 3 4 5 6 7 8 |
public class A extends Outer.Inner { public A(Outer outer) { outer. super (); } } class Outer { class Inner { } } |
方法二 ：外部类继承外部类，内部类继承内部类
|
1 2 3 4 5 6 |
public class A extends Outer { class InnerA extends Outer.Inner { } } class Outer { class Inner { } } |
创建A类的内部类InnerA对象：
|
1 2 |
A a = new A(); A.InnerA innerA = a. new InnerA(); |
创建内部类A.InnerA对象时，需要绑定外围对象，a引用就是外围类的对象，
内部类A.InnerA继承了另外一个内部类Outer.Inner，在A.InnerA调用父类构造器时，也需要传递父类的外围类(Outer)对象，
A类继承了Outer类，因为子类的对像可以当作父类的对象来使用，因此a引用也是另一个内部类Outer.Inner的外围对象。
6. 本地内部类
本地内部类：就是在方法，构造器，初始化块中声明的类。
本地内部类不是类的成员，从结构上类似一个局部变量，因此不能使用访问修饰符（public，protected，private），也不能使用static修饰。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
public class LocalInnerDemo { private int x = 100 ; // 1.本地内部类声明在实例初始化块中 { class Local1 { } } // 2.本地内部类声明在静态初始化块中 static { class Local2 { } } // 3.本地内部类声明在构造器中 public LocalInnerDemo() { int y = 2 ; final int z = 3 ; class Local3 { int a = x; int b = y; int c = z; } } //加入Java开发交流君样：756584822一起吹水聊天 // 4.本地内部类声明在实例方法中 public T1 method1() { // 使用本地内部类实现某个接口，然后以接口形式返回 class Local4 implements T1 { @Override public void operate() { System.out.println( "Start to operate." ); } } return new Local4();
} // 5.本地内部类声明在静态方法中 public static T1 method2() { class Local5 implements T1 { @Override public void operate() { System.out.println( "Start to operate." ); } } return new Local5(); } } interface T1 { void operate(); } |
问：本地内部类声明在实例环境(实例方法，构造器，实例初始化块)和静态环境中有什么区别呢？
答：实例环境：本地内部类需要与外围类绑定，即会在类中隐式生成一个final的引用。
静态环境：本地内部类不需要与外围类绑定。
嵌套接口
嵌套接口：就是在类或者接口中声明的接口。
不管声明在类中，还是接口中，嵌套接口永远都是静态的。 当类实现了某个接口时，不需要实现嵌套接口的方法。
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！
原文链接：https://blog.csdn.net/wj1314250/article/details/117046078
查看更多关于Java开发岗位面试被问到嵌套类怎么办的详细内容...