java基础-内部类

一、什么是内部类？

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性 定义方式一致。

二、内部类的种类

内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

静态内部类

public class Outer {

    private static int radius = 1;

    static class StaticInner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
        }
    }
}

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建方式，new 外部类.静态内部类()，如下:
new Outer.StaticInner()

成员内部类

定义在类内部，成员位置上的非静态类，就是成员内部类。

public class Outer {

    private static  int radius = 1;
    private int count =2;
    
     class Inner {
        public void visit() {
            System.out.println("visit outer static  variable:" + radius);
            System.out.println("visit outer   variable:" + count);
        }
    }
}

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式外部类实例.new 内部类()，如下：
new Outer().new Inner()

局部内部类

定义在方法中的内部类，就是局部内部类。

public class Outer {

    private  int out_a = 1;
    private static int STATIC_b = 2;

    public void testFunctionClass(){
        int inner_c =3;
        class Inner {
            private void fun(){
                System.out.println(out_a);
                System.out.println(STATIC_b);
                System.out.println(inner_c);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
    public static void testStaticFunctionClass(){
        int d =3;
        class Inner {
            private void fun(){
                // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
                System.out.println(STATIC_b);
                System.out.println(d);
            }
        }
        Inner  inner = new Inner();
        inner.fun();
    }
}

定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式，在对应方法内，new 内部类()，如下：
public static void testStaticFunctionClass(){
class Inner {
}
Inner inner = new Inner();
}

匿名内部类

匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

public class Outer {

    private void test(final int i) {
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类" );
                }
            }
        }.method();
    }
 }
 //匿名内部类必须继承或实现一个已有的接口 
 interface Service{
    void method();
}

除了没有名字，匿名内部类还有以下特点：

• 匿名内部类必须继承一个抽象类或者实现一个接口。
• 匿名内部类不能定义任何静态成员和静态方法。
• 当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
• 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

匿名内部类创建方式：
new 类/接口{
//匿名内部类实现部分
}

内部类的优点

我们为什么要使用内部类呢？因为它有以下优点：

• 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
• 内部类不为同一包的其他类所见，具有很好的封装性；
• 内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
• 匿名内部类可以很方便的定义回调。

内部类的底层

• javac Outer.java编译完成后， 生成的class文件是两个Outer.class Outer$Inner.class
• 为什么内部类可以访问外部类的成员，包括私有数据？内部类的class中保存一个外部类的指针

final innerclass.Outer this$0;

• 局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？
  1 如果一个变量的值在编译期间可以确定 ，则编译器会默认在匿名内部类（局部内部类）的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中.
  2 局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题.
  3 既然在innerMethod方法中访问的变量a和outMethod方法中的变量a不是同一个变量，当在innerMethod方法中修改a会怎样？那就会造成数据不一致的问题
  4 使用final修饰符，final修饰的引用类型变量，不允许指向新的对象，这就解决数据不一致问题
  5 注意： 在Java8 中，被局部内部类引用的局部变量，默认添加final，所以不需要添加final关键词。

总结

成员内部类

• 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
• 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
  外部类.this.成员变量
  外部类.this.成员方法
• 外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：new Inner().method()
• 成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：new Outter().new Innter()
• 内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。
• 外部类只能被public和包访问两种权限修饰。由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

匿名内部类

• 匿名内部类也是不能有访问修饰符和static修饰符的
• 匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static

• 静态内部类是不需要依赖于外部类的实例的，这点和类的静态成员属性有点类似
• 不能使用外部类的非static成员变量或者方法。因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象

为什么局部内部类和匿名内部类只能访问局部final变量？

因为外部变量生命周期结束，但是匿名内部类可能并没有执行完，比如新开线程等。所以虚拟机的做法是将外部变量的引用复制给匿名内部类，所以，要求必须是final的，不会变化的，否则就不一致了。

内部类的使用场景

1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，

2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

3.方便编写事件驱动程序

4.方便编写线程代码

创建静态内部类对象的一般形式为： 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()

创建成员内部类对象的一般形式为： 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()