Java Nested Class嵌套类详解

这是一篇对Java Nested Class基础知识的复习，也是掌握Java 8 Lambda原理的基础。能力有限，希望能把嵌套类的相关内容说清楚。

嵌套类 Nested Class就是在一个class定义的内部定义另外一个类。

分类

Java中一般规定类的定义文件中只能定义一个Public Class，并且公有类名需要和类的物理文件名保持一致，不然编译器会报错。这个是Java的基本原则。

有些代码组织会希望将这个公有类密切相关的类，与共有类放在一起。那么这个时候可以选择：

1. 在同一个文件中，定义包私有类，或私有类。也就是说在Public文件外定义类。
2. 在公有类内部，再定义一个类。

第二种方式定义的类就是本文的主题，嵌套类（Nested Class）！

嵌套类能够在任意的代码块Block中嵌套，通常情况下嵌套的范围主要是2类：

1. 在Public Class范围内嵌套，换句话说就是一个类的定义作为类的Member。
2. 在静态块、方法、条件判断或者循环代码块中嵌套，换句话说就是代码块中的一个Variable。

对于第一种嵌套类，可以增加访问限定符 public, protected, private 来修饰允许访问范围，也可以增加static关键词；而第二种嵌套类则不能加任何的限定符。

对于加了static的嵌套类，则称为静态嵌套类；对于没加static的嵌套类，则称为非静态嵌套类，又经常被称为内部类（inner class）。

总结静态嵌套类和内部类的区别，如下表：

	静态嵌套类	内部类
生命周期	独立于被嵌套类	依赖被嵌套类，只有在被嵌套类实例化后才可使用
访问权限	不能访问被嵌套类的成员	能够访问被嵌套类的任何成员，包含private
能否拥有静态成员	可以	不能

下面就每一个区别分别举几个例子说明：

生命周期

静态嵌套类

public class Car {

    private String vendorName;
    private Tier[] tiers;

    public Car(String vendorName, Tier tier) {
        this.vendorName = vendorName;
        Tier[] tiers = new Tier[4];
        for (int i = 0; i < 4; i++) {
            tiers[i] = tier.clone();
        }
    }

    private static class Tier {
        private int size;

        public int getSize() {
            return size;
        }

        public void setSize(int size) {
            this.size = size;
        }

        public Tier(int size) {
            this.size = size;
        }

        protected Tier clone() {
            return new Tier(this.getSize());
        }
    }

    @Override
    public String toString() {
        return "Car{" +
                "vendorName='" + vendorName + '\'' +
                ", tiers=" + Arrays.toString(tiers) +
                '}';
    }

    public static void main(String[] args) {
        Car car = new Car("Toyota", new Tier(17));
    }
}

非静态嵌套类

内部类

局部本地类 (local classes)

匿名类(anonymous classes)

Java 中匿名类——Lambda

inner class能访问嵌套类的属性，包括private
static nested class不能访问嵌套类的成员

static nested class 的实例可以脱离外部类的生命周期独立存在，通过 OutterClass.StaticInnerClass instantce = new OutterClass.StaticInnerClass();来创建实例

inner class的实例无法脱离外部类的生命周期独立存在，要实例化一个inner class，必须先实例化相应的outer class，使用以下语法实例化inner class:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

inner class不能生命任何的静态成员

inner class 的两种特殊类型 local classes anonymous classes

local class是定义在代码块内部的，经常会出现在方法体内部。local class可以访问类的成员。local class也可以访问块的本地变量，不过要求本地变量一定要是final的。因为会捕获(capture）相应的值（captrued variable）在Java8开始，本地变量可以访问effectively final的变量，翻译为等价final可能比较合适，就是初始化时候从来不改变的值，编译器会等同于final。java 8 开始，方法的本地类也可以访问方法的参数。shadowing规则同inner class的shadow规则

不能在块内定义接口，因为接口天然是静态的。实例方法不是一个静态的上下文。local cass内部不能定义static方法，只能定义static的常量

匿名类anonymous class与local class类似，只是没有名称。如果类只使用一次，可以使用匿名类。如果说Local class是类声明，那么匿名类就是表达式

访问规则：
匿名类可以访问外部类的成员
匿名类不能访问非final或effectively final的本地变量
匿名类内部的变量生命将屏蔽所有外部的同名变量。通过this, ClassName.this进行访问

同local class，匿名类的成员也有限制：
不能声明静态的方法或接口
能够拥有常量的静态成员

匿名类内可以生命：字段、另外的方法、实例初始化器？，本地类。但不能声明构造器（因为没有名字）

如果匿名类只有一个方法，那么在Java 8中可以使用 Lambda表达式替代

java.util.function

inner class 同名变量的查找策略
method parameter, this.variableName(inner class), OuterClassName.this.variableName.

inner classes的序列化将遇到很大挑战。不同的编译器实现将影响代码的可移植性，因为inner class的构造器是编译器生成的。