Qu'est-ce qu'un modèle d'usine abstrait

Cet article parle du dernier type d'usine, commençons par

Modèle d'usine abstraitDéfinition(de l'Encyclopédie Baidu) :
Le modèle d'usine abstrait est un modèle d'usine de tous formes La forme la plus abstraite et la plus générale. Le modèle de fabrique abstraite fait référence à un modèle de fabrique utilisé lorsqu'il existe plusieurs rôles abstraits.
Le modèle d'usine abstrait peut fournir une interface au client, lui permettant de créer des objets produits dans plusieurs familles de produits sans avoir à spécifier les produits spécifiques. Selon le principe de substitution de Liskov,
Tout endroit qui accepte un type parent devrait pouvoir accepter un sous-type. Par conséquent, ce dont le système a réellement besoin, ce sont simplement quelques instances du même type que ces rôles de produits abstraits, et non des instances de ces produits abstraits.
En d'autres termes, des instances de sous-classes concrètes de ces produits abstraits. Les classes d'usine sont chargées de créer des instances de sous-classes concrètes de produits abstraits.

Diagramme de classes UML

Code spécifique :

public class Client {public static void main(String[] args) {//        Creator benzCreator = new BenzCreator();//        benzCreator.createCar().run();////        Creator bmwCreator = new BmwCreator();//        bmwCreator.createCar().run();AbstractFactory factory1 = new Factory1();
        factory1.createProductA().getProductAName();
        factory1.createProductB().getProductBName();

        AbstractFactory factory2 = new Factory2();
        factory2.createProductA().getProductAName();
        factory2.createProductB().getProductBName();
    }
}public interface AbstractFactory {
    AbstractProductA createProductA();

    AbstractProductB createProductB();
}public class Factory1 implements AbstractFactory {
    @Overridepublic AbstractProductA createProductA() {return new ProductA1();
    }

    @Overridepublic AbstractProductB createProductB() {return new ProductB1();
    }
}public class Factory2 implements AbstractFactory {

    @Overridepublic AbstractProductA createProductA() {return new ProductA2();
    }

    @Overridepublic AbstractProductB createProductB() {return new ProductB2();
    }
}public interface AbstractProductA {
       String getProductAName();
}public class ProductA1 implements AbstractProductA {
    ProductA1(){
        System.out.println("产品A1");
    }

    @Overridepublic String getProductAName() {return "产品A1名称";
    }
}public class ProductA2 implements AbstractProductA {
    ProductA2(){
        System.out.println("产品A2");
    }

    @Overridepublic String getProductAName() {return "产品A2名称";
    }
}public interface AbstractProductB {
    String getProductBName();
}public class ProductB1 implements AbstractProductB {
    ProductB1(){
        System.out.println("产品B1");
    }

    @Overridepublic String getProductBName() {return "产品B1名称";
    }
}public class ProductB2 implements AbstractProductB {
    ProductB2(){
        System.out.println("产品B2");
    }

    @Overridepublic String getProductBName() {return "产品B2名称";
    }
}

Famille de produits :

fait référence à une famille de produits fonctionnellement liés situés dans différentes structures hiérarchiques de produits

Exemples spécifiques  :

Laissez-moi vous donner un exemple qui n'est peut-être pas approprié
Par exemple, nos ordinateurs sont à la fois 32 bits et 64 bits, et les machines correspondantes installent des logiciels avec les bits correspondants
Deux CD de logiciels 32 bits et 64 bits sont stockés séparément Lors de l'installation de la machine, il vous suffit de prendre un CD pour installer l'ensemble du logiciel de la machine sans avoir à rechercher chaque logiciel un par un.
Le disque ici est l'usine spécifique. Et si chaque disque avait QQ et 360 (je veux juste me battre ?)
Le disque 32 bits ici est Factory1 dans le code ci-dessus. Le disque 64 bits ici est Factory2. dans le code ci-dessus
Le QQ dans le CD 32 bits est ProductA1 et le 360 ​​​​est ProductB1
Le QQ dans le CD 64 bits est ProductA2 et le 360 ​​​​est ProductB2

Pour un novice comme moi, procurez-vous simplement le bon CD, vous n'avez pas besoin de trouver à la fois le bon chiffre QQ et le bon chiffre 360, n'est-ce pas génial ?

Avantages et inconvénients
Avantages :
Interface et implémentation séparées, de sorte que le client n'a pas besoin de connaître l'implémentation spécifique.
Il devient facile de changer de famille de produits, tout comme si une machine 128 bits apparaissait, il suffisait d'ajouter un CD supplémentaire.

Inconvénients :
Il n'est pas facile de développer de nouveaux produits (imaginez combien de classes et de méthodes vous devez ajouter pour ajouter un produit).
La structure hiérarchique de la classe est compliquée (il suffit de regarder le schéma de classe et vous vous sentirez malade)

Essence :

Comme je l'ai déjà dit, le L'essence de la méthode de l'usine est Choisir la mise en œuvre signifie choisir un produit spécifique
L'usine abstraite signifie choisir une famille de produits, passer d'un produit unique à une famille de produits.

Maintenant que nous avons fini de parler des trois modèles d'usine, nous allons d'abord creuser un trou dans la relation, la différence et le processus d'évolution entre eux, puis en parler plus tard.

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!