《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。。。。