Effective Java -- 01

Effective Java – 01

第一条 用静态工厂方法代替构造方法

所谓的静态工厂方法有别于设计模式中的工厂模式
类会提供一个公有的静态工厂方法，它只是返回类的实例的静态方法。
传统的的获取类实例的方法是使用构造器来获得，如：

    Date date = new Date();

而静态工厂方法则是通过类来调用，如：

    Calendar calendar = Calendar.getInstance();

相比传统的构造方法，静态工厂方法有一下优点：

• 它们有名字： 拥有名字的静态工厂方法，使得代码可读性更强，并且更加易于使用
• 不必每次调用它们的时候都创建一个新的对象。在实现单例模式时候，这个优势就很好的体现出来了 (单例模式：https://blog.csdn.net/weixin_43943642/article/details/114319180)
• 可以返回原返回类型的子类， 如

Class Person {
    public static Person getInstance(){
        return new Person();
        // 这里可以改为 return new Player() / Cooker()
    }
}
Class Player extends Person{
}
Class Cooker extends Person{
}

• 所返回的对象的类可以随着每次调用而发生变化，这取决于静态方法的参数值。
• 方法返回的对象所属的类，在编写包含该静态工厂方法类时可以不存在：这使得代码更好的解耦。

当然，这种实现方法也有缺点：

• 类如果不含公有的或者受保护的构造器，就不能被子类化。
• 程序员很难去发现它们

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

静态构造方法和构造器有个共同的局限性，它们都不能很好的处理大量的可选参数。在这种情况下，可以使用构建器的方法来实现。

构建器：构建器也是一种获得类对象的方法
（引用原书中的代码）

// 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;
    }
}

通过一个builder，将可选的参数放在里面实现。与构造器相比，builder的优势就在有：

• 它可以有多个可变参数，因为Bulder是利用单独的方法来设置每一个参数。
• 可以利用单个builder构建多个对象

builder的劣势在于：

• 为了创建对象，必须先创建他的构建器，这个可能带来性能的损耗
• 它的实现有点冗长

所以，只有当类的构造器或者静态工有多个参数，使用这个实现可以有不错的效果。