Explorez l'application pratique des modèles de conception Java : environnements applicables de modèle singleton et de modèle d'usine

Compréhension approfondie des modèles de conception Java : les scénarios d'application du modèle singleton et du modèle d'usine nécessitent des exemples de code spécifiques

Les modèles de conception sont des méthodologies et des résumés d'expérience qui ont été pratiqués et largement utilisés dans le développement de logiciels pour résoudre des problèmes spécifiques. Dans le développement d'applications en langage Java, les modèles de conception couramment utilisés incluent le modèle singleton et le modèle d'usine. Cet article explorera en profondeur les scénarios d'application de ces deux modèles de conception et les illustrera avec des exemples de code spécifiques.

1. Modèle Singleton

Le modèle singleton est un modèle de conception créationnelle couramment utilisé. Il garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global. Les méthodes de mise en œuvre spécifiques incluent le style de l'homme paresseux et le style de l'homme affamé.

Le mode singleton paresseux convient aux situations où les ressources sont relativement importantes et fréquemment utilisées. Voici un exemple de code du modèle singleton paresseux :

public class LazySingleton {
    private static LazySingleton instance;
    
    private LazySingleton() {
        // 私有构造方法
    }
    
    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

Le modèle singleton affamé convient aux situations où les ressources sont relativement petites et seront utilisées tout le temps. Voici un exemple de code du modèle singleton de style Hungry :

public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();
    
    private EagerSingleton() {
        // 私有构造方法
    }
    
    public static EagerSingleton getInstance() {
        return instance;
    }
}

Les scénarios d'application du modèle singleton incluent, sans s'y limiter, les situations suivantes :

1. Objets qui doivent être créés et détruits fréquemment pour réduire l'utilisation des ressources. ;
2. Besoin d'être des objets Access globaux pour faciliter le partage de données ou l'appel de méthodes entre différents modules ;
3. Besoin de contrôler le nombre d'instances de la classe, telles que les pools de threads, les pools de connexions à la base de données, etc.

2. Modèle d'usine

Le modèle d'usine est un modèle de conception créationnelle couramment utilisé, qui encapsule le processus de création d'objet dans une classe d'usine et fournit une interface unifiée avec le monde extérieur. Les modèles d'usine comprennent le modèle d'usine ordinaire, le modèle de méthode d'usine et le modèle d'usine abstrait.

Le modèle d'usine ordinaire convient pour décider dynamiquement quelle instance spécifique créer en fonction des paramètres entrants. Voici un exemple de code d'un modèle d'usine courant :

public class ShapeFactory {
    public Shape createShape(String shapeType) {
        if ("circle".equals(shapeType)) {
            return new Circle();
        } else if ("rectangle".equals(shapeType)) {
            return new Rectangle();
        } else if ("triangle".equals(shapeType)) {
            return new Triangle();
        } else {
            return null;
        }
    }
}

Le modèle de méthode d'usine convient aux situations où la gamme de produits doit être élargie et chaque usine spécifique est responsable de la création d'un produit. Voici un exemple de code du modèle de méthode d'usine :

public interface ShapeFactory {
    Shape createShape();
}

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

public class TriangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Triangle();
    }
}

Le modèle d'usine abstrait convient aux situations dans lesquelles vous devez créer un ensemble d'objets produit associés ou dépendants. Voici un exemple de code du modèle d'usine abstrait :

public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

public class CircleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
    
    @Override
    public Color createColor() {
        return new Red();
    }
}

public class RectangleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
    
    @Override
    public Color createColor() {
        return new Blue();
    }
}

public class TriangleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Triangle();
    }
    
    @Override
    public Color createColor() {
        return new Green();
    }
}

Les scénarios d'application du modèle d'usine incluent, sans s'y limiter, les situations suivantes :

1. Situations dans lesquelles plusieurs objets similaires doivent être créés pour simplifier la logique du code ;
2. La création de produits spécifiques doit être masquée. Détails pour réduire le couplage.
3. Lorsqu'il est nécessaire d'élargir la gamme de produits pour faciliter la création de nouveaux produits.

Pour résumer, le modèle singleton et le modèle d'usine sont des modèles de conception couramment utilisés et sont largement utilisés dans le développement d'applications Java. Le modèle singleton convient aux scénarios où il est nécessaire de garantir qu'une classe n'a qu'une seule instance, tandis que le modèle usine convient aux scénarios où le processus de création d'un objet doit être encapsulé. Dans des applications spécifiques, les développeurs doivent choisir des modèles de conception appropriés en fonction des besoins d'amélioration de la qualité et de la maintenabilité du code.

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!