先看3段代码，看了以后就差不多明白了

public class Book {
	private final String name; //required
	private final String id;   //required
	private final String value;
	private final String vendor;
	private final String vendor2;
	
	public Book(String name, String id) {
		this(name, id, "");
	}

	public Book(String name, String id, String value) {
		this(name, id, value, "");
	}

	public Book(String name, String id, String value, String vendor) {
		this(name, id, value, vendor, "");
	}

	public Book(String name, String id, String value, String vendor, String vendor2) {
		this.name = name;
		this.id = id;
		this.value = value;
		this.vendor = vendor;
		this.vendor2 = vendor2;
	}
}

 以上是一般我们用的构造器，当参数比较多的时候，在使用中就比较麻烦 ，一个是难读，另一个就是传我们不需要的数据，比如：

Book b = new Book("aaa","1","0.0","abc","");

 其实book的vendor2 我们并不需要，但是为了构建对象而不得不传这个值，所以这种方式看上去就有点奇怪。

在来看第2种：

public class Book {
    private String name; //required
    private String id;   //required
    private String value;
    private String vendor;
    private String vendor2;
    
    public Book() {
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public void setVendor(String vendor) {
        this.vendor = vendor;
    }

    public void setVendor2(String vendor2) {
        this.vendor2 = vendor2;
    }

}

这种是利用javabean 来创建对象：

Book b = new Book();
	b.setName("aaa");
	b.setId("12");
	b.setValue("0.0");
	b.setVendor("ccc");

 这种方式也有缺陷 首先类无法通过构造器参数来保证类的一致性，通俗说就是只能靠人力来保证类的统一，保证不少某个参数。而且这种类线程不安全。

第3种才是重点，当类的参数比较多的时候：

public class Book {
    private String name; // required
    private String id; // required
    private String value;
    private String vendor;
    private String vendor2;

    public Book(Builder b) {
        this.name = b.name;
        this.id = b.id;
        this.value = b.value;
        this.vendor = b.vendor;
        this.vendor2 = b.vendor2;
    }

    public static class Builder {
        private String name; // required
        private String id; // required
        private String value = "";
        private String vendor = "";
        private String vendor2 = "";

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

        public Builder value(String value) {
            this.value = value;
            return this;
        }

        public Builder vendor(String vendor) {
            this.vendor = vendor;
            return this;
        }

        public Builder vendor2(String vendor2) {
            this.vendor2 = vendor2;
            return this;
        }
        
        public Book build(){
            return new Book(this);
        }
    }
}

 这种写法 可能写的时候代码比较冗长，但是使用起来的效果不错：

Book b = new Book.Builder("aaa", "12").value("0.0").vendor("bbb").build();

 这种写法好处很多，首先使用清晰，其次对参数有约束性，builder 可以有多个可变参数，而且一个builder 可以创建多个对象，添加参数比较容易（当项目需要添加参数的时候这种写法很容易添加，构造器的话就要添加新的构造器来为新的属性初始化）

当然有好处也有坏处，这种写法代码冗长，而且在很重视性能的地方 这种方法还是会比构造器需要更多的开销。

总之，如果类的构造器或静态工厂中具有多个参数，设计这个类的时候，Builder模式就是不错的选择。