This time I will bring you a tutorial on how to use the Builder mode. What are the precautions when using the Builder mode. The following is a practical case, let’s take a look.
Overview
Builder pattern: Separates 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;
}
}Copy after login
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", "测试使用重叠构造器模式");
Copy after login
Overlapping constructors work, but when there are many parameters, the creation and use code will be difficult to write and difficult to read
JavaBeans Pattern
Adopt Javabean writing method, write a bunch of setter methods for attributes, generate objects, and then call the setter method to assign values to the attributes.
/ * 使用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;
}Copy after login
This pattern makes up for the shortcomings of the overlapping constructor pattern. Creating instances is easy, and the resulting code is easy to read:
Person person = new Person();
person.setId(1);
person.setName("李四");
person.setAge(20);
person.setSex("男");
person.setPhone("18800000000");
person.setAddress("China");
person.setDesc("测试使用JavaBeans模式");Copy after login
JavaBeans Pattern Because the construction process is divided into several calls, JavaBeans may be in an inconsistent state during the construction process. 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.
/**
* 使用Builder模式
*/
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;
private Person(Builder builder) {
this.id = builder.id;
this.name = builder.name;
this.age = builder.age;
this.sex = builder.sex;
this.phone = builder.phone;
this.address = builder.address;
this.desc = builder.desc;
}
public static class Builder {
//必要参数
private final int id;
private final String name;
//可选参数
private int age;
private String sex;
private String phone;
private String address;
private String desc;
public Builder(int id, String name) {
this.id = id;
this.name = name;
}
public Builder age(int val) {
this.age = val;
return this;
}
public Builder sex(String val) {
this.sex = val;
return this;
}
public Builder phone(String val) {
this.phone = val;
return this;
}
public Builder address(String val) {
this.address = val;
return this;
}
public Builder desc(String val) {
this.desc = val;
return this;
}
public Person build() {
return new Person(this);
}
}
}Copy after login
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
Advantages:
Good encapsulation, using builder mode can prevent the client from knowing the details of the internal composition of the product
Builder is independent and easy to extend (can be abstracted - interface, Abstract class)
Disadvantages:
Summary: Builder pattern is usually used as a builder of configuration classes to separate the construction and presentation of configurations. , and also isolates the configuration from the target class to avoid too many setter methods.
# I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!
Recommended reading:
How does JS store original values and reference values
Detailed explanation of the use of common JS functions
The above is the detailed content of Builder mode usage tutorial. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
