Explication détaillée du modèle de méthode d'usine Java

Cet article vous apporte des connaissances pertinentes sur java, qui introduit principalement les problèmes liés au modèle de méthode d'usine. Le modèle de méthode d'usine est également appelé modèle de constructeur virtuel ou modèle d'usine polymorphe. aide tout le monde.

Étude recommandée : "Tutoriel Java"

1. Qu'est-ce que le modèle de méthode d'usine ?

Modèle de méthode d'usine : Également appelé modèle de constructeur virtuel ou modèle d'usine 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. Le but est de retarder l'instanciation de la classe produit. à la sous-classe d'usine Terminé dans le processus, 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 véritables usines d’aujourd’hui 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 être modifié et ajusté dans cette classe, et le modèle de méthode d'usine a plusieurs usines chacune. L'usine fabrique un produit. S'il est nécessaire d'ajouter de nouveaux produits, nous pouvons directement construire une nouvelle usine. Il n'est pas nécessaire de la modifier à l'intérieur d'autres usines. Cela est conforme au principe d'ouverture et de fermeture.

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

Avantages :

• Les utilisateurs ont seulement besoin de connaître le nom de l'usine spécifique pour obtenir le produit qu'ils souhaitent, sans connaître le processus de création spécifique du produit

• Flexibilité améliorée, pour la création de nouveaux produits, il vous suffit d'écrire une classe d'usine correspondante supplémentaire

• Un cadre de découplage typique. Les modules de haut niveau n'ont besoin que de connaître la classe abstraite du produit et n'ont pas besoin de se soucier des autres classes d'implémentation. Ils satisfont à la loi de Demeter, au principe d'inversion de dépendance et au principe de substitution de Richter

Inconvénients :

• Le le nombre de classes est facilement trop élevé. Complexité accrue

• Augmente 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 le Abstract Factory Pattern (Abstract Factory Pattern). est dans le prochain article)

3. Structure et mise en œuvre du modèle

La structure se compose des quatre parties suivantes :

• Abstract Factory (Abstract Factory) : Fournit une interface pour créer des produits, à travers lesquels le l'appelant accède à la méthode d'usine newProduct() de l'usine spécifique. Pour créer des produits

• Concrete Factory (ConcreteFactory) : implémente principalement les méthodes abstraites dans l'usine abstraite pour terminer la création de produits spécifiques

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

• Concrete Product (ConcreteProduct) : implémente l'interface définie par le rôle de produit abstrait et est créée par une usine spécifique. correspondance à un avec l'usine spécifique

Schéma de structure :

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

Prenons l'usine de Coca-Cola de l'article précédent comme exemple :
Les produits sont : Coca-Cola, Pepsi-Cola, Coca-Cola sans sucre
Dans le mode usine simple, il n'y a qu'une seule usine de Coca-Cola qui peut produire trois produits, dans le modèle de méthode d'usine, il peut y avoir plusieurs usines pour générer les produits correspondants :

Usine abstraite : Usine de Coca-Cola (peut être comprise comme l'usine principale)
Usine Pepsi-Cola : Générer du Pepsi-Cola
Usine Coca-Cola : Générer du Coca-Cola
Usine de Coca-Cola sans sucre : Générer sans sucre Coca

Méthode pour produire du Coca :

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

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

Cola Abstract Factory :

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

    public Cola newCola();}

Méthodes pour générer trois types de Coca :
Coca Coca :

/**
 * 产品名称：可乐可乐，实现了产品的接口
 */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("开始生产百事可乐");
    }}

Coke sans sucre :

/*
 * 产品名称：无糖可乐，实现了产品的接口
 */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-Cola 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 Coca

• 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 (produire 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 dans l'usine Pepsi en AF :

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

如果传入CocaColaFactory：

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

5、总结

这就是工厂方法模式，和简单工厂模式有所不同，在这个模式内有一个抽象工厂接口，也就是你需要增加新产品后，不需要在原本的工厂内去修改代码，而是直接新建一个工厂，去实现抽象工厂即可，也是符合了开闭原则。

当然缺点也就是工厂多了，管理变得复杂，也增加了系统的抽象性和理解难度，而且抽象产品只能生产一种产品，但是此弊端可使用抽象工厂模式解决（抽象工厂模式在下一篇文章）

推荐学习：《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!