Einführung in das Builder-Muster im Java-Design

In diesem Artikel werden hauptsächlich die Analyse des überlappenden Konstruktormusters und die Verwendungsszenarien des Builder-Musters anhand eines Personenbeispiels sowie die Verwendung des JavaBeans-Musters zum Ausgleich der Mängel des überlappenden Konstruktormusters vorgestellt

Ü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;
 }
}

Wenn Sie im obigen Code eine Instanz erstellen möchten, verwenden Sie den Konstruktor mit der kürzesten Parameterliste. Die Liste enthält jedoch alle festzulegenden Parameter:

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

Überlappende Konstruktoren funktionieren, aber wenn es viele Parameter gibt, wird es schwierig, Verwendungscode zu erstellen Schreiben , und es ist schwer zu lesen

JavaBeans-Muster

Übernehmen Sie die Javabean-Schreibmethode, schreiben Sie eine Reihe von Setter-Methoden für Eigenschaften und generieren Sie sie Objekte, damit Rufen Sie dann die Setter-Methode auf, um der Eigenschaft einen Wert 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;
 }

Dieses Muster gleicht die Mängel des überlappenden Konstruktormusters aus. Das Erstellen von Instanzen 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模式");

Das JavaBeans-Muster ist aufgrund der geteilt Konstruktionsprozess Innerhalb weniger Aufrufe kann sich die JavaBean während der Konstruktion 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);
 }
 }
}

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 Client-Nutzungscode:

Person person = new Person.Builder(1, "Zhang San")
      .age(18).sex("Male").desc("Test using builder Mode").build();

Builder-Modus im Android-Quellcode

• AlertDialog-Quellcode

• Universal-Image-Loader-Bildbibliothek

• OkHttps Quellcode anfordern

Vorteile:

• Gute Kapselung, die Verwendung des Builder-Musters kann den Kunden unabhängiger machen und einfacher machen, als die Details der internen Zusammensetzung des Produkts zu kennen

• Builder-unabhängige Erweiterung (kann abstrahiert werden – Schnittstelle, abstrakte Klasse)

Nachteile:

• erzeugt Redundanz Builder-Objekte und Director-Objekte verbrauchen Speicher

Zusammenfassung: Der Builder-Modus wird normalerweise als Konstruktion verwendet von Konfigurationsklassen Der Konstruktor trennt die Konstruktion und Darstellung der Konfiguration. Er isoliert auch die Konfiguration von der Zielklasse und vermeidet zu viele Setter-Methoden.

Ich habe das Obige für Sie zusammengestellt und hoffe, dass es Ihnen in Zukunft hilfreich sein wird.

Verwandte Artikel:

Das Problem, dass IE8 nicht jedes Mal mit Ajax-Zugriff aktualisiert werden kann

Ajax-Cache-Problem unter IE8/IE9

Ajax-Cache-Problem und Lösung unter IE8

Das obige ist der detaillierte Inhalt vonEinführung in das Builder-Muster im Java-Design. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!