Explication détaillée de l'usine abstraite en Java

Cet article présente principalement en détail les informations pertinentes du modèle de conception Java Abstract Factory, qui a une certaine valeur de référence. Les amis intéressés peuvent s'y référer

1. Concept

<.> Fournit une interface pour créer une série d'objets liés ou interdépendants sans spécifier leurs classes concrètes.

2. Motivation du motif

Cette série d'objets est interdépendante et équivalente à une famille de produits

3. La structure du motif

À travers l'image ci-dessus nous pouvons clairement voir que le modèle d'usine abstraite comprend les 4 rôles suivants :

1. Rôle d'usine abstraite (AbstractFactory ) : Le cœur du modèle de fabrique abstraite, qui n'a rien à voir avec une logique métier spécifique. Il s'agit généralement d'une interface JAVA ou d'une classe abstraite.

2. Concrete Factory : ce rôle est généralement étroitement lié à une logique métier spécifique. La méthode d'usine dans ce rôle instancie des produits spécifiques et les renvoie en fonction d'une logique métier spécifique. Le client utilise ce rôle et appelle la méthode d'usine. du rôle pour obtenir un objet produit spécifique. Ce rôle est généralement assumé par une classe JAVA spécifique.

3. Rôle de produit abstrait : la classe qui joue ce rôle est la classe parent du produit créé par le modèle de méthode d'usine, ou l'interface qu'ils partagent, généralement une interface ou une classe abstraite.

4. Rôle de produit spécifique : tout produit créé par le modèle d'usine abstraite est une instance de ce rôle et possède une classe JAVA spécifique pour l'assumer.

L'exemple de code est le suivant :

public class AbstractProductA 
{
  
  /**
  * @roseuid 59AC05990327
  */
  public AbstractProductA() 
  {
  
  }
}


public class ProductA1 extends AbstractProductA 
{
  
  /**
  * @roseuid 59AC05990359
  */
  public ProductA1() 
  {
  
  }
}


public class ProductA2 extends AbstractProductA 
{
  
  /**
  * @roseuid 59AC05990381
  */
  public ProductA2() 
  {
  
  }
}

public class AbstractProductB 
{
  
  /**
  * @roseuid 59AC059903BA
  */
  public AbstractProductB() 
  {
  
  }
}

public class ProductB1 extends AbstractProductB 
{
  
  /**
  * @roseuid 59AC059A001F
  */
  public ProductB1() 
  {
  
  }
}

public class ProductB2 extends AbstractProductB 
{
  
  /**
  * @roseuid 59AC059A0049
  */
  public ProductB2() 
  {
  
  }
}


public abstract class AbstractFactory 
{
  
  /**
  * @roseuid 59AC05690005
  */
  public AbstractFactory() 
  {
  
  }
  
  /**
  * @return AbstractProductA
  * @roseuid 59ABFB0103BE
  */
  public Abstract AbstractProductA createProductA() ;
  
  
  /**
  * @return AbstractProductB
  * @roseuid 59ABFB3B029D
  */
  public Abstract AbstractProductB createProductB() ;
}


public class ConcreteFactory1 extends AbstractFactory 
{
  
  /**
  * @roseuid 59AC057A02FC
  */
  public ConcreteFactory1() 
  {
  
  }
  
  /**
  * @return AbstractProductA
  * @roseuid 59ABFB9C00C9
  */
  public AbstractProductA createProductA() 
  {
    return new ProductA1();
  }
  
  /**
  * @return AbstractProductB
  * @roseuid 59ABFBA30011
  */
  public AbstractProductB createProductB() 
  {
    return new ProductB1();
  }
}



public class ConcreteFactory2 extends AbstractFactory 
{
  
  /**
  * @roseuid 59AC057A02C0
  */
  public ConcreteFactory2() 
  {
  
  }
  
  /**
  * @return AbstractProductA
  * @roseuid 59ABFCC701B9
  */
  public AbstractProductA createProductA() 
  {
    return new ProductA2();
  }
  
  /**
  * @return AbstractProductB
  * @roseuid 59ABFCC9001F
  */
  public AbstractProductB createProductB() 
  {
    return new ProductB2();
  }
}

public class Client 
{
  
  
  /**
  * @roseuid 59AC055700AB
  */
  public Client() 
  {
  
  }

  public static void main(String[] args){
      AbstractFactory theAbstractFactory;
    AbstractProductA theAbstractProductA;
    AbstractProductB theAbstractProductB;

    theAbstractFactory=new ConcreteFactory1();

    theAbstractProductA=theAbstractFactory.createProductA();
    theAbstractProductB=theAbstractFactory.createProductB();
 
  }
}

Selon le diagramme de structure du modèle ci-dessus , nous "Fournissons une interface pour créer une série d'objets liés ou interdépendants sans préciser leurs classes spécifiques" Effectuons une brève analyse :

1. Objets liés ou interdépendants, voici les instances de ProductA1 L'instance avec ProductB1 est un ensemble de relations interdépendantes (telles que les relations internes) ou interdépendantes (telles que le tout et la partie) Selon la logique métier, ProductA1

ne peut interagir avec ProductB1 que sous la même structure hiérarchique de produits AbstractProductB associée et ne peut pas être associée. avec ProduitB2.

2. Fournir une interface pour créer une série d'objets liés ou interdépendants sans spécifier leurs classes spécifiques. Les interfaces ici sont AbstractProductA et AbstractProductB dans le diagramme de structure. Le client s'appuie uniquement sur celles-ci. est programmé sans s'appuyer sur une implémentation spécifique, qui est conforme au principe d'inversion de dépendance. "Il n'est pas nécessaire de spécifier leurs classes spécifiques". Autrement dit, le client ne connaît pas l'existence de ProductA1, ProductA2, ProductB1 et ProductB2. Le client n'a qu'à appeler la méthode d'usine de l'usine spécifique pour renvoyer l'instance de produit spécifique.

4. Exemples de modèles

Suivons les exemples du modèle de méthode d'usine pour une analyse plus approfondie. Désormais, cette usine de pneus ne se contente plus de produire uniquement des pneus de voiture. il a maintenant introduit la ligne de production de moteurs (EngineLine), de portes (DoorLine) et d'autres lignes de production de pièces détachées pour l'ensemble de la voiture. On peut dire qu'il peut désormais fabriquer facilement une voiture, mais toutes les voitures ne peuvent pas être fabriquées. , il Actuellement, il ne peut produire que deux types de voitures : Benz et BMW (une telle usine suffit pour NX. Par exemple, une voiture ne contient désormais que des pneus, des portes et des moteurs (bien sûr, il y en a certainement plus que cela), alors cette usine peut suivre les voitures BMW et Benz qui ont été produites selon les exigences du client, comme indiqué ci-dessous :

Le code est le suivant :

public interface Door {
  public void open();
  public void close();
}
public class BenzDoor implements Door {

  @Override
  public void open() {
    System.out.println("奔驰车门开");
  }

  @Override
  public void close() {
    System.out.println("奔驰车门关");
  }
}
public class BmwDoor implements Door {

  @Override
  public void open() {
    System.out.println("宝马车门开");
  }

  @Override
  public void close() {
    System.out.println("宝马车门关");
  }

}
public interface Tire {
  public void getColor();
  public void getLife();
  public void getWidth();
}
public class BenzTire implements Tire {

  @Override
  public void getColor() {
    System.out.println("benz车color");
  }

  @Override
  public void getLife() {
    System.out.println("benz车life");
  }

  @Override
  public void getWidth() {
    System.out.println("benz车width");
  }
}
public class BmwTire implements Tire {

  @Override
  public void getColor() {
    System.out.println("bmw车color");
  }

  @Override
  public void getLife() {
    System.out.println("bmw车life");
  }

  @Override
  public void getWidth() {
    System.out.println("bmw车width");
  }

}
public interface Engine {
  public void start();

  public void stop();

}
public class BenzEngine implements Engine {

  @Override
  public void start() {
    System.out.println("benz车start");

  }

  @Override
  public void stop() {
    System.out.println("benz车stop");

  }

}
public class BmwEngine implements Engine {

  @Override
  public void start() {
    System.out.println("bmw车start");

  }

  @Override
  public void stop() {
    System.out.println("bmw车stop");

  }

}
public interface PartFactory {
  public Door createDoor();

  public Tire createTire();

  public Engine createEngine();

}
public class BenzPartFactory implements PartFactory {

  @Override
  public Door createDoor() {
    return new BenzDoor();
  }

  @Override
  public Tire createTire() {
    return new BenzTire();
  }

  @Override
  public Engine createEngine() {
    return new BenzEngine();
  }

}
public class BmwPartFactory implements PartFactory {

  @Override
  public Door createDoor() {
    return new BmwDoor();
  }

  @Override
  public Tire createTire() {
    return new BmwTire();
  }

  @Override
  public Engine createEngine() {
    return new BmwEngine();
  }

}
public class Car {
  private Door door;
  private Engine engine;
  private Tire tire;

  public Car(PartFactory factory) {
    this.door = factory.createDoor();
    this.engine = factory.createEngine();
    this.tire = factory.createTire();
  }

  public Door getDoor() {
    return door;
  }

  public Engine getEngine() {
    return engine;
  }

  public Tire getTire() {
    return tire;
  }  
}
public class Client {
  
  public static void main(String[] args) {
    PartFactory partFactory=new BenzPartFactory();
    Car benzCar=new Car(partFactory);
    
    benzCar.getDoor().open();
    benzCar.getEngine().start();
    benzCar.getTire().getColor();
    
  }

}

Exécuter Les résultats sont les suivants :

Porte de la voiture Benz ouverte

Démarrage de la voiture Benz
Couleur de la voiture Benz

Selon le au-dessus du diagramme de classes et des résultats de fonctionnement, l'analyse suivante peut être effectuée :

BenzDoor, BenzTire et BenzEngine ont une relation forte. On peut dire qu'une voiture Benz ne peut pas utiliser les portes Bmw, c'est-à-dire BmwDoor. Cette relation solide est bien entretenue grâce à BenzPartFactory. Pour le client, comme la classe de clients ci-dessus, si le client veut une voiture Benz, alors j'ai seulement besoin d'une usine qui produit des voitures Benz. Toutes les instances de produits dans cette usine sont des pièces de voitures Benz. Nous pouvons également le constater à partir des résultats en cours d’exécution.

Imaginez qu'avec le développement de cette usine, elle produira désormais également des voitures Audi. Pour le moment, il suffit d'ajouter une classe de porte Audi AudiDoor, AudiTire, AudiEngine et AudiPartFactory. toute modification. Mais le client a dit : je veux installer une paire d'ailes sur la voiture pour qu'elle puisse voler en cas d'embouteillage. À ce stade, nous devons ajouter une méthode d'usine qui peut renvoyer les ailes à chaque usine, et nous. Il faut modifier chaque usine. Ce n'est pas cohérent. Par conséquent, l'usine abstraite ne prend pas en charge le principe d'ouverture-fermeture pour l'ajout de structures hiérarchiques de produits, mais prend en charge le principe d'ouverture-fermeture pour les dimensions des familles de produits (telles que les voitures Audi).

5. Contraintes de mode

Il convient pour générer une famille de produits interdépendants ou dépendants et prend en charge l'expansion dans la direction de la famille de produits, mais ne convient pas au niveau du produit direction.

6. Variations et extensions de modèles

1. La fabrique abstraite fournit une méthode de fabrique statique : la fabrique abstraite peut fournir une méthode de fabrique statique qui est renvoyée via des paramètres Exemple d'usine à béton.

2. Fusionner l'usine abstraite avec l'usine spécifique : S'il n'y a qu'une seule famille de produits dans le sens de la famille de produits, alors l'usine abstraite n'est pas nécessaire pour le moment, une seule usine spécifique est nécessaire. Pour aller plus loin, fournissez une méthode statique pour cette usine spécifique, qui renvoie sa propre instance.

7. Relation avec d'autres modèles

S'il n'y a qu'une seule structure au niveau du produit, alors c'est le modèle de méthode d'usine, comme indiqué ci-dessous :

S'il existe plusieurs hiérarchies de produits, alors chaque méthode d'usine dans l'usine abstraite est un modèle de « méthode d'usine ».

8. Avantages et inconvénients du modèle

Il prend en charge le principe d'ouverture-fermeture dans le sens de la famille de produits, mais ne prend pas en charge le principe d'ouverture-fermeture dans le sens de la hiérarchie des produits.

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!