Java-内部类总结

    广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

    内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

1.成员内部类

    成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

    不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

    在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。创建成员内部类对象的一般方式如下：

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
 
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
}

        

    如果我们需要生成对外部类对象的引用，可以使用Outter.this，这样就能够产生一个正确引用外部类的引用了。

    内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。

2.局部内部类

    局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
    注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

3.匿名内部类

    匿名内部类也是不能有访问修饰符和static修饰符的。

    匿名内部类是唯一一种没有构造器的类，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。    

     局部内部类和匿名内部类访问外部方法的局部变量需要加final修饰符。

4.静态内部类

    静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

    一般来说，内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：

    1）成员内部类的引用方式必须为 Outter.Inner.

    2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()。这段代码摘自《Java编程思想》

class WithInner {
    class Inner{
         
    }
}
class InheritInner extends WithInner.Inner {
      
    // InheritInner() 是不能通过编译的，一定要加上形参
    InheritInner(WithInner wi) {
        wi.super(); //必须有这句调用
    }
  
    public static void main(String[] args) {
        WithInner wi = new WithInner();
        InheritInner obj = new InheritInner(wi);
    }
}

成员内部类里面为什么不能有静态成员和方法？

    非static的内部类，在外部类加载的时候，并不会加载它，所以它里面不能有静态变量或者静态方法。
    1、static类型的属性和方法，在类加载的时候就会存在于内存中。
    2、要使用某个类的static属性或者方法，那么这个类必须要加载到jvm中。
    基于以上两点，可以看出，如果一个非static的内部类如果具有static的属性或者方法，那么就会出现一种情况：内部类未加载，但是却试图在内存中创建static的属性和方法，这当然是错误的。原因：类还不存在，但却希望操作它的属性和方法。

    如果内部类没有static的话，就需要实例化内部类才能调用，说明非static的内部类不是自动跟随主类加载的，而是被实例化的时候才会加载。

为什么局部内部类（匿名内部类）访问外部方法的局部变量需要加final修饰符？

    因为局部变量会在方法调用完毕后立刻消失，而内部类对象的生命周期和外部类其他对象的生命周期一样：如果局部内部类调用的局部变量不用final修饰的话，很可能出现方法已经调用完毕，而内部类还没有被垃圾回收机制收回，会出现内部类非法引用的情况。定义为final后，编译器会把局部内部类要访问的所有final局部变量，都拷贝一份作为该对象的成员变量。这样，即使栈中局部变量已经死亡，局部内部类对象照样可以拿到该局部变量的值，因为它自己拷贝了一份，且与原局部变量的值始终保持一致。