1.使类和成员的可访问性最小化

访问修饰符：

• private
• protected
• public

顶层的（非嵌套）类和接口，两种访问级别：

• 包级私有（package-private）
• public

成员（域、方法、嵌套类和嵌套接口）

• private：只有在声明该成员的顶层类内部才可以访问
• package-private：声明该成员的包内部的任何类都可以访问，是默认访问级别
• protected：在声明类和子类中可以访问
• public：任何地方可以访问

规则一：尽可能使每个类或者成员不被外界访问

如果一个包级私有的顶层类只是在某一个类的内部使用，就应该考虑使它成为唯一使用它的那个类的私有嵌套类。

规则二：如果方法覆盖了超类中第一个方法，子类中的访问级别就不允许低于超类的访问级别，确保任何可使用超类的地方都可以使用子类

规则三：接口中的所有方法都必须是public

规则四：实例域不能是公有的

如果域时非final的，或者是一个指向可变对象的final引用，那么一旦使这个域称为公有，就放弃了在这个域中的值进行限制的能力，也就放弃了这个域的不可变能力

包含公有可变域的类并不是线程安全的。

规则四：静态域不要是公有的（除了暴露静态常量）

要对外暴露静态域，必须是基本类型的值，或者是不可变对象。

长度非零的数组总是可变的，所以，类具有公有的静态final数组域，或者返回这种域的方法，总是不正确的。

以下错误：

public static final Tings[] VALUES = {...};

解决方案：公有数组私有化，并增加一个公有的不可变列表

private static final Tings[] VALUES = {...};
public static final List<Thing> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES));

或者：添加公有方法，返回私有数组的拷贝

private static final Tings[] VALUES = {...};
public static final Tings[] values() {
    return VALUES.clone;
}

2.在公有类中使用访问方法而非公有域

公有类永远不要暴露可变的类。

3.使可变性最小化

不可变类：其实例不能被修改的类。具体来说，每个实例中包含的所有信息都必须在创建该实例的时候就提供，并在对象的整个生命周期内固定不变。

Java 平台类库中的不可变类：String、基本类型的包装类、BigInteger、BigDecimal。不可变类对应配套的可变类：StringBuilder、BitSet。本应该是不可变，但却是可变的类：Date、Point。

不可变类的优点：

• 易于设计、实现和使用
• 不可变对象很简单、只有一种状态，即被创建时的状态
• 不容易出错、更加安全
• 线程安全，不要求同步，可以被自由的共享

不可变类的缺点：

• 在特定的情况下，存在潜在的性能问题，比如执行一个多步骤操作，每个步骤都会产生一个新的对，但除了最后的结果之外其他的对象最终都会被丢弃，就会有性能问题
• 所以应该使一些小的值对象成为不可变的
• 如果发生了性能问题，才应该为不可变的类提供公有的可变配套版

String对象不可变性的优缺点

• 字符串常量池的需要.
• 线程安全考虑
• 类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载
• 支持hash映射和缓存

使类成为不可变，遵循的规则：

• 不要提供任何会修改对象状态（属性）的方法
• 保证类不会被扩展，不会有子类，破坏该类的不可变行为
  • 如果类可以被继承会破坏类的不可变性机制，只要继承类覆盖父类的方法并且继承类可以改变成员变量值，那么一旦子类以父类的形式出现时，不能保证当前类是否可变。使所有的域都是final的。
• 使所有的域（属性）都是final
• 使所有的域都是private，防止客户端获得访问被域引用的可变对象的权限，并防止客户端直接修改这些对象
• 确保对于任何可变组件的互斥访问
  • 如果类具有指向可变对象的域，必须确保该类的客户端无法获得执行这些对象的引用
  • 在构造器中，永远不要用客户端提供的对象引用来初始化这样的域
  • 在访问方法中，也不要返回该对象引用
    • 普通对象，直接new 一个新的对象
    • 数组这类复杂对象，可使用 clone方法
  • 在构造器、访问方法和 readObject 方法中请使用保护性拷贝技术

通过构造器初始化所有成员，构造器初始化成员时，需要进行深浅拷贝，如果构造器传入的对象直接赋值给成员变量，还是可以通过对传入对象的修改进而导致改变内部变量的值

     public final class ImmutableDemo {  
         private final int[] myArray;  
         public ImmutableDemo(int[] array) {  
             this.myArray = array; // wrong  
         }  
     }
     这种方式不能保证不可变性，myArray和array指向同一块内存地址，用户可以在ImmutableDemo之外通过修改array对象的值来改变myArray内部的值。
     为了保证内部的值不被修改，可以采用深度copy来创建一个新内存保存传入的值。正确做法：
     public final class MyImmutableDemo {  
         private final int[] myArray;  
         public MyImmutableDemo(int[] array) {  
             this.myArray = array.clone();   
         }   
     }

不可变类的设计

对于访问方法，一般会返回一个新的实例，而不是修改这个实例，大多数不可变类使用这种模式，称为函数的做法。

不可变的类一般会提供一些静态工厂，它们把频繁被请求的实例缓存起来，使客户端之间可以共享这些实例，而不用创建新的实例，降低内存占用和垃圾回收成本。所有基本类型的包装类和BigInteger都有这样的静态工厂。

不可变对象可以被自由共享，所以根本不需要做任何拷贝，因为拷贝始终等于原始的对象，所以不需要为不可变的类提供clone方法或者拷贝构造器。

不仅可以共享不可变对象，也可以共享它们的内部信息。

不可变对象为其他对象提供了大量的构件。

有关序列化，如果让自己的不可变类实现序列化，就必须显式提供 readObject 或者 readResolve，否则反序列化可能会产生新的实例。

尽量使用不可变类，不要为每个get方法编写一个相应的set方法

举例

说明：这个类表示一个复数，加减运算都是返回一个新的实例，而不是在原来的实例上修改，称为函数的做法。

public final class Complex {
    private final double re;
    private final double im;
    
    public Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }
    
    public double realPart() {
        return re;
    }
    
    public double imaginaryPart() {
        return im;
    }
    
    public Complex add(Complex c) {
        return new Complex(re + c.re, im + c.im);
    }
    
    public Complex sub(Complex c) {
        return new Complex(re - c.re, im - c.im);
    }
}

将构造函数改为私有的，并添加静态工厂来替代公有构造器

public final 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);
    }
    ...
}

4.复合优先于继承

与方法调用不同的是，继承打破了封装性。子类依赖于其超类中特定功能的实现细节。所以子类必须要跟着其超类的更新而演变，导致子类很脆弱。

继承

• 继承打破了封装性
• 父类内部细节对于子类是可见的，继承的代码复用是一种白盒式代码复用，如果基类的实现发生改变，那么派生类也将随之改变，导致子类的行为不可预知
• 只有两者存在is-a的关系，才使用继承，如果不是，则使用组合

组合

• 在新的类中增加一个私有域，它引用现有类的一个实例
• 继承必须在编译器确定继承哪个类，组合可以采用面向接口编程，类的组合关系可以在运行期确定

5.要么为继承而设计，并提供文档说明，要么就禁止继承

类的文档必须精确描述覆盖每个方法所带来影响，也就是说，覆盖的方法必须说明其自用性

类必须通过某种形式提供适当的钩子（hook），以便能够进入它的内部工作流程中，这种形式可以是精心选择的受保护的方法

6.接口优于抽象类

接口优点

• 现有的类可以很容易被更新，以实现新的接口
• 接口是定义mixin（混合类型）的理想选择
  • 类不可能有一个以上的父类，类层次结构中也没有适当的地方插入mixin
• 接口允许我们构造非层次接口的类型框架

接口和抽象类区别

• 接口里不能定义静态方法；抽象类里可以定义静态方法。
• 接口里不包含构造器，抽象类可以包含构造器。抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
• 接口里不能包含初始化块，但抽象类可以包含初始化块。
• 接口里不包含已经提供实现的方法，只能包含抽象方法，；抽象类则完全可以包含普通方法。
• 接口里只能定义静态常量，不能定义其他变量。抽象类既可以定义普通变量，也可以定义静态常量。
• 注意：在接口里定义的接口、枚举类、变量默认都采用public static两个修饰符，不管定义时是否指定这两个修饰符，系统都会自动使用public static对他们进行修饰，同理，在抽象类里，会默认使用public abstract修饰方法。

骨架实现类

虽然接口不允许包含默认实现，但是，可通过对你导出的每个重要接口都提供一个抽象的骨架实现类，把接口和抽象类的优点结合起来。接口的作用仍然是定义类型，但是骨架实现类接管了所有与接口实现相关的工作

在选择抽象类和接口时，并不是二选一的答案，或干脆枪毙掉抽象类。其实，你可以把接口和抽象类的优点结合起来，对于你希望导出（对外提供）的每一个重要接口都提供一个抽象类（骨架实现类）。接口的作用仍然是定义类型，骨架实现类负责所有与接口实现相关的工作

7.接口只用于定义类型

当类实现接口时，接口就充当可以引用这个类的实例的类型。类实现了接口，就表明客户端对这个类的实例实施某些动作。

接口应该只被用来定义类型，不应该被用来导出常量

接口用于导出常量

常量接口：只包含静态的final域。导出常量的一种形式。常量接口模式是对接口的不良使用。

缺点：

• 实现常量接口，会导致把这样的实现细节泄漏到该类导出的API中
• 如果非final类实现了常量接口，它的所有子类的命名空间也会被接口中的常量所”污染“。

常量接口的例子

public interface PhysicalConstants {
    static final double AAA = 0.1;
    static final double BBB = 0.1;
    static final double CCC = 0.1;
}

导出常量的合理方案：

• 使用枚举类型导出
• 使用不可实例化的工具类导出

工具类的方式：

public class PhysicalConstants {
    private PhysicalConstants() {};
    static final double AAA = 0.1;
    static final double BBB = 0.1;
    static final double CCC = 0.1;
}

8.类层次优于标签类

有时，可能遇到带有两种甚至更多风格的实例的类，并包含表示实例风格的标签域。

下面例子，此类表示圆形或者矩形

demo

标签类缺点：

• 充斥样板代码，包括枚举声明、标签域以及条件语句
• 破坏了可读性
• 内存占用也增加
• 实例承担着其他风格不相关的域

解决方案：子类化

定义一个包含抽象方法的抽象类，公共方法定义在抽象类

demo

9.用函数对象表示策略（策略模式）

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

举例：比较器函数代表一种为元素排序的策略。

Java没有提供函数指针，可以用对象引用实现此功能。

比较器实例

StringLengthComparator 实例就是用于字符串长度比较的具体策略。

StringLengthComparator 是无状态的（没有域），所以单例比较合适。

class StringLengthComparator implements Comparator<String> {
    private StringLengthComparator() {};
    private static final StringLengthComparator INSTANCE = new StringLengthComparator();
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
}

定义一个策略接口

public interface Comparator<T> {
    public int compare(T t1, T t2);
}

使用比较策略

Arrays.sort(stringArray, new Comparator(String)(){
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
})

10.优先考虑静态成员类

嵌套类：被定义在另一个类的内部的类。嵌套类存在的目的只是为了它的外围类提供服务。

嵌套类包括：

• 静态成员类（内部类）
• 非静态成员类（内部类）
• 匿名类
• 局部类

静态成员类

最简单的一种嵌套类，可看作是普通的类，可以访问外围类的所有成员，包括私有成员。

公有静态成员类常见用法，是作为公有的辅助类，仅当与它的外部类一起使用时才有意义。

私有静态成员类常见用法，用来代表外围类所代表的对象的组件。例如，Map实例，Map的内部都有一个Entry对象，对应于Map的key和value。

非静态成员类（内部类）

必须和外围类的一个实例相关联，可以用this来访问

常见用法：Adapter

如果成员类不要求访问外围实例，就要声明成静态成员类，不然每个实例都会包含一个额外的指向外围对象的引用