java 内部类(嵌套类)、内部接口(嵌套接口)

内部类

Java中的内部类共分为四种：

• 静态内部类：static inner class (also called nested class)
• 成员内部类：member inner class
• 局部内部类：local inner class
• 匿名内部类：anonymous inner class
• 接口类定义内部类：interface inner class

内部类就相当于一个外部类的成员变量，所以可以直接访问外部变量，外部类不能直接访问内部类变量，必须通过创建内部类实例的方法访问，
new InnerClass(32).m就是创建内部类实例访问内部类成员变量(包括内部类的私有变量或私有访问都可以访问)
你想不通的肯定是指内部类的私有变量怎么可以被外部类访问吧，按常规，私有变量m只能在InnerClass里被访问，

内部类可以直接访问外部类的私有属性，这是由于这个原因。
1、非静态内部类对象会持有外部类的对象。其实是，非静态内部类对象依赖于外部类对象而存在，没有外部类就没有内部类，有外部类不一定有内部类。这一点从内部类的使用语法上面可以看出：

    public class Outer {  
    int outValue = 1;  
          
    public static void main(String[] args) {  
        Inner inner = new Outer().new Inner();//内部类需要外部类的实例来new，所以没有外部类就没有内部类  
    }  
      
   	public void test() {
	    Inner inner = new Inner(); 
	    System.out.println(inner.name); // 在外部类中，实例话内部类inner后，可以访问inner中的任意的变量或属性，private的效果只针对非外部类
	    inner.inner();
	}
    class Inner{   // Inner内部类如果是private的话，效果也只针对非外部类
    	private String name = "1";
        private void inner(){  
        int innerValue =    outValue;  
        }  
    }  
}  

如果非静态内部类不持有外部类实例，那么它怎么能直接访问外部类实例呢。

 2、静态内部类，内部类是静态的，那么它就是类级别的类成员了，不在依赖于对象而存在。所以静态内部类，不能访问外部类非静态成员。这样静态内部类就不再依赖于外部类实例而存在，静态内部类也就只持有外部类的类引用。

3、为什么匿名内部类访问方法内的变量必须是final修饰？
匿名内部类是非静态内部类的一种，它可以访问外部类的成员，且不必用final修饰，所以它也会持有外部类对象。（在安卓中时刻防止内部类导致内存泄露）

由于方法中的声明的变量，它是在方法执行时，加载到栈内存中，随着方法执行结束就会被销毁释放。而匿名内部类是类成员的一种，它的生命周期跟外部类是一致的，这就导致方法中的变量被销毁后，匿名内部类对象还可以访问它，这显然不符合逻辑。所以java这样解决，使用final修饰，首先让大家都不要再改动，然后匿名内部类会拷贝一份，这样保证了值的统一性，在方法中的变量被释放后还是可以访问。当这个变量是引用变量的时候，也是一样的。引用变量在栈中的值是对象在堆的内存地址，这样保证了访问的是同一个对象，但是这个对象还是可以修改自己堆中的值。
注意：
1. 在java 1.8中，可以不用final修饰，但是千万不要被误导，因为你不用final修饰，在匿名内部类中修改它的值还是会导致编译报错。因为java 1.8其实会自动给它加上final
2. 类中的多层嵌套按照单层嵌套处理即可

public class Test5 {

    public static void main(String[] args) {
        new Test5().test1();
    }

    public void test1() {
        Test6 test6 = new Test6();
        System.out.println(test6.name);
        test6.name = "2";
        System.out.println(test6.name);

        Test6.Test7 test7 = test6.new Test7();
        test7.name7 = "3";
        System.out.println(test7.name7);
    }
    private class Test6 {
        private String name = "1";
        private void test2() {
            System.out.println("Test6 -> test2()");
        }

        private class Test7 { // Test7不能加static, 因为Test6没有加static
            private String name7 = "8";
            private void tes3() {
                System.out.println("Test7 -> test3()");
            }
        }
    }
}

内部接口

1. 内部接口也称为嵌套接口，即在一个接口内部定义另一个接口。举个例子，Entry接口定义在Map接口里面，如下代码：

public interface Map {
    interface Entry{
        int getKey();
    }
    void clear();
}

2. 如下是一些强有力的理由：

• 一种对那些在同一个地方使用的接口进行逻辑上分组；
• 封装思想的体现；
• 嵌套接口可以增强代码的易读性和可维护性；
  在Java标准库中使用内部接口的一个例子是java.util.Map和Java.util.Map.Entry。这里java.util.Map同样被当成命名空间使用。Entry并不属于全局作用域范围.

3. 为了弄清楚内部接口是如何工作的，我们可以拿它与内部类作比较。内部类可以被认为是一个外部类内部定义的一个常规方法。因为一个方法可以被声明为静态和非静态，类似的内部类也可以被声明为静态和非静态。静态类类似于静态方法，它只能访问外部类的静态成员属性。非静态方法可以访问外部类的所有成员属性。
   因为接口是不能实例化的，内部接口只有当它是静态的才有意义。因此，默认情况下，内部接口是静态的，不能你是否手动加了static关键字。

public interface Map {
    interface Entry{
        int getKey();
    }
    void clear();
}

public class MapImpl implements Map {
    class ImplEntry implements Map.Entry{
        public int getKey() {
            return 0;
        }
    }
    @Override
    public void clear() {
        //clear
    }
}