Introduction to the Builder pattern in Java design

This article mainly introduces the analysis of the overlapping constructor pattern and the usage scenarios of the Builder pattern from a Person example, and the use of JavaBeans pattern to make up for the shortcomings of the overlapping constructor pattern

##Overview

Builder pattern: Separate the construction of a complex object from its representation, so that the same construction process can create different representations.

Usage scenarios

• The same method, different execution order, produces different event results

• Multiple components or parts can be assembled into one object, but the running results are different

• The product class is very complex, or the product Different calling orders in the class have different effects

• When initializing an object is particularly complex, such as when there are many parameters and many parameters have default values

The following uses a Person example to analyze the use of the overlapping constructor pattern, JavaBeans pattern, and Builder pattern. The Person class has two required parameters (id and name) and 5 optional parameters (age, sex, phone, address and desc)

Overlapping constructor pattern

In this pattern, you provide the first constructor with only required parameters, the second with one optional parameter, the third with two optional parameters, and so on , the last constructor contains all optional parameters. Let’s take a look at its programming implementation:

/ * 使用重叠构造器模式
 */
public class Person {
 //必要参数
 private final int id;
 private final String name;
 //可选参数
 private final int age;
 private final String sex;
 private final String phone;
 private final String address;
 private final String desc;
 public Person(int id, String name) {
 this(id, name, 0);
 }
 public Person(int id, String name, int age) {
 this(id, name, age, "");
 }
 public Person(int id, String name, int age, String sex) {
 this(id, name, age, sex, "");
 }
 public Person(int id, String name, int age, String sex, String phone) {
 this(id, name, age, sex, phone, "");
 }
 public Person(int id, String name, int age, String sex, String phone, String address) {
 this(id, name, age, sex, phone, address, "");
 }
 public Person(int id, String name, int age, String sex, String phone, String address, String desc) {
 this.id = id;
 this.name = name;
 this.age = age;
 this.sex = sex;
 this.phone = phone;
 this.address = address;
 this.desc = desc;
 }
}

From the above code, when you want to create an instance, use the constructor with the shortest parameter list, But the list contains all the parameters to be set:

Person person = new Persion(1, "李四", 20, "男", "18800000000", "China", "测试使用重叠构造器模式");

Overlapping constructors work, but when there are many parameters, it will be difficult to create using code Write, and it is more difficult to read

JavaBeans pattern

Adopt Javabean writing method, write a bunch of setter methods for properties, and generate objects so that Then call the setter method to assign a value to the property.

/ * 使用JavaBeans模式
 */
public class Person {
 //必要参数
 private int id;
 private String name;
 //可选参数
 private int age;
 private String sex;
 private String phone;
 private String address;
 private String desc;
 public void setId(int id) {
 this.id = id;
 }
 public void setName(String name) {
 this.name = name;
 }
 public void setAge(int age) {
 this.age = age;
 }
 public void setSex(String sex) {
 this.sex = sex;
 }
 public void setPhone(String phone) {
 this.phone = phone;
 }
 public void setAddress(String address) {
 this.address = address;
 }
 public void setDesc(String desc) {
 this.desc = desc;
 }

This pattern makes up for the shortcomings of the overlapping constructor pattern. Creating an instance is easy, and the resulting code is easy to read: Within a few calls, a JavaBean may be in an inconsistent state during construction. Classes cannot ensure consistency simply by checking the validity of constructor parameters.

Builder pattern

The Builder pattern can ensure the safety like the overlapping constructor and the readability like the JavaBean pattern.

Person person = new Person();
person.setId(1);
person.setName("李四");
person.setAge(20);
person.setSex("男");
person.setPhone("18800000000");
person.setAddress("China");
person.setDesc("测试使用JavaBeans模式");

Person is immutable, and all default parameter values ​​are placed in a separate place. The builder's setter method returns the builder itself so that it can be called in a chain. The following is the client usage code: Person person = new Person.Builder(1, "Zhang San")

      .age(18).sex("Male").desc("Test using builder Mode").build();

Builder mode in Android source code

AlertDialog source code

Universal-Image-Loader Picture Library

OkHttp Request source code
• Advantages:

• Good encapsulation, using the builder pattern can make the client independent and easier than knowing the details of the internal composition of the product

Builder Extension (can be through abstraction - interface, abstract class)

• Disadvantages:

• will produce redundant Builders Objects and Director objects consume memory

Summary:

• Builder mode is usually used as the construction of configuration classes The constructor separates the construction and presentation of the configuration. It also isolates the configuration from the target class and avoids too many setter methods.

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future. Related articles: The problem that IE8 cannot be refreshed every time using ajax access

Ajax cache problem under IE8/IE9

Ajax cache problem and solution under IE8

The above is the detailed content of Introduction to the Builder pattern in Java design. For more information, please follow other related articles on the PHP Chinese website!