清单1：使类和成员的可访问性最小化
这个原则，其实就是我们常说的“封装”，也是软件设计的基本原则之一。
类之间，隐藏内部数据和实现细节，只通过API进行通信。
信息隐藏的好处：模块可独立开发测试优化，并行开发，降低大型系统的风险等。
清单2： final不一定不可变
很多人容易把final跟不可变划上等号，但是，final限制的只是引用不可变，
也就是说，一个final数组，你不能把它指向另一个数组，但是你可以修改数组的元素。
看下面这段代码，TestFinal提供了一个final的数组，然后以为final了就无敌了，自以为是的加了public修饰符
public class TestFinal {
public static final String[] VALUES = {"1","2","3"};
}
接着，Test类来调用了
public class Test {
public static void main(String[] args) {
String[] arr = {"1","2","3"};
// TestFinal.VALUES = arr; // cannot be assigned because of final
TestFinal.VALUES[0] = "11"; // but u can change the sub item
}
}
它修改了TestFinal的final数组的角标为0的元素，而且还修改成功了。
那么，要怎样做，才能既对外提供这个数组的访问权限，又让外界不能修改数组的子元素呢？
一种方法是使用Collections.unmodifiableList暴露一个不可修改的List
public class TestFinal {
private static final String[] PRIVATE_VALUES = {"1","2","3"};
public static final List<String> VALUES = Collections.unmodifiableList(Arrays.asList(PRIVATE_VALUES));
}
这样外界在修改的时候会抛出java.lang.UnsupportedOperationException
另一种方法是提供一个get方法，返回一个clone对象
public class TestFinal {
private static final String[] PRIVATE_VALUES = {"1","2","3"};
public String[] getValues()
{
return PRIVATE_VALUES.clone();
}
}
清单3 使类的可变性最小化
不可变类是实例不能被修改的类，这种类具有天然的线程安全特性，不需要同步，也不需要进行保护性拷贝。
设计一个不可变类的四条规则：
1） 不提供任何修改对象状态的方法
2） 把类声明为final，保证不被扩展
3） 把所有的域都声明为final，这样可以更清楚的表明意图
4） 使所有域都是private
不可变类唯一的缺点就是，对于每个不同的值都需要创建一个单独的对象，性能差。比如String，因此，对于不可变类，我们一般都会提供一个可变配套类，比如String对应的可变配套类就是StringBuilder和StringBuffer。
清单4 复合优先于继承
继承有一个天然的缺陷，子类依赖于超类的特定功能，和清单1所提到的封装相违背，而包装模式的复合，则可以解决这个问题。
清单5 要么为继承而设计，并提供文档说明，要么就禁止继承
既然继承有清单4所讲的缺陷，那么就不要轻易提供继承的能力。
禁止继承的两种方法：
1）把类声明为final
2）构造器私有或者包级私有
清单6 构造器不能调用可被覆盖的方法
为直观说明这个原则，下面举个例子：
有个类违法了这个原则：
public class Super {
// Broken - constructor invokes an overridable method
public Super() {
overrideMe();
}
public void overrideMe() {
}
}
然后下面这个子类覆盖了overrideMe方法：
import java.util.*;
public final class Sub extends Super {
private final Date date; // Blank final, set by constructor
Sub() {
date = new Date();
}
// Overriding method invoked by superclass constructor
@Override public void overrideMe() {
System.out.println(date);
}
public static void main(String[] args) {
Sub sub = new Sub();
sub.overrideMe();
}
}
由于超类的构造器会在子类构造器之前执行，因此会有两次打印，而且第一次打印的是null，因为父类构造器先于子类构造器执行，如果这里调用了date的方法，那么就会导致NullPointer异常。
清单7 类层次优于标签类
在面向过程的编码中，常常会使用标签，当标签等于某个值的时候，是一种代码逻辑，当标签等于另一个值的时候，执行另一套逻辑。
而这种标签的方式，在面向对象的Java里面，都应该被抽取为超类和子类。
举个简单的例子，下面是一个标签类，可以表示圆形或者矩形：
class Figure {
enum Shape { RECTANGLE, CIRCLE };
// Tag field - the shape of this figure
final Shape shape;
// These fields are used only if shape is RECTANGLE
double length;
double width;
// This field is used only if shape is CIRCLE
double radius;
// Constructor for circle
Figure(double radius) {
shape = Shape.CIRCLE;
this.radius = radius;
}
// Constructor for rectangle
Figure(double length, double width) {
shape = Shape.RECTANGLE;
this.length = length;
this.width = width;
}
double area() {
switch(shape) {
case RECTANGLE:
return length * width;
case CIRCLE:
return Math.PI * (radius * radius);
default:
throw new AssertionError();
}
}
}
可以看到，代码里充斥这各种枚举和条件语句，一旦要新增类型，修改时很容易遗漏。
用Java面向对象的思维，改造一下：
// Class hierarchy replacement for a tagged class
abstract class Figure {
abstract double area();
}
class Circle extends Figure {
final double radius;
Circle(double radius) { this.radius = radius; }
double area() { return Math.PI * (radius * radius); }
}
class Rectangle extends Figure {
final double length;
final double width;
Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
double area() { return length * width; }
}
改造后的代码，简单清楚，而且很容易扩展。
清单8 接口优先于抽象类
接口和抽象类都可以让实现或者继承它们的类，具有某些特定的函数模板。
和抽象类相比，接口具有以下优势：
1）一个类可以实现多个接口，但是却只能继承一个类。想一下，假如Comparable接口当初被设计为一个抽象类了，那由于Java的单继承的特点，我们很多客户端的代码就都无法做到Comparable了。
2）接口可以实现非层次结构的类型框架
清单7里讲到了层次结构，但是，我们常常会遇到非层次结构的类型，比如歌唱家和作曲家，这俩就是非层次结构的，因为有的歌唱家本身也是作曲家。这就只能用接口来实现了，因为Java给了接口一个特权——接口可以多继承。
你可以这样做：
public interface Singer {
String sing();
}
public interface Singer {
String sing();
}
public interface SingerSongwriter extends Singer, SongWriter {
}
当然，抽象类也有它的优势：
1）抽象类可以包含一些方法的具体实现，接口不行。 如果使用接口，一般都要提供一个骨架实现类，客户端可以去继承这个骨架实现类来使用方法的具体实现。
2）抽象类的演变比接口的演变要容易得多。抽象类可以随意添加新的方法，但是接口不行，一旦接口新增了方法，之前实现了这个接口的类就无法编译通过。
总结一下：
接口通常是定义允许多个实现的类型的最佳选择。但是，当演进的容易性被更重视，或者说，后续修改的可能性更大时，这种情况下，就应该使用抽象类。
以上八条清单，希望可以给你带来帮助。
