《Effect Java》学习笔记1———创建和销毁对象

第二章 创建和销毁对象

1.考虑用静态工厂方法代替构造器

　　四大优势：

　　　　i. 有名称

　　　　ii. 不必在每次调用它们的时候都创建一个新的对象；

　　　   iii. 可以返回原返回类型的任何子类型的对象；

　　　　　　JDBC（Java Database Connectivity）

　　　　　　服务提供者框架（Service Provider Framework）

　　　　　　　　　服务接口、提供者注册API、服务访问API、服务提供者接口（负责创建其服务实现的实例）；

　　　　iv. 在创建参数类型实例的对象，它们使代码变得更加简洁

　　下面是一个Boolean（基本类型boolean的包装类）的基本实现：

public static Boolean valueOf(boolean b) {
      return b ? Boolean.TURE : Boolean.FALSE;  
}

 　　美中不足处：

　　　 ① 类如果不会含公有的或者受保护的构造器，就不能被子类化

　　　 ② 与其他的静态方法实际上没有区别

　　常用的名称：

　　　　valueOf　　of　　getInstance　　newInstance　　getType　　newType

2.遇到多个构造器参数时，要考虑使用构造器

　　　　class.newInstance 破坏了编译时的异常检查（Builder弥补不足）

　　　　总：如果类的构造器或静态工厂中具有多个参数，考虑用Builder模式；

　　下面是示例：

//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 carbohydrate = 0;
        private int sodium = 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 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;
    }
}

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

　　单元素的枚举类型已经成为实现Singleton的最佳方法

　　　　实现方式一：公有静态成员是一个final域

//Singleton with public final field
public class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() {......}  
  
    public void leaveTheBuilding() {......}  
}

　　　　实现方式二:  公有的成员是个静态工厂方法

//Singleton with static factory
public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    private Elvis() {......}
    public static Elvis getInstance() { return INSTANCE;}

    public void leaveTheBuilding() {......}  
}

　　　　实现方式三(最佳实现方式)：

　　　　　　　　只需编写一个包含单个元素的枚举类型；

　　　　　　这种方法在功能上与公有域方法相近，当是它更加简洁，无偿地提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。

//Enum singleton - the preferred approach
public enum Elvis {
    INSTANCE;
    
    public void leaveTheBuilding() {......}      
}

　　　　　　

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

　　throw new AssertionError(); （构造器内）

　　可在上面加入注释，便于理解，如下：

　　　　suppress default coustructor for noninstratiability.

    示例如下：

//Noinstantialbe utility class
public class UtilityClass {
    //Suppress default constructor for noninstiability
    private UtilityClass() {
         throw new AssertionError();
    }  
    ......  //Remainder omitted
}    

5.避免创建不必要的对象

　　update。。。。