Quelles sont les différences entre les modèles de conception Factory, Factory Method et Abstract Factory, et quand chacun doit-il être utilisé ?

Factory vs. Factory Method vs. Abstract Factory : comprendre les différences

Comprendre les différences entre les modèles de conception Factory, Factory Method et Abstract Factory peut être un défi. Pour clarifier, voici une explication de chaque modèle et en quoi ils diffèrent :

Factory

Le modèle Factory crée des objets sans exposer la logique d'instanciation au client. Il fait référence à l'objet nouvellement créé via une interface commune. Essentiellement, cela simplifie le modèle de méthode Factory.

Méthode Factory

La méthode Factory définit une interface pour créer des objets, permettant aux sous-classes de décider quelle classe instancier. Semblable au modèle Factory, il utilise une interface commune pour référencer l'objet créé.

Abstract Factory

Le modèle Abstract Factory fournit une interface pour créer une famille d'objets associés sans spécifier leurs classes concrètes. explicitement. Ce modèle est utile lorsque vous devez créer plusieurs objets avec une interface cohérente.

Différences et quand utiliser

Pattern	Differences	When to Use
Factory	Simplified version of Factory Method	Use when you need a fixed, object-creation mechanism without subclassing.
Factory Method	Generic base class with specific creation logic handled by subclasses	Use when you need to vary the object type based on the subclass implementation.
Abstract Factory	Creates related objects of the same type	Use when you need to ensure consistency in creating object families for dependency injection or strategy patterns.

Exemples Java

Factory :

<code class="java">public class FruitFactory {

  public Fruit makeFruit(String type) {
    switch (type) {
      case "Apple":
        return new Apple();
      case "Orange":
        return new Orange();
      default:
        throw new IllegalArgumentException("Invalid fruit type");
    }
  }
}</code>

Méthode d'usine :

<code class="java">abstract class FruitPicker {

  protected abstract Fruit makeFruit();

  public void pickFruit() {
    Fruit fruit = makeFruit();
    // Perform operations using fruit...
  }
}

class ApplePicker extends FruitPicker {

  @Override
  protected Fruit makeFruit() {
    return new Apple();
  }
}

class OrangePicker extends FruitPicker {

  @Override
  protected Fruit makeFruit() {
    return new Orange();
  }
}</code>

Usine abstraite :

<code class="java">interface FruitPlantFactory {

  public Plant makePlant();
  public Picker makePicker();
}

class AppleFactory implements FruitPlantFactory {

  @Override
  public Apple makePlant() {
    return new Apple();
  }

  @Override
  public ApplePicker makePicker() {
    return new ApplePicker();
  }
}

class OrangeFactory implements FruitPlantFactory {

  @Override
  public Orange makePlant() {
    return new Orange();
  }

  @Override
  public OrangePicker makePicker() {
    return new OrangePicker();
  }
}</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!