Introduction au modèle de générateur et au modèle de prototype dans les modèles de conception Java (exemple de code)

Le contenu de cet article est une introduction au modèle de constructeur et au modèle de prototype dans les modèles de conception Java (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. aide.

Préface

Dans l'article précédent, nous avons découvert le modèle d'usine et présenté le modèle d'usine simple, la méthode d'usine et le modèle d'usine abstrait. Cet article présente le modèle de générateur et le modèle de prototype, qui sont des modèles créatifs dans les modèles de conception.

Mode Constructeur

Introduction

Le mode Constructeur est un mode créatif. Le modèle de générateur utilise plusieurs objets simples pour créer un objet complexe étape par étape. Ce type de modèle de conception est un modèle de création qui offre une manière optimale de créer des objets.
Pour faire simple, il s'agit d'extraire une chose complexe et de fournir un simple appel au monde extérieur, qui peut créer différentes représentations dans le même processus de construction. Il est très similaire au mode usine, mais il accorde plus d’attention à l’assemblage des composants.

Voici un exemple pour illustrer.
La nourriture que nous mangeons chaque jour comprend des crêpes, des boîtes à lunch, des ramen, du lait de soja, du lait et des jus. Il est divisé en trois repas, petit-déjeuner, déjeuner et dîner. Les repas comprennent principalement de la nourriture (communément appelée riz) et des boissons (lait de soja, jus, etc.), puis nous pouvons prendre des crêpes et du lait de soja au petit-déjeuner, ainsi qu'un panier-repas. et du jus au déjeuner, afin que nous puissions savoir exactement quoi manger au petit-déjeuner et au déjeuner.

Nous définissons d’abord une catégorie d’aliments avec deux attributs, la nourriture et la boisson.

class Meal{
    private String food;
    private String drinks;
    
    public String getFood() {
        return food;
    }
    public void setFood(String food) {
        this.food = food;
    }
    
    public String getDrinks() {
        return drinks;
    }
    public void setDrinks(String drinks) {
        this.drinks = drinks;
    }
}

Lorsque nous définissons la nourriture, nous définissons une interface standard pour la nourriture. Que contient un morceau de nourriture ? En fait, cela signifie manger et boire.

interface IBuilderFood{
    void buildFood();
    void buildDrinks();
    Meal createMeal();
}

L'interface alimentaire définit un composant manger et boire, puis renvoie la nourriture dont nous avons besoin via la méthode createMeal().
Nous pouvons donc maintenant définir un petit-déjeuner et un déjeuner.
Exemple de code :

class Breakfast implements IBuilderFood{
    Meal meal;

    public Breakfast(){
        meal=new Meal();
    }
    
    @Override
    public void buildFood() {
        meal.setFood("煎饼");
    }

    @Override
    public void buildDrinks() {
        meal.setDrinks("豆浆");   
    }
    
    @Override
    public Meal createMeal() {
        return meal;
    }
}

class Lunch implements IBuilderFood{
    Meal meal;

    public Lunch(){
        meal=new Meal();
    }
    
    @Override
    public void buildFood() {
        meal.setFood("盒饭");
    }

    @Override
    public void buildDrinks() {
        meal.setDrinks("果汁");   
    }
    
    @Override
    public Meal createMeal() {
        return meal;
    }
}

Une fois la définition terminée, le processus de création du petit-déjeuner et du déjeuner est terminé. Mais ce n'est pas le mode constructeur. Il dispose d'un directeur principal, qui est utilisé pour créer des parties d'objets complexes, créer les pièces complètement ou les créer selon certaines règles. On peut donc ici créer un Directeur pour créer un repas. Quant au repas qui sera créé, il n'a pas besoin de le savoir, c'est l'appelant qui décide.

Ici, nous pouvons définir un restaurant et créer un repas. Le client décide quel repas créer.
Exemple de code :

class FoodStore{
    public Meal createBreakfast(IBuilderFood bf){
        bf.buildDrinks();
        bf.buildFood();
        return bf.createMeal();
    }
}

Après avoir créé ce Directeur, nous effectuerons le test d'appel.

Exemple de code :

public class BuilderTest {

    public static void main(String[] args) {
        FoodStore foodStore=new FoodStore();
        Meal meal=foodStore.createBreakfast(new Breakfast());
        Meal meal2=foodStore.createBreakfast(new Lunch());
        System.out.println("小明早上吃的是:"+meal.getFood()+",喝的饮料是:"+meal.getDrinks());
        System.out.println("小明中午吃的是:"+meal2.getFood()+",喝的饮料是:"+meal2.getDrinks()); 
    }

}

Résultat de sortie :

小明早上吃的是:煎饼,喝的饮料是:豆浆
小明中午吃的是:盒饭,喝的饮料是:果汁

Une brève introduction au modèle de générateur Le Le principe de fonctionnement peut être résumé par ces 4 points :

1. Builder : spécifie une interface abstraite qui stipule la création de composants requis pour le produit, et n'implique pas la création de composants d'objet spécifiques. .

2. ConcreteBuilder : Il est nécessaire d'implémenter l'interface Builder, et de créer différentes méthodes pour différentes logiques, et enfin de fournir une instance du produit.

3. Directeur : utilisé pour créer la partie d'objets complexes, terminer la création de cette partie ou la créer selon certaines règles.

4. Produit : Indique l'objet complexe construit.

Scénarios d'utilisation :
Applicable lorsque certains composants de base ne sont pas pratiques, mais que la combinaison change fréquemment. Par exemple, un coffret cadeau promotionnel pour un supermarché.

Avantages :

1. Builder est indépendant et facile à développer.

2. Rises détaillés faciles à contrôler.

Inconvénients

1. La structure interne est compliquée et pas facile à comprendre.

2. Les produits doivent directement avoir quelque chose en commun et leur portée doit être contrôlée.

Modèle de prototype

Le modèle de prototype est utilisé pour créer des objets répétés tout en garantissant les performances. Ce type de modèle de conception est un modèle de création qui offre une manière optimale de créer des objets.

De manière générale, lorsque l'on crée un objet, on le crée directement. Cependant, lorsque le coût de création de l'objet est élevé, la création répétée n'est pas rentable. Dans ce cas, on peut utiliser le mode prototype. .
Par exemple, nous avons tous envoyé des courriels. Pendant les festivals, nous envoyons généralement des bénédictions. La plupart de ces bénédictions sont les mêmes, à l'exception des noms. À ce stade, nous pouvons utiliser ce mode pour créer en conséquence.

Voici un exemple simple pour illustrer.
Xiao Ming et Xiao Hong fêtent leur anniversaire le même jour, nous devons donc leur envoyer des e-mails pour leur souhaiter bonne chance, mais parce que nous sommes paresseux, les mots de bénédiction sont les mêmes, à l'exception de leurs noms. À ce moment-là, nous pouvons d'abord terminer l'écriture de la bénédiction, puis cloner la bénédiction et enfin l'envoyer sous différents noms. Mais je vais rester simple ici, il suffit de l’imprimer.

Exemple de code :

public class PrototypeTest {

    public static void main(String[] args) {
        Mail mail=new Mail();
        mail.setMsg("生日快乐!");
        Mail mail2=(Mail) mail.clone();
        mail.setName("小明");
        mail2.setName("小红");
        System.out.println(mail.toString());
        System.out.println(mail2.toString());
    }
}

 class Mail implements Cloneable {
    private String name;
    private String msg;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }

    @Override
    public String toString() {
        return name + ":" + msg ;
    }
    
}

Résultat de sortie :

小明:生日快乐!
小红:生日快乐!

看完原型模式的创建，是不是感觉就是和Java中克隆即为类似呢?
实际上它的核心也就是克隆。
克隆有两种，浅克隆和深克隆，本文主要介绍的是浅克隆。
浅克隆:

在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。
简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。
实现Cloneable接口并重写Object类中的clone()方法；

深克隆:

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。

简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。
实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

使用场景:

1. 类初始化的时候需要消耗大量资源的时候；

2. 获取数据库连接繁琐的时候；

3. 一个对象，有很多个修改者的时候；

优点:
1.可以提升性能；

缺点:
1.因为必须实现Cloneable 接口，所以用起来可能不太方便。

相关推荐：

Java设计模式中工厂模式的介绍（代码示例）

Java设计模式是什么？Java设计模式中单例模式的介绍

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!