Effective Java -- 1

第1条：考虑用静态工厂方法代替构造器

优点：

1.静态工厂方法与构造器不同的第一大优势在于，它们有名称。

getInstance：返回唯一的实例。
newInstance：返回不同的实例。

2.静态工厂方法与构造器不同的第二大优势在于，不必在每次调用它们的时候都创建一个新对象。
3.静态工厂方法与构造器不同的第三大优势在于，它们可以返回原返回类型的任何子类型的对象。
4.静态工厂方法与构造器不同的第四大优势在于，在创建参数化类型实例的时候，它们使代码变得更加简洁。

缺点：

1.静态工厂方法的主要缺点在于，类如果不含公有的或者受保护的构造器，就不能被子类化。
2.静态工厂方法的第二个缺点在于，它们与其他的静态方法实际上没有任何区别。

public class OttoBus extends Bus {
    private volatile static OttoBus mBus;

    private OttoBus() { 
    }

    public static OttoBus getInstance() { //静态工厂方法
        if (mBus == null) {
            synchronized(OttoBus.class){
                if(mBus == null){
                    mBus = new OttoBus();
                }
            }
        }
        return mBus;
    }
}

第2条：遇到多个构造器参数时要考虑用构建器

重叠构造器模式：第一个构造器只有必要参数，第二个构造器有一个可选参数，第三个构造器有两个可选参数，以此类推。
重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难编写，并且仍然较难以阅读。

如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builder模式就是种不错的选择，特别是当大多数参数都是可选的时候。与使用传统的重叠构造器模式相比，使用Builder模式的客户端代码将更易于阅读和编写，构建器也比JavaBeans更加安全。

Builder模式：

public class Car {
    public static final int COLOR_WHITE = 0;
    public static final int COLOR_OTHER = 1;
    private final String company;
    private final String model;
    private final int color;
    private final float price;

    public static class Builder {
        //Required parameters
        private final String company;
        private final String model;

        //Optional parameters - initialized to default values
        private int color = COLOR_OTHER;
        private float price = 0F;

        public Builder(String company, String model) {
            this.company = company;
            this.model = model;
        }

        public Builder color(int color) {
            this.color = color;
            return this;
        }

        public Builder price(float price) {
            this.price = price;
            return this;
        }

        public Car build() {
            return new Car(this);
        }
    }

    private Car(Builder builder) {
        company = builder.company;
        model = builder.model;
        color = builder.color;
        price = builder.price;
    }

    @Override
    public String toString() {
        return "company: " + company + ", model: " + model + ", color: " + color + ", price: " + price;
    }
}

//代码测试
Car.Builder builder = new Car.Builder("Honda", "XRV");
builder.color(Car.COLOR_WHITE);
builder.price(138000F);
Car car = builder.build();
Log.d(TAG, "zwm, car: " + car);

//输出
03-02 17:07:25.919 zwm, car: company: Honda, model: XRV, color: 0, price: 138000.0

第3条：用私有构造器或者枚举类型强化Singleton属性

实现Singleton有三种常用方法：
方法1：

public class Car {
    public static final Car INSTANCE = new Car();

    private Car() {
    }

    public void doSomething() {
    }
}

//测试代码
Car.INSTANCE.doSomething();

方法2：

public class Car {
    private static final Car INSTANCE = new Car();

    private Car() {
    }

    public static Car getInstance() {
        return INSTANCE;
    }
    
    public void doSomething() {
    }
}

//测试代码
Car.getInstance().doSomething();

方法3：

public enum Car {
    INSTANCE;

    public void doSomething() {
    }
}

//测试代码
Car.INSTANCE.doSomething();

这种方法在功能上与公有域方法相近，但是它更加简洁，无偿地提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现Singleton的最佳方法。

第4条：通过私有构造器强化不可实例化的能力

所有的构造器都必须显式或隐式地调用超类构造器，当将构造器私有化之后，子类就没有可访问的超类构造器可调用了，因此将构造器私有化的类无法被子类化。

第5条：避免创建不必要的对象

String：

String s = new String("string"); //每次都创建一个新的String实例，错误使用
String s = "string"; //只用了一个String实例，正确使用

自动拆箱：

Long sum = 0L; //变量sum声明为Long类型
for(long i=0; i

要优先使用基本类型而不是装箱基本类型，要当心无意识的自动拆箱。

第6条：消除过期的对象引用

内存泄露场景：
1.无意识的对象保持。
2.缓存。
3.监听器和其他回调。

第7条：避免使用终结方法

Java语言规范不仅不保证终结方法会被及时地执行，而且根本就不保证它们会被执行，不应该依赖终结方法来更新重要的持久状态。例如，依赖终结方法来释放共享资源（比如数据库）上的永久锁，很容易让整个分布式系统垮掉。

第8条：覆盖equals时请遵守通用约定

覆盖equals时请遵守通用约定：
1.自反性
对象必须等于其自身。
2.对称性
任何两个对象对于"它们是否相等"的问题都必须保持一致。
3.传递性
如果一个对象等于第二个对象，并且第二个对象又等于第三个对象，则第一个对象一定等于第三个对象。
4.一致性
如果两个对象相等，它们就必须始终保持相等，除非它们中有一个对象（或者两个都）被修改了。
5.非空性
所有的对象都必须不等于null。

实现高质量equals方法的诀窍：
1.使用==操作符检查"参数是否为这个对象的引用"。如果是，则返回true。
2.使用instanceof操作符检查"参数是否为正确的类型"。如果不是，则返回false。
3.把参数转换成正确的类型。
4.对于该类中的每个"关键"域，检查参数中的域是否与该对象中对应的域相匹配。如果这些测试全部成功，则返回true，否则返回false。
对于既不是float也不是double类型的基本类型域，可以使用==操作符进行比较；对于对象引用域，可以递归地调用equals方法；对于float域，可以使用Float.compare方法；对于double域，则使用Double.compare。对float和double域进行特殊的处理是很有必要的，因为存在着Float.NaN、-0.0F以及类似的double常量；对于数组域，则要把以上这些指导原则应用到每个元素上。
5.当编写完equals方法，应该确认五个特性：对称性、传递性、一致性、自反性（通常自动满足）、非空性（通常自动满足）。

public final class CaseInsensitiveString {
    private final String s;

    public CaseInsensitiveString(String s) {
        if(s == null) {
            throw new NullPointerException();
        }
        this.s = s;
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }
        if(obj instanceof CaseInsensitiveString) {
            return s.equalsIgnoreCase(((CaseInsensitiveString) obj).s);
        }
        return false;
    }
}

//测试代码
CaseInsensitiveString testString1 = new CaseInsensitiveString("ABC");
CaseInsensitiveString testString2 = new CaseInsensitiveString("Abc");
Log.d(TAG, "zwm, testString1.equals(testString1): " + testString1.equals(testString1));
Log.d(TAG, "zwm, testString1.equals(testString2): " + testString1.equals(testString2));

//输出
03-03 15:40:47.979 zwm, testString1.equals(testString1): true
03-03 15:40:47.979 zwm, testString1.equals(testString2): true

第9条：覆盖equals时总要覆盖hashCode

在每个覆盖了equals方法的类中，也必须覆盖hashCode方法。如果不这样做的话，就会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常工作，这样的集合包括HashMap、HashSet和Hashtable。

约定内容如下：
1.在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
2.如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
3.如果两个对象根据equals(Object)方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生不同的整数结果。但是给不相等的对象产生截然不同的整数结果，有可能提高散列表的性能。

public class PhoneNumber {
    private final int areaCode;
    private final int prefix;
    private final int lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == this) {
            return true;
        }
        if(!(obj instanceof PhoneNumber)) {
            return false;
        }
        PhoneNumber pn = (PhoneNumber)obj;
        return pn.areaCode == areaCode
                && pn.prefix == prefix
                && pn.lineNumber == lineNumber;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + areaCode;
        result = 31 * result + prefix;
        result = 31 * result + lineNumber;
        return result;
    }
}

//测试代码
PhoneNumber phoneNumber1 = new PhoneNumber(9, 150, 11);
PhoneNumber phoneNumber2 = new PhoneNumber(5, 137, 11);
Log.d(TAG, "zwm, phoneNumber1 hashCode: " + phoneNumber1.hashCode());
Log.d(TAG, "zwm, phoneNumber2 hashCode: " + phoneNumber2.hashCode());
Log.d(TAG, "zwm, phoneNumber1.equals(phoneNumber2): " + phoneNumber1.equals(phoneNumber2));

//输出
03-03 23:31:00.905 zwm, phoneNumber1 hashCode: 519757
03-03 23:31:00.906 zwm, phoneNumber2 hashCode: 515510
03-03 23:31:00.906 zwm, phoneNumber1.equals(phoneNumber2): false

第10条：始终要覆盖toString

虽然java.lang.Object提供了toString方法的一个实现，但它返回的字符串通常并不是类的用户所期望看到的。它包含类的名称，以及一个"@"符号，接着是散列码的无符号十六进制表示法，例如"PhoneNumber@163b91"。

toString的通用约定指出，被返回的字符串应该是一个"简洁的，但信息丰富，并且易于阅读的表达形式"，建议所有的子类都覆盖这个方法。

public class PhoneNumber {
    private final int areaCode;
    private final int prefix;
    private final int lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == this) {
            return true;
        }
        if(!(obj instanceof PhoneNumber)) {
            return false;
        }
        PhoneNumber pn = (PhoneNumber)obj;
        return pn.areaCode == areaCode
                && pn.prefix == prefix
                && pn.lineNumber == lineNumber;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + areaCode;
        result = 31 * result + prefix;
        result = 31 * result + lineNumber;
        return result;
    }

    @Override
    public String toString() {
        return "areaCode: " + areaCode + ", prefix: " + prefix + ", lineNumber: " + lineNumber;
    }
}

//测试代码
PhoneNumber phoneNumber1 = new PhoneNumber(9, 150, 11);
Log.d(TAG, "zwm, phoneNumber1: " + phoneNumber1);

//输出
03-04 22:50:50.878 zwm, phoneNumber1: areaCode: 9, prefix: 150, lineNumber: 11

第11条：谨慎地覆盖clone

Object类提供了Clone方法用于复制对象，一个类如果要支持Clone，需要覆盖Clone方法，并实现Cloneable接口。Object类的Clone实现为浅复制，为了达到深复制，对象的引用以及其引用的引用（依次类推）都需要实现深复制。

浅复制

public class PhoneNumber implements Cloneable{
    public int areaCode;
    public int prefix;
    public int lineNumber;
    public Address address;

    public PhoneNumber(int areaCode, int prefix, int lineNumber, Address address) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "areaCode: " + areaCode + ", prefix: " + prefix + ", lineNumber: " + lineNumber + ", address: " + address;
    }

    public static class Address {
        public String country;
        public String city;

        public Address(String country, String city) {
            this.country = country;
            this.city = city;
        }
    }
}

//测试代码
PhoneNumber.Address address = new PhoneNumber.Address("China", "Guangzhou");
PhoneNumber phoneNumber1 = new PhoneNumber(9, 150, 11, address);
PhoneNumber phoneNumber2 = null;
try {
    phoneNumber2 = (PhoneNumber)phoneNumber1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
Log.d(TAG, "zwm, phoneNumber1 == phoneNumber2: " + (phoneNumber1 == phoneNumber2));
Log.d(TAG, "zwm, phoneNumber1.address == phoneNumber2.address: " + (phoneNumber1.address == phoneNumber2.address));

//输出
2019-03-11 17:16:00.590 zwm, phoneNumber1 == phoneNumber2: false
2019-03-11 17:16:00.590 zwm, phoneNumber1.address == phoneNumber2.address: true

深复制

public class PhoneNumber implements Cloneable{
    public int areaCode;
    public int prefix;
    public int lineNumber;
    public Address address;

    public PhoneNumber(int areaCode, int prefix, int lineNumber, Address address) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        PhoneNumber phoneNumber = (PhoneNumber)super.clone(); //浅复制
        phoneNumber.address = (PhoneNumber.Address)address.clone(); //深复制
        return phoneNumber;
    }

    @Override
    public String toString() {
        return "areaCode: " + areaCode + ", prefix: " + prefix + ", lineNumber: " + lineNumber + ", address: " + address;
    }

    public static class Address implements Cloneable {
        public String country;
        public String city;

        public Address(String country, String city) {
            this.country = country;
            this.city = city;
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
}

//测试代码
PhoneNumber.Address address = new PhoneNumber.Address("China", "Guangzhou");
PhoneNumber phoneNumber1 = new PhoneNumber(9, 150, 11, address);
PhoneNumber phoneNumber2 = null;
try {
    phoneNumber2 = (PhoneNumber)phoneNumber1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
Log.d(TAG, "zwm, phoneNumber1 == phoneNumber2: " + (phoneNumber1 == phoneNumber2));
Log.d(TAG, "zwm, phoneNumber1.address == phoneNumber2.address: " + (phoneNumber1.address == phoneNumber2.address));

//输出
2019-03-11 17:29:43.010 zwm, phoneNumber1 == phoneNumber2: false
2019-03-11 17:29:43.011 zwm, phoneNumber1.address == phoneNumber2.address: false

第12条：考虑实现Comparable接口

Java平台类库中的所有值类都实现了Comparable接口，如果你正在编写一个值类，它具有非常明显的内在排序关系，比如按字母顺序、按数值顺序或者按年代顺序，那你就应该坚决考虑实现这个接口：

public interface Comparable {
    int compareTo(T t);
}

compareTo方法的通用约定与equals方法的相似：
将这个对象与指定的对象进行比较。当该对象小于、等于或大于指定对象的时候，分别返回一个负整数、零或者正整数。如果由于指定对象的类型而无法与该对象进行比较，则抛出ClassCastException。

public class PhoneNumber implements Comparable{
    public int areaCode;
    public int prefix;
    public int lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = lineNumber;
    }

    @Override
    public int compareTo(PhoneNumber o) {
        int areaCodeDiff = areaCode - o.areaCode;
        if(areaCodeDiff != 0) {
            return areaCodeDiff;
        }
        int prefixDiff = prefix - o.prefix;
        if(prefixDiff != 0) {
            return prefixDiff;
        }
        int lineNumberDiff = lineNumber - o.lineNumber;
        return lineNumberDiff;
    }
}

//测试代码
PhoneNumber phoneNumber1 = new PhoneNumber(9, 150, 1501753);
PhoneNumber phoneNumber2 = new PhoneNumber(9, 137, 1375186);
Log.d(TAG, "zwm, phoneNumber1.compareTo(phoneNumber2): " + phoneNumber1.compareTo(phoneNumber2));

//输出
2019-03-11 18:36:20.252 zwm, phoneNumber1.compareTo(phoneNumber2): 13

第13条：使类和成员的可访问性最小化

对于成员（域、方法、嵌套类和嵌套接口）有四种可能的访问级别：
私有的（private）：只有在声明该成员的顶层类内部才可以访问这个成员。
包级私有的（package-private）：声明该成员的包内部的任何类都可以访问这个成员。从技术上讲，它被称为"缺省（default）访问级别"，如果没有为成员指定访问修饰符，就采用这个访问级别。
受保护的（protected）：声明该成员的类的子类可以访问这个成员，并且该成员的包内部的任何类也可以访问这个成员。
公有的（public）：在任何地方都可以访问该成员。
如果方法覆盖了超类中的一个方法，子类中的访问级别就不允许低于超类中的访问级别。这样可以确保任何可使用超类的实例的地方也都可以使用子类的实例。
如果一个类实现了一个接口，那么接口中所有的类方法在这个类中也都必须被声明为公有的。这是因为接口中的所有方法都隐含着公有访问级别。
实例域决不能是公有的，包含公有可变域的类并不是线程安全的。同样的建议也适用于静态域，当然公有静态final域除外，但是要确保公有静态final域所引用的对象都是不可变的。

第14条：在公有类中使用访问方法而非公有域

公有类永远都不应该暴露可变的域。但是，有时候会需要用包级私有的或者私有的嵌套类来暴露域，无论这个类是可变还是不可变的。

第15条：使可变性最小化

不可变类只是其实例不能被修改的类。每个实例中包含的所有信息都必须在创建该实例的时候就提供，并在对象的整个生命周期内固定不变。Java平台类库中包含许多不可变的类，其中有String、基本类型的包装类、BigInteger和BigDecimal。

为了使类成为不可变，要遵循下面五个规则：
1.不要提供任何会修改对象状态的方法。
2.保证类不会被扩展。
一般做法是使这个类成为final的。或者让类的所有构造器都变成私有的或者包级私有的，并添加公有的静态工厂来代替公有的构造器。
3.使所有的域都是final的。
4.使所有的域都成为私有的。
5.确保对于任何可变组件的互斥访问。

public class Complex {
    private final double re;
    private final double im;

    private Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    public static Complex valueOf(double re, double im) {
        return new Complex(re, im);
    }
}

第16条：复合优先于继承

继承是实现代码重用的有力手段，但它并非永远是完成这项工作的最佳工具。继承使得子类依赖于其超类中特定功能的实现细节。超类的实现有可能会随着发行版本的不同而有所改变，如果真的发生了变化，子类可能会遭到破坏，即使它的代码完全没有变化。因而，子类必须要跟着其超类的更新而演变，除非超类是专门为了扩展而设计的，并且具有很好的文档说明。

不用扩展现有的类，而是在新的类中增加一个私有域，它引用现有类的一个实例，这种设计被称做复合。它不依赖于现有类的实现细节，即使现有的类添加了新的方法，也不会影响新的类。

第17条：要么为继承而设计，并提供文档说明，要么就禁止继承

对于为了继承而设计的类，唯一的测试方法就是编写子类，必须在发布类之前先编写子类对类进行测试。

对于为了继承而设计的类，其构造器决不能调用可被覆盖的方法，无论是直接调用还是间接调用。如果违反了这条规则，很有可能导致程序失败。超类的构造器在子类的构造器之前运行，所以，子类中覆盖版本的方法将会在子类的构造器运行之前就先被调用。如果该覆盖版本的方法依赖于子类构造器所执行的任何初始化工作，该方法将不会如预期般地执行。

public class Super {
    private static final String TAG = "Super";

    public Super() {
        Log.d(TAG, "zwm, Super construct method");
        overrideMe(); //超类构造器调用了可被覆盖的方法
    }

    public void overrideMe() {
        Log.d(TAG, "zwm, Super overrideMe method");
    }
}

public class Sub extends Super {
    private static final String TAG = "Sub";
    private final Date date;

    public Sub() {
        Log.d(TAG, "zwm, Sub construct method");
        date = new Date();
    }

    @Override
    public void overrideMe() {
        Log.d(TAG, "zwm, Sub overrideMe method, date: " + date);
    }
}

//测试代码 
Sub sub = new Sub();
sub.overrideMe();

//输出Log
2019-03-14 17:29:55.298 zwm, Super construct method //超类构造器
2019-03-14 17:29:55.299 zwm, Sub overrideMe method, date: null //子类覆盖的方法
2019-03-14 17:29:55.299 zwm, Sub construct method //子类构造器
2019-03-14 17:29:55.356 zwm, Sub overrideMe method, date: Thu Mar 14 17:29:55 GMT+08:00 2019 //子类覆盖的方法

第18条：接口优于抽象类

抽象类允许包含某些方法的实现，但是接口则不允许，为了实现由抽象类定义的类型，类必须成为抽象类的一个子类。任何一个类，只要它定义了所有必要的方法，并且遵守通用约定，它就被允许实现一个接口，而不管这个类是处于类层次的哪个位置。因为Java只允许单继承，所以抽象类作为类型定义受到了极大的限制。

第19条：接口只用于定义类型

当类实现接口时，接口就充当可以引用这个类的实例的类型。因此，类实现了接口，就表明客户端可以对这个类的实例实施某些动作，为了任何其他目的而定义接口是不恰当的。

第20条：类层次优于标签类

标签类正是类层次的一种简单的仿效。为了将标签类转变成类层次，首先要为标签类中的每个方法都定义一个包含抽象方法的抽象类，这每个方法的行为都依赖于标签值。
标签类：

class Figure {
    enum Shape{RECTANGLE, CIRCLE};

    //Tag field
    final Shape shape;

    //Fields for RECTANGLE
    double length;
    double width;

    //Field for or CIRCLE
    double radius;

    //Construct for RECTANGLE
    Figure(double length, double width) {
        shape = Shape.RECTANGLE;
        this.length = length;
        this.width = width;
    }
    
    //Construct for CIRCLE
    Figure(double radius) {
        shape = Shape.CIRCLE;
        this.radius = radius;
    }

    double area() {
        switch (shape) {
            case RECTANGLE:
                return length * width;
            case CIRCLE:
                return Math.PI * (radius * radius);
            default:
                throw new AssertionError();
        }
    }
}

类层次：

abstract class Figure {
    abstract double area();
}

class Rectangle extends Figure {
    final double length;
    final double width;

    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    double area() {
        return length * width;
    }
}

class Circle extends Figure {
    final double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * (radius * radius);
    }
}

第21条：用函数对象表示策略

为了在Java中实现策略模式，需要声明一个接口来表示该策略，并且为每个具体策略声明一个实现了该接口的类。当一个具体策略只被使用一次时，通常使用匿名类来声明和实例化这个具体策略类。当一个具体策略是设计用来重复使用的时候，它的类通常就要被实现为私有的静态成员类，并通过公有的静态final域被导出，其类型为该策略接口。

第22条：优先考虑静态成员类

嵌套类是指被定义在另一个类的内部的类。嵌套类存在的目的应该只是为了它的外围类提供服务。如果嵌套类将来可能会用于其他的某个环境中，它就应该是顶层类。嵌套类有四种：静态成员类、非静态成员类、匿名类和局部类，除了第一种外，其他三种都被称为内部类。

静态成员类是最简单的一种嵌套类，最好把它看作是普通的类，只是碰巧被声明在另一个类的内部而已，它可以访问外围类的所有成员，包括那些声明为私有的成员。静态成员类是外围类的一个静态成员，与其他的静态成员一样，也遵守同样的可访问性规则。如果它被声明为私有的，它就只能在外围类的内部才可以被访问，等等。

非静态成员类的每个实例都隐含着与外围类的一个外围实例相关联。在非静态成员类的实例方法内部，可以调用外围实例上的方法，或者利用修饰过的this构造获得外围实例的引用。如果嵌套类的实例可以在它的外围类的实例之外独立存在，这个嵌套类就必须是静态成员类：在没有外围实例的情况下，要想创建非静态成员类的实例是不可能的。

匿名类没有名字，它不是外围类的一个成员，它并不与其他的成员一起被声明，而是在使用的同时被声明和实例化。匿名类可以出现在代码中任何允许存在表达式的地方。当且仅当匿名类出现在非静态的环境中时，它才有外围实例。但是即使它们出现在静态的环境中，也不可能拥有任何静态成员。

局部类是四种嵌套类中使用得最少的类。在任何可以声明局部变量的地方，都可以声明局部类，并且局部类也遵守同样的作用域规则。局部类与其他三种嵌套类中的每一种都有一些共同的属性。与成员类一样，局部类有名字，可以被重复地使用。与匿名类一样，只有当局部类是在非静态环境中定义的时候，才有外围实例，它们也不能包含静态成员。与匿名类一样，它们必须非常简短，以便不会影响到可读性。

第23条：请不要在新代码中使用原生态类型

声明中具有一个或者多个类型参数的类或者接口，就是泛型类或者接口。每个泛型都定义一个原生态类型，即不带任何实际类型参数的泛型名称，例如，与List相对应的原生态类型是List。

原生态类型List和参数化的类型List