学习笔记@Effective Java
文章内容来源于Joshua Bloch - Effective Java (3rd) - 2018.chm一书
第二章
创建和注销对象
Item 1考虑用静态工厂方法代替构造函数
静态工厂方法不是设计模式中的工厂模式[ static factory method is not the same as the Factory Method pattern from Design Patterns]
public static Boolean valueOf(boolean b) {
return b ? Boolean.TRUE : Boolean.FALSE;
}
优点一：静态工厂方法不同于构造函数——它有名称
一个具有好的名字的静态工厂方法将会使代码更加易读
优点二：静态工厂方法不同于构造函数——它不需要每次被调用都创建一个新的对象
避免创建多余的对象
优点三：静态工厂方法不同于构造函数——它可以返回所返回对象的子类
从Java8开始，接口不能包含静态方法的限制就被取消了
优点四：静态工厂方法作为一个输入参数的方法，返回的对象类型能随着调用而变化
可以灵活的在子类中控制返回类型
优点五：静态工厂方法当类包含方法被编写时，返回的对象类型不必存在
这种灵活的静态工厂方法构成了服务提供者框架的基础，比如Java数据库连接API（JDBC）
---------分割线---------
缺点一：只提供静态工厂方法的主要限制是类中没有公有或保护构造函数不能被子类（继承）
缺点二：程序员难发现
所以你可以遵守如下命名规则来吸引注意
from—带一个参数并且返回对应类型实例的转换方法
Date d = Date.from(instant);
of—带多个参数并且返回包含此些类型实例的聚合方法
Set<Rank> faceCards = EnumSet.of(JACK, QUEEN, KING);
valueOf—更详细的替代from和of方法
BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);
instance or getInstance—返回一个被它的参数描述的实例，但是不能有相同值
StackWalker luke = StackWalker.getInstance(options);
create or newInstance—像instance或getInstance那样创建或新建实例，但该方法保证每次调用都返回一个新实例
Object newArray = Array.newInstance(classObject, arrayLen);
getType—像getInstance，但是工厂方法在不同的类，类型是工厂方法返回对象的类型
FileStore fs = Files.getFileStore(path);
newType—像newInstance，但是工厂方法在不同的类，类型是工厂方法返回对象的类型
BufferedReader br = Files.newBufferedReader(path);
type—getType 和 newType的简洁替代方法
List<Complaint> litany = Collections.list(legacyLitany);
总之，静态工厂方法和公共构造函数都有它们的用途，了解它们的相对优点是值得的。通常，静态工厂更可取，因此避免条件反射使用公共构造函数而不首先考虑静态工厂方法
Item 2考虑一个生成器模式当面对很多构造参数时
静态工厂方法和构造函数都有一个限制：它们不能很好地扩展到大量可选参数
传统方式
// Telescoping constructor pattern - does not scale well!
public class NutritionFacts {
private final int servingSize; // (mL) required
private final int servings; // (per container) required
private final int calories; // (per serving) optional
private final int fat; // (g/serving) optional
private final int sodium; // (mg/serving) optional
private final int carbohydrate; // (g/serving) optional
public NutritionFacts(int servingSize, int servings) {
this(servingSize, servings, 0);
}
public NutritionFacts(int servingSize, int servings,
int calories) {
this(servingSize, servings, calories, 0);
}
public NutritionFacts(int servingSize, int servings,
int calories, int fat) {
this(servingSize, servings, calories, fat, 0);
}
public NutritionFacts(int servingSize, int servings,
int calories, int fat, int sodium) {
this(servingSize, servings, calories, fat, sodium, 0);
}
public NutritionFacts(int servingSize, int servings,
int calories, int fat, int sodium, int carbohydrate) {
this.servingSize = servingSize;
this.servings = servings;
this.calories = calories;
this.fat = fat;
this.sodium = sodium;
this.carbohydrate = carbohydrate;
}
}
//当你想创造实例，你使用包含所有你需要的参数最少的构造函数
NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
通常这种构造函数被调用需要一些你不想要的参数，但是你无论如何也必须传一个参数，上述例子中给fat传值0
总之，重叠构造函数模式是可行的，但是当有许多参数时，编写客户端（实现API方法的称为client客户端）代码是困难的，而且读取它更困难
面对很多选择的参数第二种替代方法是JavaBeans 模式，这种模式里你调用一个无参构造函数创建对象，然后调用setter 方法设置需要的参数，并且每个参数都是有用的
// JavaBeans Pattern - allows inconsistency, mandates mutability
public class NutritionFacts {
// Parameters initialized to default values (if any)
private int servingSize = -1; // Required; no default value
private int servings = -1; // Required; no default value
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public NutritionFacts() { }
// Setters
public void setServingSize(int val) { servingSize = val; }
public void setServings(int val) { servings = val; }
public void setCalories(int val) { calories = val; }
public void setFat(int val) { fat = val; }
public void setSodium(int val) { sodium = val; }
public void setCarbohydrate(int val) { carbohydrate = val; }
}
//这种模式没有重叠构造函数模式的缺点，创建实例很容易
//即使有点冗长，也很容易阅读生成的代码
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);
不幸的是，JavaBeans模式有其自身的严重缺点。由于构造被拆分为多个调用，一个JavaBean在构造过程中可能处于不一致的状态。
该类不能仅通过检查构造函数参数的有效性来强制实现一致性
一个相关的缺点是JavaBeans模式排除了使一个类不可变的可能性并且需要程序员额外付出来确保线程安全
幸运的是，有第三种替代方式组合了重叠构造函数模式的安全JavaBeans模式的可读
他是生成器模式[the Builder pattern]
客户端不直接生成所需的对象，而是使用所有必需的参数调用构造函数（或静态工厂方法），并获取一个builder对象
然后，客户端调用builder对象上类似setter的方法来设置每个需要的可选参数
最后，客户机调用无参数构建方法来生成对象，该对象通常是不可变的
生成器通常是它构建的类的静态成员类
例如：
// Builder Pattern
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public static class Builder {
// Required parameters
private final int servingSize;
private final int servings;
// Optional parameters - initialized to default values
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public Builder(int servingSize, int servings) {
this.servingSize = servingSize;
this.servings = servings;
}
public Builder calories(int val)
{ calories = val; return this; }
public Builder fat(int val)
{ fat = val; return this; }
public Builder sodium(int val)
{ sodium = val; return this; }
public Builder carbohydrate(int val)
{ carbohydrate = val; return this; }
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
}
//NutritionFacts类是不可变的，所有参数的默认值都在一个地方。
//生成器的setter方法返回生成器本身，以便可以链接调用，从而生成流畅的API。
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
.calories(100).sodium(35).carbohydrate(27).build();
生成器模式非常适合于类层次结构
使用生成器的并行层次结构，每个生成器嵌套在相应的类中抽象类有抽象生成器；实体类有实体生成器
例如，考虑一个抽象类，它在层次结构的底层表示pizza的不同种类
// Builder pattern for class hierarchies
public abstract class Pizza {
public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
final Set<Topping> toppings;
abstract static class Builder<T extends Builder<T>> {
EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
public T addTopping(Topping topping) {
toppings.add(Objects.requireNonNull(topping));
return self();
}
abstract Pizza build();
// Subclasses must override this method to return "this"
protected abstract T self();
}
Pizza(Builder<?> builder) {
toppings = builder.toppings.clone(); // See Item 50
}
}
为了简洁起见，下面显示的示例客户机代码假定对枚举常量进行静态导入：
NyPizza pizza = new NyPizza.Builder(SMALL).addTopping(SAUSAGE).addTopping(ONION).build();
Calzone calzone = new Calzone.Builder().addTopping(HAM).sauceInside().build();
生成器模式非常灵活。单个生成器可以重复用于构建多个对象。生成器的参数可以在调用build方法之间进行调整，以多元化所创建的对象。一个生成器可以在创建对象时自动填充某些字段，例如每次创建对象时都会增加的序列号。
生成器模式也有缺点。为了创建对象，必须首先创建其生成器。尽管创建此生成器的成本在实践中不太可能引起注意，但在性能关键的情况下，这可能是一个问题
还有，生成器模式比重叠构造函数模式更冗长，因此只有当有足够的参数使其值得使用时才应该使用它，比如说四个或更多参数
总之，当的构造函数或静态工厂方法的设计类将有几个以上的参数时，特别是当许多参数是可选的或类型相同时，生成器模式模式是一个很好的选择。与重叠构造函数模式相比，生成器更易于读取和编写客户端代码，而且生成器比JavaBeans更安全。