Dieses Mal bringe ich Ihnen ein Tutorial zur Verwendung des Builder-Modus. Was sind die Vorsichtsmaßnahmen bei der Verwendung des Builder-Modus?
Übersicht
Builder-Muster: Trennen Sie die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass mit demselben Konstruktionsprozess unterschiedliche Darstellungen erstellt werden können.
Nutzungsszenarien
Die gleiche Methode, unterschiedliche Ausführungsreihenfolge, führt zu unterschiedlichen Ereignisergebnissen
Mehrere Komponenten oder Teile können zu einem Objekt zusammengefügt werden, aber die laufenden Ergebnisse sind unterschiedlich
Die Produktklasse ist sehr komplex, oder das Produkt unterschiedliche Aufrufreihenfolgen in der Klasse erzeugt unterschiedliche Effekte
Wenn die Initialisierung eines Objekts besonders komplex ist, z. B. viele Parameter, und viele Parameter Standardwerte haben
Die folgenden Verwendungen Ein Personenbeispiel zur Analyse der Verwendung des überlappenden Konstruktormusters, des JavaBeans-Musters und des Builder-Musters. Die Person-Klasse verfügt über zwei erforderliche Parameter (ID und Name) und 5 optionale Parameter (Alter, Geschlecht, Telefon, Adresse und Abstieg).
Überlappendes Konstruktormuster
In diesem Modus stellen Sie dem ersten Konstruktor nur erforderliche Parameter zur Verfügung, dem zweiten Konstruktor einen optionalen Parameter, dem dritten zwei optionale Parameter usw., der letzte Konstruktor enthält alle optionalen Parameter. Werfen wir einen Blick auf die Programmierimplementierung:
/ * 使用重叠构造器模式
*/
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;
}
}Nach dem Login kopieren
Wenn Sie im obigen Code eine Instanz erstellen möchten, verwenden Sie den Konstruktor mit der kürzesten Parameterliste, aber die Liste enthält alle festzulegenden Parameter:
Person person = new Persion(1, "李四", 20, "男", "18800000000", "China", "测试使用重叠构造器模式");
Nach dem Login kopieren
Überlappende Konstruktoren funktionieren, aber wenn es viele Parameter gibt, kann das Erstellen und Verwenden von Code schwierig zu schreiben und schwer zu lesen sein
JavaBeans-Muster
Verwenden Sie die Javabean-Schreibmethode, um eine Reihe von Setter-Methoden für Eigenschaften zu schreiben, Objekte zu generieren und dann die Setter-Methoden aufzurufen, um den Eigenschaften Werte zuzuweisen.
/ * 使用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;
}Nach dem Login kopieren
Dieses Muster gleicht die Mängel des überlappenden Konstruktormusters aus. Das Erstellen einer Instanz ist einfach und der resultierende Code ist leicht zu lesen:
Person person = new Person();
person.setId(1);
person.setName("李四");
person.setAge(20);
person.setSex("男");
person.setPhone("18800000000");
person.setAddress("China");
person.setDesc("测试使用JavaBeans模式");Nach dem Login kopieren
JavaBeans-Muster Da der Konstruktionsprozess in mehrere Aufrufe unterteilt ist, können sich JavaBeans während des Konstruktionsprozesses in einem inkonsistenten Zustand befinden. Klassen können die Konsistenz nicht einfach dadurch gewährleisten, dass sie die Gültigkeit von Konstruktorparametern überprüfen.
Builder-Muster
Builder-Muster können die Sicherheit wie überlappende Konstruktoren und die Lesbarkeit wie das JavaBean-Muster gewährleisten.
/**
* 使用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);
}
}
}Nach dem Login kopieren
Person ist unveränderlich und alle Standardparameterwerte werden an einem separaten Ort platziert. Die Setter-Methode des Builders gibt den Builder selbst zurück, sodass er in einer Kette aufgerufen werden kann. Das Folgende ist der Code, den der -Client verwenden kann:
Person person = new Person.Builder(1, "Zhang San")
.age(18).sex("Male "). desc("Test mit Builder-Modus").build();
Builder-Modus im Android-Quellcode
Vorteile:
Gute Kapselung, die Verwendung des Builder-Modus ermöglicht es dem Client, die Details der internen Zusammensetzung des nicht zu kennen Produkt
Builder ist unabhängig und einfach zu erweitern (kann abstrahiert werden - Schnittstelle, Abstrakte Klasse)
Nachteile:
Zusammenfassung: Builder-Muster wird normalerweise als Builder von Konfigurationsklassen verwendet, um die Konstruktion und Präsentation von zu trennen Konfiguration und isoliert außerdem die Konfiguration von der Zielklasse, um zu viele Setter-Methoden zu vermeiden.
Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!
Empfohlene Lektüre:
Wie JS Originalwerte und Referenzwerte speichert
Detaillierte Erläuterung allgemeiner Funktionen in JS
Das obige ist der detaillierte Inhalt vonTutorial zur Verwendung des Builder-Modus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
