java 设计模式---创建对象

静态工厂，JavaBeans 模式，builder 模式，单例

1、静态工厂方法
入口Boolean创建对象，原码如下：
    public static Boolean valueOf(String s) {
        return parseBoolean(s) ? TRUE : FALSE;
    }

优势：
1）有方法名称，如果有多个构造器，可能不知道要调用那一个构造器，代码更容易阅读。
2）不必有每次调用时都创建一个新的对象，使用不可变类（如String）提供单例，可以进行重复利用（注意是不可变对象）
3）可以返回类型的任何子类型的对象。这样选择返回对象的类型就有了更大的灵活性。
这种灵活性应用：
i）如 Collections.emptyList() 是通过静态工厂方法返回一个 Collections 的一个不可实例化的内部私有类EmptyList。
如上例：这样会使API 变变得很简洁。这种技术适用于“接口框架”，接口为静态工厂方法提供了自然返回类型。返回的对象不仅可以是非公有的，只要是已声明返回类型子类型都是允许的，这样就提高了可维护性和性能，每次改版实现修改后，不影响调用。
ii）静态工厂返回的对象所属的类，在编写包含该静态工厂方法时可以不必存在。这种灵活的静态工厂方法构成了“服务提供者框架”（多个服务提供者实现一个服务，系统为服务提供者的客户端提供多个实现，并把他们从多个实现中解耦出来。如JDBC）的基础。


4）在创建参数化类型实例 的时候，代码变得简洁（jdk7 已经实现）。
如：Map<String,String> map = new HashMap<>(); 
这种写法调用了静态工厂方法：
public static <K, V> HashMap<K, V> newInstance(){
   return new HashMap<K, V>();
    }


缺点：
1）如果没有公用的构造器，就不能被子类化（被继承）。
2）和其它静态方法没有区别，在API中没有像构造器那样被标识出来。
3）不好扩展多个可选的参数


2、JavaBeans 模式
多个构造器参数时可以使用构造重叠方式（多个构造器，参数不同）来创建对象，但是这样代码不简洁，使用者不知道要用那一个构造器。可以使用JavaBeans 模式，调用一个无参构造器创建对象，然后调用setter 方法设置参数，创建实例容易，代码也容易阅读。
例如有一个类A，创建A对象
A a = new A();
a.set...();
a.set...();
a.set...();
JavaBeans 有一个严重缺点：构造的过程被分到了几个调用中，在构造过程中JavaBean 可能处于不一致的状态。试图使用处于不一致状态的对象，会失败，也会不好调试。对象是可变的，就会带来线程安全问题。


3、builder 模式
拥有构造重叠那样的安全性，也有JavaBeans 模式的好的可读性。
示例：
public class User {

    private String name;
    private int age;
    private String email;

    public static class Builder{
        private String name;
        private int age;
        private String email;


        public Builder(String name){
            this.name = name;
        }


        public Builder age(int age){
            this.age = age;
            return this;
        }
        public Builder email(String email){
            this.email = email;
            return this;
        }
        public User builder(){
            return new User(this);
        }
    }


    private User(Builder builder){
        this.name  =  builder.name;
        this.age = builder.age;
        this.email = builder.email;
    }


    public static void main(String[] args) {
        //创建User 对象
        User u = new User.Builder("name").age(10).email("email").builder();
    }
}
注意：对参数加强约束要在将参数从builder copy到对象中之后（User 私有构造方法中），而不是在builder() 方法中。
可以使用builder 这样方法就可以创建一个或者多个对象，builder可以在创建对象期间进行调整，也可以根据不同的对象而改变。

可以把builder 对象传递给方法，此方法可以创建一个或者多个对象，即：抽象工厂。


4、单例
1）1.5之前有两种方法实现，都是把构造器私有化，并导出公有的静态成员。如：
private static finale A a = new A();
public static A getInstance(){
return a;
}
private A(){}
如果对象A 是可序列化的，只声明是“implements Serializable ” 是不行的，那么就不再是一个Singleton。必须声明所有的实例域都是瞬时(transient，不能被序列化)的并且要提供一个 readResolve 方法：
private A readResolve(){
return a
}


2）1.5 之后可以编写包含单个元素的枚举，好处是jvm保证了对象被创建一次，并且提供了可序列化。代码：
public class SingletonEnum {


    private SingletonEnum(){}
    public static SingletonEnum getInstance(){
        return Singleton.INSTANCE.getInstance();
    }


    private static enum Singleton{
        INSTANCE;


        private SingletonEnum singleton;
        //JVM会保证此方法绝对只调用一次
        private Singleton(){
            singleton = new SingletonEnum();
        }
        public SingletonEnum getInstance(){
            return singleton;
        }
    }
}