illustrer

Enregistrez la méthode d'écriture d'apprentissage du modèle de conception-modèle de poids mouche. La version du JDK utilisée est la version 1.8.

Poids mouche(poids mouche)

Intention : utiliser la technologie de partage pour prendre en charge efficacement un grand nombre d'objets à granularité fine.
Structure :
Insérer la description de l'image ici

dans:

Flyweight décrit une interface à travers laquelle Flyweight peut accepter et agir sur des états externes.
ConcreteFlyweight implémente l'interface Flyweight et ajoute de l'espace de stockage pour l'état interne (le cas échéant). Les objets ConcreteFlyweight doivent être partageables. L'état qu'il stocke doit être interne, c'est-à-dire qu'il doit être indépendant de la scène de l'objet ConcreteFlyweight.
Toutes les sous-classes Flyweight n'ont pas besoin d'être partagées. L'interface Flyweight rend le partage possible, mais elle ne force pas le partage. À un certain niveau de la structure des objets Flyweight, les objets UnsharedConcreteFlyweight ont généralement des objets ConcreteFlyweight comme nœuds enfants.
FlyweightFactory crée et gère les objets Flyweight ; assurant un partage raisonnable des Flyweights, lorsque l'utilisateur demande un Flyweight, l'objet FlyweightFactory fournit une instance créée ou crée une instance si elle n'existe pas.
Le client maintient une référence à Flyweight : calcule ou stocke l'état externe d'un ou plusieurs Flyweights.

applicabilité :

Une application utilise un grand nombre d'objets.
Cela est entièrement dû à l’utilisation d’un grand nombre d’objets, ce qui entraîne une surcharge de stockage importante.
La majeure partie de l'état d'un objet peut être rendue externe.
Si vous supprimez l'état externe des objets, vous pouvez remplacer de nombreux groupes d'objets par relativement peu d'objets partagés.
L'application ne repose pas sur l'identification d'objets. Étant donné que les objets Flyweight peuvent être partagés, les tests d'identité renverront vrai pour des objets conceptuellement distincts.

scènes à utiliser :

Un système possède un grand nombre d’objets identiques ou similaires, ce qui entraîne une consommation de mémoire importante.
La majeure partie de l’état d’un objet peut être externalisée et ces états externes peuvent être transmis à l’objet.
Lorsque vous utilisez le mode poids mouche, vous devez conserver un pool de poids mouche pour stocker les objets poids mouche, ce qui nécessite une certaine quantité de ressources système. Par conséquent, il vaut la peine d'utiliser le mode poids mouche uniquement lorsque vous devez réutiliser l'objet poids mouche plusieurs fois.

Table des matières

Insérer la description de l'image ici

Exemple de diagramme de classes de modèle de poids mouche

Insérer la description de l'image ici

Utilisez ce diagramme de classes UML pour implémenter l’exemple de modèle de poids mouche.

cours de graphisme abstrait

package com.example.deesign_patterns.flyweight;

//抽象享元角色
public abstract class AbstractBox {
    
    

    //获取图形的方法
    public abstract String getShape();

    //显示图形及颜色
    public void display(String color){
    
    
        System.out.println("方块形状："+getShape()+",方块颜色："+color);
    }
}

IGraphiques

package com.example.deesign_patterns.flyweight;

//I图形类(具体享元角色)
public class IBox extends AbstractBox{
    
    

    @Override
    public String getShape() {
    
    
        return "I";
    }
}

Classe LGraphics

package com.example.deesign_patterns.flyweight;

//L图形类(具体享元角色)
public class LBox extends AbstractBox{
    
    

    @Override
    public String getShape() {
    
    
        return "L";
    }
}

Classe OGraphics

package com.example.deesign_patterns.flyweight;

//O图形类(具体享元角色)
public class OBox extends AbstractBox{
    
    

    @Override
    public String getShape() {
    
    
        return "O";
    }
}

Classe d'usine

package com.example.deesign_patterns.flyweight;

import java.util.HashMap;

//工厂类，将该类设计为单例
public class BoxFactory {
    
    

    private HashMap<String,AbstractBox> map;

    //使用单例模式-饿汉式静态成员变量方式
    private static BoxFactory factory=new BoxFactory();

    //在构造方法中进行初始化操作
    public BoxFactory() {
    
    
        map=new HashMap<String,AbstractBox>();
        map.put("I",new IBox());
        map.put("L",new LBox());
        map.put("O",new OBox());
    }

    //提供一个方法获取该工厂类对象
    public static BoxFactory getInstance(){
    
    
        return factory;
    }

    //根据名称获取图形对象
    public AbstractBox getShape(String name){
    
    
        return map.get(name);
    }
}

Classe d'essai

package com.example.deesign_patterns.flyweight;

//测试类
public class Client {
    
    

    public static void main(String[] args) {
    
    
        //获取I图形对象
        AbstractBox box1 = BoxFactory.getInstance().getShape("I");
        box1.display("灰色");
        //获取L图形对象
        AbstractBox box2 = BoxFactory.getInstance().getShape("L");
        box2.display("绿色");
        //获取O图形对象
        AbstractBox box3 = BoxFactory.getInstance().getShape("O");
        box3.display("灰色");
        //获取O图形对象
        AbstractBox box4 = BoxFactory.getInstance().getShape("O");
        box4.display("红色");
        System.out.println("两次获取到的O图形对象是否是同一个对象："+(box3==box4));
    }
}