Comment implémenter le modèle de méthode d'usine Java

1. Quel est le modèle de méthode d'usine ?

Factory method pattern : également appelé modèle de constructeur virtuel ou modèle de fabrique polymorphe, il appartient au modèle de création de classe.

Dans le modèle de méthode factory, la classe parent factory est chargée de définir l'interface publique pour créer des objets produit, tandis que la sous-classe factory est responsable de la génération d'objets produit spécifiques. consiste à convertir la classe de produit en L'opération d'instanciation est reportée à la sous-classe d'usine, c'est-à-dire que la sous-classe d'usine est utilisée pour déterminer quelle classe de produit spécifique doit être instanciée.

Nous savons que la division du travail dans les usines réelles devient de plus en plus détaillée et professionnelle. . Divers produits sont fabriqués dans des usines spécialisées, faisant complètement adieu à l'ère de l'économie paysanne autosuffisante, ce qui raccourcit considérablement le cycle de production des produits et améliore l'efficacité de la production. Le modèle de méthode d'usine satisfait non seulement au principe d'ouverture et de fermeture, mais hérite également des avantages du modèle d'usine simple.

Exemple :

Dans l'usine de Coca-Cola dans l'article sur le modèle d'usine simple, car il n'y a qu'une seule classe d'usine, tout produit doit Soyez dans Modifier et ajuster dans cette classe, et le modèle de méthode d'usine consiste à avoir plusieurs usines, chaque usine produit un produit. Si nous devons ajouter de nouveaux produits, nous pouvons directement créer une nouvelle usine, et il n'est pas nécessaire d'en ajouter de nouveaux. ceux à l'intérieur d'autres usines. Allez le modifier pour qu'il soit conforme au principe d'ouverture et de fermeture.

2. Avantages et inconvénients du modèle de méthode d'usine

Avantages :

• #🎜🎜 # Les utilisateurs n'ont besoin que de connaître le nom de l'usine spécifique pour obtenir le produit souhaité, et n'ont pas besoin de connaître le processus de création spécifique du produit. Écrivez une autre classe d'usine correspondante

.
• Un cadre de découplage typique. Conformément à la loi de Demeter, au principe d'inversion de dépendance et au principe de substitution de Richter, les modules de haut niveau n'ont besoin d'accéder qu'à la classe abstraite du produit sans prendre en compte les autres classes d'implémentation

• #🎜🎜 # Inconvénients :

Il est facile d'avoir trop de cours, ce qui augmente la complexité

#🎜🎜 #augmenter Cela réduit la difficulté d'abstraction et de compréhension du système

• Les produits abstraits ne peuvent produire qu'un seul produit. Cet inconvénient peut être résolu en utilisant
Abstract Factory Pattern#. 🎜🎜#(Modèle d'usine abstrait dans le prochain article)
3. Structure et mise en œuvre du modèle

• La structure se compose des éléments suivants quatre parties : #🎜🎜 #

  Abstract Factory : Fournit une interface pour créer des produits, à travers laquelle l'appelant accède à la méthode d'usine newProduct() de l'usine spécifique pour créer des produits #🎜🎜 ##🎜🎜 #

ConcreteFactory : Implémente principalement les méthodes abstraites dans l'usine abstraite et finalise la création de produits spécifiques

Abstract Product ( Product ) : définit les spécifications du produit et décrit les principales caractéristiques et fonctions du produit

• Concrete Product (ConcreteProduct) : implémente l'interface définie par le rôle abstrait product , constitué d'une usine de béton à créer, il a une correspondance individuelle avec l'usine spécifique
Schéma de structure :
• #🎜 🎜#

  #🎜 🎜#

4. Implémentation du code de modèle de méthode d'usine

• Ou l'usine de Coca-Cola dans l'article précédent à titre d'exemple :

  # 🎜🎜# Les produits incluent : Coca-Cola, Pepsi-Cola, Coca-Cola sans sucre

En mode usine simple, il n'y a qu'une seule usine de Coca-Cola, qui peut produire trois produits. , il peut y avoir plusieurs usines pour générer les produits correspondants :

# 🎜🎜#Usine abstraite : Usine de coke (peut être comprise comme l'usine principale)

Pepsi -Usine de Cola : Générer du Pepsi-Cola

Usine de Coca-Cola :

Générer du Coca-Cola

Usine de Coca-Cola sans sucre : #🎜🎜 # Générer du Coca sans sucre
Méthode de production de Coca :

# 🎜🎜#

/**
 *  提供了产品的接口
 */public interface Cola {

    //生产可乐的方法
    public void cola();}

Cola abstract factory : #🎜 🎜#

/**
 * 可乐抽象工厂(可以理解成可乐总厂，旗下还有很多分厂)
 */public interface ColaFactory {

    public Cola newCola();}

Méthodes pour générer trois colas :
Cola cola :

/**
 * 产品名称：可乐可乐，实现了产品的接口
 */public class CocaCola implements Cola{

    @Override
    public void cola() {
        System.out.println("开始生产可口可乐");
    }}

Pepsi :

/**
 *
 * 产品名称：百事可乐，实现了产品的接口
 */public class PepsiCola implements Cola{

    @Override
    public void cola() {
        System.out.println("开始生产百事可乐");
    }}

Sugar- Coca gratuit :

/*
 * 产品名称：无糖可乐，实现了产品的接口
 */public class SugarFreeCola implements Cola{

    @Override
    public void cola() {
        System.out.println("开始生产无糖可乐");
    }}

Trois produits correspondent à trois usines :

L'usine qui produit du Coca-Cola :

/**
 *
 * 具体工厂1：可口可乐工厂
 */public class CocaColaFactory implements ColaFactory{
    
    @Override
    public Cola newCola() {
        System.out.println("我是可乐工厂下面的可口可乐工厂");
        return new CocaCola();
    }}

#🎜 🎜#L'usine qui produit du Pepsi-Cola :

/**
 *
 * 具体工厂2：百事可乐工厂
 */public class PepsiColaFactory implements ColaFactory{

    @Override
    public Cola newCola() {
        System.out.println("我是可乐工厂下面的百事可乐工厂");
        return new PepsiCola();
    }}

L'usine qui produit du Coca sans sucre :

/*
 * 具体工厂3：无糖可乐工厂
 */public class SugarFreeColaFactory implements ColaFactory{
    
    @Override
    public Cola newCola() {
        System.out.println("我是可乐工厂下面的无糖可乐工厂");
        return new SugarFreeCola();
    }}

#🎜 🎜#

Jusqu'à présent il y a :

Une méthode de production de cola

#🎜 🎜#Une usine de Coca (il y a plusieurs petites usines ci-dessous)#🎜 🎜#

Trois méthodes de production de trois types de Coca (implémentant l'interface Coke)

#🎜🎜 #

Trois usines de cola (produisent trois types de cola et implémenter l'interface de l'usine de cola)

Classe de test : #🎜🎜 #

public class Test {
    public static void main(String[] args) {

        try{

            //新建一个可乐方法对象
            Cola a;

            //新建一个可乐工厂对象
            ColaFactory af;

            //告诉可乐工厂，你需要什么可乐，并且通知对应的分工厂
            af = (ColaFactory) new PepsiColaFactory();
            //执行对于生产方法
            a = af.newCola();
            a.cola();
            
        }catch (Exception e ){
            System.out.println(e.getMessage());
        }
    }}

Par exemple, si J'ai besoin de Pepsi maintenant, je passe à l'usine Pepsi en af ​​:

我是可乐工厂下面的无糖可乐工厂
开始生产无糖可乐

Si je passe à
• CocaColaFactory

  : #🎜🎜 #

  我是可乐工厂下面的可口可乐工厂
  开始生产可口可乐

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!