内部类就是一个类的内部定义的类
一、成员内部类
成员内部类的格式如下：
class Outer{
class Inner{}
}
编译上述代码会产生两个文件：
Outer.class 和 Outer$Inner.class
public class Test1 {
public static void main(String[] args){
Outer outer = new Outer();
// 在外部创建成员内部类的实例，因为成员内部类需要依赖外部类的对象
// 通常情况下，我们不建议这样来
Outer.Inner inner = outer.new Inner();
inner.print();
}
}
class Outer{
private String name;
class Inner{
public void print(){
System.out.println("inner");
}
}
}
建议在外部类中定义一个方法，对外提供访问内部类的接口
public class Test1 {
public static void main(String[] args){
Outer outer = new Outer();
outer.innerPrint();
}
}
class Outer{
private String name;
// 建议在外部类中定义一个方法，对外提供访问内部类的接口
public void innerPrint(){
Inner inner = new Inner();
inner.print();
}
private class Inner{
public void print(){
System.out.println("inner");
}
}
}
二、方法内部类
方法内部类只能在定义该内部类的方法内实例化。不可以在此方法外对其实例化。
方法内部类对象不能使用该内部类所在方法的非final局部变量。
public class Test1 {
public static void main(String[] args){
Outer outer = new Outer();
outer.show();
}
}
class Outer{
// show方法的局部变量或方法的参数，实际必须是常量 final
public void show(){
final int x = 2;
class Inner2{
public void print(){
//x++；// 从内部类引用的本地变量必须是最终变量或实际上的最终变量
System.out.println("方法内部类"+x);
}
}
Inner2 inner2 = new Inner2();
inner2.print();
}
}
三、静态内部类
在一个类内部定义一个静态内部类。静态内部类的含义是该内部类可以像其他静态成员一样，没有外部对象时，也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。
public class Test1 {
public static void main(String[] args){
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
class Outer{
static private String name = "aiguo";
static public void say(){
System.out.println("could say");
}
static class Inner{
public void show(){
System.out.println(name);
say();
}
}
}
四、匿名内部类
匿名内部类就是没有名字的内部类。
匿名内部类有三种情况：
（1）、集成式匿名内部类
public class Test1 {
public static void main(String[] args){
Outer outer = new Outer();
outer.print1();
}
}
class Outer{
// 继承式
public void print1(){
Cat cat = new Cat() {
public void eat() {
System.out.println("集成式匿名内部类");
}
};
cat.eat();
}
}
abstract class Cat{
public abstract void eat();
}
（2）、接口式匿名内部类
public class Test1 {
public static void main(String[] args){
Outer outer = new Outer();
outer.print2();
}
}
class Outer{
// 接口式
public void print2(){
Eat eat = new Eat() {
public void eat() {
System.out.println("接口式匿名内部类");
}
};
eat.eat();
}
}
interface Eat{
public void eat();
}
（3）、参数式匿名内部类
public class Test1 {
public static void main(String[] args){
Outer outer = new Outer();
outer.print3(new Eat(){
public void eat(){
System.out.println("参数式匿名内部类");
}
});
}
}
class Outer{
public void print3(Eat eat){
eat.eat();
}
}
interface Eat{
public void eat();
}
在使用匿名内部类时，要记住下面几个原则：
（1）、不能有构造方法，只能有一个实例
（2）、不能定义任何静态成员
（3）、不能使用public，protected，private，static
（4）、一定是在new的后面，用其隐含实现一个接口或实现一个类。
（5）、匿名内部类为局部的，所以局部内部类的所有限制对其生效。
五、问题：局部内部类访问局部变量必须用final修饰，为什么？
当调用这个方法时，局部变量如果没有final修饰，它的生命周期和方法的生命周期是一样的，当方法调用时会入栈，方法结束后会弹栈，这个局部变量也会消失，那么如果局部内部类的对象还没马上消息想用这个局部变量，显然已无法使用了，如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也就可以继续使用了。
注意⚠️：在jdk1.8中取消了在局部内部类中使用变量必须显式的使用final修饰，编译器默认会为这个变量加上final。
六、内部类的作用
每个内部类都能独立的继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类是的多重继承的解决方法变得完整。接口解决了部分问题，而内部类有效的实现了“多重继承”。
成员 局部
成员内部类 方法内部类
静态内部类 匿名内部类
依赖外部类对象的：成员内部类 、方法内部类、匿名内部类
静态内部类不依赖外部类的对象。所以，我们在项目中优先考虑静态内部类（不会产生内存泄漏）
