搞懂Java内部类

Java内部类一直是我感觉很生疏的地方，但是这个知识点在面试中被问到的几率还是很高，而且在最近的需求中也用到了静态内部类，索性就把这一块又好好学习了下，趁热打铁，写一篇博客巩固下

为什么会有内部类

开始学习内部类的时候，最让我懵比的就是为啥要设计一个内部类，直接就新建一个普通的类岂不是更简单粗暴，但是大神既然设计，那肯定存在即有理。

在我看来内部类的作用主要包括以下几点：

1. 更好的封装性，因为内部类可以被访问限定符修饰，所以可以完全对外部其他类隐藏;
2. 弥补Java单继承的问题，利用内部类，可以在类里利用内部类再继承其他的抽象类或实体类，提高代码的复用率;
3. 内部类可以直接访问所在作用域中的其他数据，包括私有数据，这是直接新建一个普通类做不到的;
4. 内部类可以简化代码，在Android中最常用的就是匿名内部类，例如注册Button的Onclick时，使用匿名内部类简化代码，不用再单独建一个类来实现抽象类或接口

内部类的分类

内部类主要可以分为成员内部类，局部内部类以及匿名内部类。其中成员内部类又包括静态内部类和非静态内部类。

静态内部类和非静态内部类的使用和区别

1. 使用非静态内部类之前必须先实例化外部类，而静态类不需要。这个很好理解，内部类也是外部类的成员，静态成员可以直接通过类来调用，而非静态的必须通过实例来调用；
2. 非静态内部类不能有静态成员，而静态内部类可以有。因为如上一点所说非静态类的使用必须依赖于外部类的实例，而静态成员是类成员，不属于任何实例，所以如果在非静态内部类声明静态成员就存在了矛盾，因此在非静态内部类里不能有静态成员;
3. 静态内部类可以访问外部类的静态成员，但不能访问外部类的非静态成员。这个也很好理解，因为静态内部类不依赖外部类的实例化，所以不能访问外部类的非静态成员；而非静态内部类可以访问外部类的所有成员;

还是用代码说最直白

public class ClassOuter {

    private int a = 1;
    private static int static_b = 2;
    public int c =3;
    public static int static_d = 4;

    public class ClassInner {

        private int x;

        public void innerFun(){
            System.out.println("内部类方法");
            System.out.println(a);
            System.out.println(static_b);
            System.out.println(c);
            System.out.println(static_d);

        }
    }

    public static class ClassStaticInner{

        private int y;
        private static int static_z;

        public void innerFun() {
            System.out.println("静态类方法");
            System.out.println(static_b);
            System.out.println(static_d);
        }
    }

}

public class TestInnerClass {

    public static void main(String[] args){

        ClassOuter.ClassInner classInner = new ClassOuter(). new ClassInner();
        ClassOuter.ClassStaticInner classStaticInner = new ClassOuter.ClassStaticInner();
        classInner.innerFun();
        classStaticInner.innerFun();
    }

}

从demo中可以看出

1. 代码中非静态内部类ClassInner内部只定义了一个非静态的成员变量，若定义静态的成员变量IDE会报错;而在静态内部类ClassStaticInner 中既能定义静态成员，也能定义非静态成员;
2. 非静态内部类ClassInner里既能访问外部类的静态变量，也能访问非静态变量，而静态内部类只能访问外部类的静态变量;
3. 使用非静态内部类时必须先new一个外部类，再通过外部类的实例去new内部类，而静态内部类不需要外部类的实例;

局部内部类

局部内部类相对于上面所说的两种内部类的区别就在于作用域发生了变化，它定义在方法中，或者某个作用域中，这个类的使用仅限于这个方法内或作用域内。
使用局部内部类的作用在于，当我们在一个方法的内部想要实现一个较为复杂的逻辑时，想用一个类把他封装起来，但又不想暴露在别的地方，这时就可以使用局部内部类。
使用局部内部类时需要注意的是：

1. 局部内部类不能使用访问修饰符修饰，它对外是完全隐藏的，只有在定义该局部内部类的方法里或作用域内才能访问;
2. 局部内部类可以使用该类外部方法的局部变量，但是该局部变量必须被声明为final

public class ClassOuter {

   public void testInnerClass(final int a){
       final int b = 1;
       class LocalInnerClass{
           int c;
           public void test(){
               System.out.println(a);
               System.out.println(b);
               System.out.print(c);
           }
       }
       LocalInnerClass localInnerClass = new LocalInnerClass();
       localInnerClass.test();
   }

}

如demo中代码所示，局部内部类LocalInnerClass声明在testInnerClass方法内部，则只能在该方法内部使用，对方法以外的作用域是隐藏的;

在局部内部类中使用了方法中的参数a以及方法内定义的局部变量b，这两个变量在该局部内部类使用时都需要被声明为final，否则IDE会报错;而局部内部类自己的成员变量c的使用和普通类的成员变量使用一致，不需要声明为final。

匿名内部类

匿名内部类和局部内部类比较类似，最大的区别就在于他没有类名，所以称为匿名内部类。
匿名内部类的特点：

1. 没有访问修饰符修饰;
2. 匿名内部类需继承一个抽象类或者实现一个接口;
3. 匿名内部类中不能定义任何静态成员;
4. 匿名内部类没有构造方法，因为他没有类名;
5. 和局部内部类一样，当他使用该类外部方法的局部变量时，必须被声明为final;

public class ClassOuter {

   public void testInnerClass(final int a, final int c){
       final int b = 1;
       new testInterface() {
           int d = c;
           @Override
           public void onClick() {
              System.out.println(a);
              System.out.println(b);
           }
       };
   }

   public interface testInterface{
       void onClick();
   }
}

在如上的demo中，通过testInterface接口实现了一个匿名内部类，在匿名内部类中访问外部的局部变量时，都需要该变量声明为final，否则IDE会报错

为什么局部和匿名内部类在使用局部变量时，该局部变量需要被声明为final

这个问题实际上是由于各自的生命周期不同所引起的。
因为匿名内部类被创建后存在于堆中，而方法的局部变量在栈中，当方法里的代码执行完成后，局部变量就会出栈，而匿名内部类存在于堆中，还可能在其他地方被引用，这样就引起了冲突，方法的局部变量已经消失，而内部类还需要用到这个变量;
所以为了解决这个问题，编译器就帮我们在匿名内部类中创建了一个局部变量的备份，内部类直接使用的是该备份，备份的生命周期和内部类是一样的。但是如果局部变量发生变化，备份也要不断发生变化，所以索性采取了一个比较妥协的办法，把该变量声明为final，这样变量是只可读的，就保证了内部类和外部的该变量的值是一样。

以上就是我学习内部类时的一些理解，能力有限，有理解不对的地方欢迎指正

2019.3.6