使用Builder来构建一个对象

对于一个有着大量可选参数的类来说，我们在构建的时候一般有一下几种方式：

一：重叠构造模式：

比如Android中的View

 public class MyView extends View {
        public MyView(Context context) {
            super(context);
        }

        public MyView(Context context, AttributeSet attrs) {
            super(context, attrs);
        }

        public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);

        }

        public MyView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
            super(context, attrs, defStyleAttr, defStyleRes);

        }
    }

这种模式我们可以根据具体场景使用不同的构造方法来创建一个MyView对象。这种方式在参数个数较少时可行，但是当如果一个类参数过多并且有相同类型的参数，我们在创建对象的时候必须小心的检查具体调用的那一个构造方法，因为我们很容易颠倒参数的顺序，此时编译器也并不会报错，（比如在View的构建方法中我把defStyleAttr和defStyleRes两个方法的顺序颠倒）。

二：JavaBean模式，这应该算是我们最常用的一种形式

  public class User {
        private long uid;
        private String nick;
        private int gender;
        private int age;
        private String email;

        public long getUid() {
            return uid;
        }

        public void setUid(long uid) {
            this.uid = uid;
        }

        public String getNick() {
            return nick;
        }

        public void setNick(String nick) {
            this.nick = nick;
        }

        public int getGender() {
            return gender;
        }

        public void setGender(int gender) {
            this.gender = gender;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getEmail() {
            return email;
        }

        public void setEmail(String email) {
            this.email = email;
        }
    }

创建一个JavaBean对象：

    User user = new User();
    user.setAge(23);
    user.setGender(1);
    user.setNick("superman");
    user.setEmail("abc@xx.com");
    user.setUid(10001);

这种模式代码看上去逻辑很清晰，也解决了多个构造器的不足，但是它自身也有一个缺陷：在涉及到多线程的时候，我们在构造对象的过程中对象可能处于不一致的状态。

三：Builder构建模式（比如Android中的我们常用的AlertDialog）

 public class Desk {
        private int length;
        private int width;
        private int height;
        private int weight;
        private int color;
        private int price;

        public static class Builder {
            private int length = 0;
            private int width = 0;
            private int height = 0;
            private int weight = 0;
            private int color = 0;
            private int price = 0;

            public Builder length(int length) {
                this.length = length;
                return this;
            }

            public Builder width(int width) {
                this.width = width;
                return this;
            }

            public Builder height(int height) {
                this.height = height;
                return this;
            }

            public Builder weight(int weight) {
                this.weight = weight;
                return this;
            }

            public Builder color(int color) {
                this.color = color;
                return this;
            }

            public Builder price(int price) {
                this.price = price;
                return this;
            }

            public Desk build() {
                return new Desk(this);
            }
        }

        private Desk(Builder builder) {
            length = builder.length;
            width = builder.width;
            height = builder.height;
            weight = builder.weight;
            color = builder.color;
            price = builder.price;
        }
    }

构建一个对象：

Desk.Builder builder = new Desk.Builder();
    Desk desk = builder.length(2000)

            .width(1600)

            .height(1400)

            .weight(1000)

            .color(Color.BLACK)

            .price(500)

            .build();

这种方式兼具上面两种方式的优点并解决了两种方式各自的缺陷，并且代码看上去也很容易阅读。但是它自身也还是有一些缺陷的，在创建一个对象的时候必须先构建一个他的Builder对象，还是增加了一些开销。