【Builder】Java类设计过程参数太多时怎么办

2018/02/10 17:36
阅读数 116

Java类设计过程中,如果类的构造器或者静态工厂中具有多个参数,并且其中有大量的可选参数时,我们应该怎么办?

1.Telescoping Constructor模式(重叠构造器)

我们首先想到的方法肯定是传统的构造器

/**
 * Created by itbird on 2017/3/23
 */

public class Person {
    private String name;
    private String sex;
    private int year;

    public Person(String name, String sex, int year) {
        this.name = name;
        this.sex = sex;
        this.year = year;
    }
}

但是设计以及使用过程中我们发现以下几点问题:
(1)属性参数逐渐变多时
属性参数逐渐变多时,由于要对之前的代码做兼容,所以不可以直接在现有构造器后面追加属性,只能不断新增构造器

/**
 * Created by itbird on 2017/3/23
 */

public class Person {
    private String name;
    private String sex;
    private int year;
    private String city;

    public Person(String name, String sex, int year) {
        this.name = name;
        this.sex = sex;
        this.year = year;
    }

    public Person(String name, String sex, int year, String city) {
        this.name = name;
        this.sex = sex;
        this.year = year;
        this.city = city;
    }
}

(2)属性参数中有大量的可选参数

/**
 * Created by itbird on 2017/3/23
 */

public class Person {
    private String name;
    private String sex;
    private int year;
    private String city;
    private String state;
    private boolean isFemale;
    private boolean isEmployed;
    private boolean isHomewOwner;

    public Person(String name, String sex, int year) {
        this.name = name;
        this.sex = sex;
        this.year = year;
    }

    public Person(String name, String sex, int year, String city) {
        this.name = name;
        this.sex = sex;
        this.year = year;
        this.city = city;
    }

    public Person(String name, String sex, int year, String city, String newState,
                  boolean newIsFemale, boolean newIsEmployed, boolean newIsHomeOwner) {
        this.name = name;
        this.sex = sex;
        this.year = year;
        this.city = city;
        this.state = newState;
        this.isFemale = newIsFemale;
        this.isEmployed = newIsEmployed;
        this.isHomewOwner = newIsHomeOwner;
    }
}

显而易见,这样写的类构造器虽然无可厚非,但是当有许多参数的时候,客户端代码会很难编写,并且难以阅读。如果读者想知道那些值是什么意思,必须很仔细的数着这些参数来探个究竟。

2.JavaBeans模式

在这种模式下,调用一个无参构造器来创建对象,然后调用setter方法来设置每个必要的参数,以及每个相关的可选参数。

/**
 * Created by itbird on 2017/3/23
 */

public class Person {
    private String name;
    private String sex;
    private int year;
    private String city;
    private String state;
    private boolean isFemale;
    private boolean isEmployed;
    private boolean isHomewOwner;

    public Person() {
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public boolean isFemale() {
        return isFemale;
    }

    public void setFemale(boolean female) {
        isFemale = female;
    }

    public boolean isEmployed() {
        return isEmployed;
    }

    public void setEmployed(boolean employed) {
        isEmployed = employed;
    }

    public boolean isHomewOwner() {
        return isHomewOwner;
    }

    public void setHomewOwner(boolean homewOwner) {
        isHomewOwner = homewOwner;
    }
}

这种模式弥补重叠构造器模式的不足。说的明白一点,就是创建实例很容易,这样产生的代码读起来也很容易:

 Person person = new Person();
 person.setCity("重庆");
 person.setYear(12);
 person.setSex("男");
 person.setName("itbird");

遗憾的是,JavaBeans模式自身有着很严重的缺点。因为构造过程被分到几个调用中,在构造过程中JavaBean可能处于非一致的状态。JavaBeans模式阻止了把类做成不可变的可能,这就需要程序员付出额外的努力来确保他的线程安全。

3.Builder模式

/**
 * Created by itbird on 2017/3/23
 */

public class Person {
    private String name;
    private String sex;
    private int year;
    private String city;
    private String state;
    private boolean isFemale;
    private boolean isEmployed;
    private boolean isHomewOwner;

    public Person() {
    }

    public static class PersonBuilder {
        // 必要参数
        private String name;
        // 可选参数
        private String sex;
        private int year;
        private String city;
        private String state;
        private boolean isFemale;
        private boolean isEmployed;
        private boolean isHomewOwner;

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

        public PersonBuilder setSex(String sex) {
            this.sex = sex;
            return this;
        }

        public PersonBuilder setYear(int year) {
            this.year = year;
            return this;
        }

        public PersonBuilder setCity(String city) {
            this.city = city;
            return this;
        }

        public PersonBuilder setState(String state) {
            this.state = state;
            return this;
        }

        public PersonBuilder setFemale(boolean female) {
            isFemale = female;
            return this;
        }

        public PersonBuilder setEmployed(boolean employed) {
            isEmployed = employed;
            return this;
        }

        public PersonBuilder setHomewOwner(boolean homewOwner) {
            isHomewOwner = homewOwner;
            return this;
        }

        public Person build() {
            Person person = new Person();
            person.name = name;
            person.sex = sex;
            person.city = city;
            person.isEmployed = isEmployed;
            person.isFemale = isFemale;
            person.isHomewOwner = isHomewOwner;
            person.state = state;
            person.year = year;
            return person;
        }
    }
}

调用的实例:

 Person person = new Person.PersonBuilder("itbird")
                    .setCity("重庆").setYear(15).build();

显然,使用Builder模式解决了上诉的难题,达到了“以不变(Builder)应万变(参数)”的目的。

总结:

Java类设计过程中,如果类的构造器或者静态工厂中具有多个参数,并且其中有大量的可选参数时,我们应该考虑使用构建器,与传统的重叠构造器模式相比,使用Builder模式的代码更易于阅读和编写,有更好的可扩展性,同时构建器也比JavaBeans更加安全。
从最后的实例演练中我们知道,在实际开发过程中,我们往往是需要几种模式混合使用,这样才能在保证代码健壮性、可读性的同时,去保证代码的可扩展性以及线程安全性等,这才是代码设计开发过程中真正的“以不变应万变”之道。



作者:itbird01
链接:https://www.jianshu.com/p/a34bebd9767f
來源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

展开阅读全文
加载中

作者的其它热门文章

打赏
1
9 收藏
分享
打赏
1 评论
9 收藏
1
分享
返回顶部
顶部