写在前面的话

内部类在面向对象中用的并不多，而且使用起来也有点抽象，所以我们只需要对其概念有个理解就好。不需要花费功夫深入学习。

概念

所谓内部类，就是在类的里面再定义一个类，那么这样的类称之为内部类。

• 内部类有四种：

  成员内部类
  局部内部类
  匿名内部类
  静态内部类

匿名内部类也是局部内部类的一种。

成员内部类
类的成员有属性、方法。现在又多了一种成员，这种成员为类。

如果类不创建对象，则成员属性无法使用，对于成员内部类也一样，如果外部类不创建对象，内部类是使用不了的。

成员内部类可以无条件使用外部类的属性和方法；因为成员内部类能被使用说明对象已经创建，对象已经创建说明外部类的所有属性和方法都已经在成员内部类使用之前被调用，此时内部类再使用则完全没有问题。

如何内部类和外部类同时定义了一个成员A，那么内部类会使用离自己最近的也就是内部类成员。

public class outer{
    
    
    private int x = 10;

    class inner{
    
    
        private int x = 11;
        public void say(){
    
    
            System.out.println(x);
            System.out.println(outer.this.x);
        }
    }

}

public static void main(String[] args){
    
    
    outer o = new outer();
    outer.inner i = o.new ineer();
    i.say();
}
// 打印结果为:11  10

局部内部类
对于变量，分为成员变量：类中的属性；和局部变量：定义在可执行的方法里面的变量；

所以局部内部类指的是定义在类中可执行方法里面的类。

使用范围也仅限于该方法（鸡肋的地方)，像一个局部变量一样，不能有public,protected,private,static权限修饰符修饰。

public class outer{
    
    

    public void say(){
    
    
         class inner{
    
    
            public void say(){
    
    
                System.out.println("hello");
            }
            inner i = new inner();
            i.say();
         }
    }
}

public static void main(String[] args){
    
    
    outer o = new outer();
    o.say();
}
// 打印为：hello

匿名内部类
指的是创建内部类时没有给类起名字，所以这种类只能使用一次。

类的作用就是创建对象的，所以匿名内部类也就只能创建一次对象，下一次就找不到该内部类了。

格式：

new 父类(参数列表)|实现接口( )

{
    
    

// 匿名内部类类体部分

} ;  

注意事项：

必须有父类或者实现一个接口，但两者不可兼得

匿名内部类中是不能定义构造函数的。

匿名内部类不能存在任何静态变量和方法

匿名内部类为局部内部类，所以局部内部类的限制对匿名内部类生效

匿名内部类不能是抽象的

只能访问final型的局部变量

静态内部类
在成员内部类加上static静态修饰就是静态内部类。

静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似；

public class book{
    
    
    static class info{
    
    
        public void say(){
    
    
            System.out.println("这是一个信息类");
        }
    }
}

// 使用时可不需要通过外部类创建对象才能使用
book.info a = new book.info();
a.say();   // 此时外部类对象并没有被创建。

并且它不能使用外部类的非static成员变量或者方法。因为有可能外部类还没有创建对象，非static修饰的成员未被加载。

规则：静态只能访问静态修饰的成员。

局部内部类使用final参数
局部内部类使用外部类参数，内在逻辑是局部内部类把该参数备份了一份放在自己的内存里，如果外部类再对参数修改值，那么里面和外面参数大小就会不一样，导致逻辑错乱。所以只能使用final修饰的参数。

在外部类中，参数初始化之后没有再被更改值之前，该参数默认是final型。