Quelles sont les manières d'utiliser le mode constructeur ?

Cette fois, je vais vous montrer comment utiliser le mode constructeur, et quelles sont les précautions lors de l'utilisation du mode constructeur. Ce qui suit est un cas pratique, jetons un coup d'œil.

Vue d'ensemble

Modèle de constructeur : Séparez la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.

Scénarios d'utilisation

• La même méthode, un ordre d'exécution différent, produisent des résultats d'événement différents

• Plusieurs composants ou pièces peuvent être assemblés en un seul objet, mais les résultats d'exécution sont différents

• La classe de produits est très complexe, ou le produit Différentes commandes d'appel dans le la classe produit différents effets

• Lorsque l'initialisation d'un objet est particulièrement complexe, comme de nombreux paramètres, et de nombreux paramètres ont des valeurs par défaut

Les utilisations suivantes un exemple Person pour analyser l'utilisation du modèle de constructeur qui se chevauche, du modèle JavaBeans et du modèle Builder. La classe Person a deux paramètres obligatoires (id et nom) et 5 paramètres facultatifs (âge, sexe, téléphone, adresse et description)

Modèle de constructeur qui se chevauchent

Dans ce mode, vous fournissez au premier constructeur uniquement les paramètres requis, au deuxième constructeur un paramètre facultatif, au troisième deux paramètres facultatifs, et ainsi de suite, le dernier constructeur contient tous les paramètres facultatifs. Jetons un coup d'œil à son implémentation de programmation :

/ * 使用重叠构造器模式
 */
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;
 }
}

À partir du code ci-dessus, lorsque vous souhaitez créer une instance, utilisez le constructeur avec la liste de paramètres la plus courte, mais la liste contient tous les paramètres à définir Paramètres :

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

Les constructeurs qui se chevauchent fonctionnent, mais lorsqu'il y a de nombreux paramètres, la création et l'utilisation de code seront difficiles à écrire et difficiles à lire

Modèle JavaBeans

/ * 使用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;
 }

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

Modèle JavaBeans Étant donné que le processus de construction est divisé en plusieurs appels, les JavaBeans peuvent être dans un état incohérent pendant le processus de construction. Les classes ne peuvent pas garantir la cohérence simplement en vérifiant la validité des paramètres du constructeur. Modèle de constructeur

/**
 * 使用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);
 }
 }
}

La personne est immuable et toutes les valeurs des paramètres par défaut sont placées à un endroit séparé. La méthode setter du constructeur renvoie le constructeur lui-même afin qu'il puisse être appelé dans une chaîne. Voici le code que le

 :

    .age(18).sex("Male "). desc("Test en utilisant le mode constructeur").build();Mode constructeur dans le code source Android

Code source d'AlertDialog
Bibliothèque d'images Universal-Image-Loader
Code source de la requête OkHttp

• Bonne encapsulation, l'utilisation du

  mode constructeur
permet au client de ne pas connaître les détails de la composition interne du produit

• Builder est indépendant et facile à étendre (peut être abstrait - interface,

  Classe abstraite
)

• générera des objets Builder et des objets Director redondants, consommant de la mémoire

Résumé : Le modèle de constructeur est généralement utilisé comme générateur de classes de configuration pour séparer la construction et la présentation de configuration. et isole également la configuration de la classe cible pour éviter trop de méthodes de définition.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture recommandée :

Explication détaillée des étapes d'interaction avec les données de la mise en œuvre d'Axios

Explication détaillée du cas d'utilisation du composant angulaire

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!