图片来自网络

对象的创建和销毁

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

类除了可以通过构造器来实例化之外，还可以通过静态的工厂方法（newInstance）

优势

1. 他们有名称

比如一个Apple类，你想获得一个红苹果和绿苹果的实例，Apple.newRedInstance()和Apple.newGreenInstance()比Apple(red)和Apple(green)看上去要更能突出他们之间的区别

2. 不必在每次调用的时候都创建一个新对象

class Apple{
     private Apple apple;    
     private Apple();
    newInstance(){
           return apple ==null ?new Apple : apple;
    }
}

单例模式的简单写法，单例模式的有各种好处，比如不用重复创建对象，可以用==来代替equals方法等等之类的我就不多说神马了。

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

这种时候我们在返回对象的类时就有了更大的灵活性，甚至于我们在编写该静态方法的时候这个类是可以不存在的。书上管这个叫服务提供者框架(Service Provicer Framework)。 例如JDBC 的API就是一个很好的例子。Connection是他的服务接口，DriverManager.registerDriver 是提供者的API，DriverManager.getConnection是服务访问的API，Driver就是服务提供者接口。适配器模式也是这种框架的一种变体。

// 服务提供者框架简易Demo
// 服务类的接口
public interface Service{
    // 具体需要实现的服务方法
}
// 服务提供者的接口
public interface Provider{
    Service newService();
}
// Service 注册和调用的类
public class Services{
    private Services();    // 防止实例化
    // Service 名字跟服务的Map
    private static final Map<String,Provider> providers = new ConcurrentHashMap<String , Provider>( );
    public static final String DEFAULT_PROVIDER_NAME = "<dev>";
    // 服务提供者注册的API
    public static void registerDefaultProvider(Provider p){
         registerProvider(DEFAULT_PROVIDER_NAME ,p); 
    }
    public static void registerDefaultProvider(String name ,Provider p){
         providers.put(name ,p); 
    }
//  获取服务接口
public static Service newInstance(){
    return newInstance(DEFAULT_PROVIDER_NAME);
}
publicstatic Service newInstance(String name ){
    Provider p = providers.get(name);
    if(p== null)
            throw new IllegalArgumentException("这个服务者没有注册");
    return p.newService();
}

适配器模式的简单例子。

4. 实例化参数类型时更简单

比如

    Map<String,List<String>> m = new HashMap<String,List<String>>();

随着参数越来越长，越来越复杂，代码就越来越丑了。
这个时候如果有这个方法

public static <K,V> HashMap<K,V> newInstance(){
    return new HashMap<K,V>();
}

那我们只要这样写就好了Map<String,List<String>> m = HshMap.newInstance();,代码就简洁了好多。目前（jdk 1.8.0_73）官方并没有实现这样的方法，可以放在自己的工具类中体现自己的逼格。

缺点

• 如果类不含public 或者protect 的构造方法则不能被实例化
  是缺点也是优点，关键看你肿么用吧。。。
• 不能在java doc中有什么体现。
  java doc认识构造方法，会重点标识出来，但是静态方法不会，所以用起来找api会麻烦。

第二条 当构造方法有多个可选参数的时候考虑用构造器

当实例化一个类有很多可选参数的时候，有如下的几种方法

创建多个构造器

优点： 能用
缺点：写起来容易错，参数的顺序啊神马的记起来容易错

用JavaBean 的getter 和setter 模式

优点：写的时候不容易出错
缺点：线程不安全

使用构造器模式

优点：使代码简单好些，而且看上去很有逼格
缺点：增加了一些开销
拿一个苹果类举例

class Apple{
    private String color;
    private String size;
    private String weight;
    private String price;
    
    public static class Builder{
        private String color;
        private String size;
        private String weight;
        
        public Builder color(String color){
            this.color = color;
            return this;
        }
        public Builder size(String size){
            this.size = size;
            return this;
        }
        public Builder weight(String weight){
            this.weight = weight;
            return this;
        }
        public Apple bulid(){
            return new Apple(this);
        }
    }
    
    private Apple(Builder bulider){
        this.color = bulider.color;
        this.size = bulider.size;
        this.weight = bulider.weight;
    };
}

然后就可以通过下面的方式来实例化一个苹果

Apple apple = new Apple.Builder().color("red").size("100").weight("100").bulid(); 

这样逼格满满的代码就出来了。在可选参数很多的时候选择这种写法是种很不错的选择。

第三条 单例的三种写法和注意事项

原翻译 使用枚举增强类的单例属性

单例模式的各种好处就不说，这条讲了单例的三种写法和注意事项

写法一

class Apple{
    public static Apple INSTANCE = new Apple();
    // someThing
    private Apple(){
    };
} 

写法二

class Apple{
    private static Apple INSTANCE = new Apple();
    // someThing
    private Apple(){
    };
    public static Apple newInstance(){
        return INSTANCE;
    }
} 

*** 注意事项 ***

1. AccessibleObject.setAccessible 可以通过反射调用私有的构造方法。在构造器加上第二次实例化抛异常的逻辑可以防范这种攻击。

2. 如果单例的类为了可序列化而继承了 Serializable 接口，那么为了防止类在反序列化的时候被偷偷的实例化，可以在类中加入如下代码

    private Object readResolve() {
        return INSTANCE;
    } 

写法三 使用枚举实现单例

enum Apple{
    INSTANCE;
}

• 优点
  简单明了，不仅能防止因为反序列而重新创建对象，又是线程安全的，简直逼格满满
• 缺点
  这是JDK1.5之后的新特性，这么写可能有些人会看不懂（怪我咯j╮(╯_╰)╭）。

第4条 通过私有化构造器使单例类更加单例

有些工具类我们可能不希望它被实例化，可以使用如下代码

public class AppleUtils{
    private AppleUtils(){
        throw new AssertionError();
    }
} 

这样一来，AppleUtils（和他的子类）就不能被实例化了。

第5条 避免创建不必要的对象

对象么能少创建就少创建，这条主要讲了如何更少的创建对象

• 比如不要写 String s = new String("Don't do this"); 这样的代码(因为这里创建了两个String 对象)
• 对于有静态工厂方法和构造器的不可变类，尽量使用静态工厂方法
• 对象能重用的就尽量重用
  明显能重用那肯定是要重用的，有些不明显的比如像Map接口的KeySet方法每次返回的Set实例这种也是考虑用一个对象减少实例化的
• 使用基本数据类型时防止程序自从装箱
  例如如下代码

Long sum =0L;
for (int i = 0; i < Integer.MAX_VALUE; i++) {
sum +=i;
}
System.out.println(sum); 

这段代码在我机器上的运行时间为

Long 的运行时间

但是如果把Long sum 换成long sum

long 的运行时间

可以看到时间从6886ms变成了781ms,效率大大的优化了。

第六条 避免内存泄露的几点建议

原翻译:消除过期的对象引用

• 警惕自己管理内存的类
• 警惕让不用的对象留在缓存中
  wakHashMap 和LinkedHashMap 可以一定程度解决这个问题
• 警惕监听器和其他回调
  最好只保存他们的若引用，例如只将他们保存成WeakHashMap中的键

第七条 避免使用终结（finalizer）方法

• finalizer方法并不能保证被及时的执行
  从对象不可到达到它的finalizer方法被执行，其中的这段时间是不好估计的。
• finalizer方法并不能保证被正确的执行
  不同的JVM实现中finalizer的效果是不同的。
• finalizer方法并不能保证被执行
  当一个程序被终止的时候，某些已经无法访问的对象上的终结方法没有被执行也是有可能的。
• finalizer 有一个非常严重的性能损失
  Effective Java的作者说他试了下，真的有很严重的性能损失。
  所以最好有显示的终止方法，向InputStream、OutputStream``的close方法，java.util.Timer中的cancel```方法之类的。

总结

这一章主要讲了对象的创建和销毁时候需要注意的一些点。有些代码真的是使人豁然开朗，瞬间逼格满满。期待第二章的学习，Fighting~