设计模式-------构建者（Builder pattem）

使用场景：

• 当一个类超过4个构造函数，而且这些参数是可选的就考虑构造者模式。 

传统方法：  

1. 写多个构造器来实现 

public class Computer {
     ...
    public Computer(String cpu, String ram) {
        this(cpu, ram, 0);
    }
    public Computer(String cpu, String ram, int usbCount) {
        this(cpu, ram, usbCount, "罗技键盘");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard) {
        this(cpu, ram, usbCount, keyboard, "三星显示器");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard, String display) {
        this.cpu = cpu;
        this.ram = ram;
        this.usbCount = usbCount;
        this.keyboard = keyboard;
        this.display = display;
    }
}

2.使用Javabean 模式实现

第一种主要是使用及阅读不方便。你可以想象一下，当你要调用一个类的构造函数时，你首先要决定使用哪一个，然后里面又是一堆参数，如果这些参数的类型很多又都一样，你还要搞清楚这些参数的含义，很容易就传混了。。。那酸爽谁用谁知道。

第二种方式在构建过程中对象的状态容易发生变化，造成错误。因为那个类中的属性是分步设置的，所以就容易出错

建造者如何实现

1. 在User类中创建一个静态内部类Builder,然后将主类中的参数复制到Builder内部类中
2. 在User类中创建一个private的构造器,参数类型为Builder
3. 在Builder类中创建一个public的构造器，参数为User类必填的参数
4. 在Builder类中创建设置函数，对User哪些参数进行赋值，返回值为Builder类型的实例
5. 在Builder类中创建一个build()方法，在其中构建User的实例并返回。

public class User {

    private List<Trip> trips = new ArrayList<Trip>();
    private List<User> friends = new ArrayList<User>();

    private User(Builder builder) {
        this.trips = builder.trips;
        this.friends = builder.friends;
    }

    public List<User> getFriends() {
        return friends;
    }

    public void addFriend(User user) {
        friends.add(user);
    }

    public void addTrip(Trip trip) {
        trips.add(trip);
    }

    public List<Trip> trips() {
        return trips;
    }

    public boolean isFriend(User loggedUser) {
        return getFriends().stream().anyMatch(friend -> friend.equals(loggedUser));
    }

    public static class Builder{
        private List<Trip> trips = new ArrayList<Trip>();
        private List<User> friends = new ArrayList<User>();
        
        //为了项目方便，改写成的这个形式来替代构造器
        public Builder aUser() {
            this.trips = new ArrayList<>();
            this.friends = new ArrayList<>();
            return this;
        }
        //原来的构造器
        public Builder(List<Trip> trips,List<User> friends) {
            this.trips = trips;
            this.friends = friends;
        }
        public Builder writeFriends(User... friends){
            this.friends = Arrays.asList(friends);
            return this;
        }
        public Builder writeTrips(Trip ... trips){
            this.trips = Arrays.asList(trips);
            return this;
        }
        public User build(){
            return new User(this);
        }
    }
}

 如何使用：

        User user = new User.Builder()
                .aUser()
                .writeFriends()
                .writeTrips()
                .build();

使用静态内部类的原因：

如果不使用静态的话：

需要new两个空间内存，浪费空间

/**
 * 使用p普通内部类 创建Builder
 * @param args
 */
public static void main(String[] args) {
    Course.CourseBuilder courseBuilder = new Course().new CourseBuilder();
    Course course = courseBuilder.build();
    System.out.println();
}