Comment implémenter le modèle d'usine des modèles de conception Java

Les détails sont les suivants :

Le modèle d'usine fournit principalement une interface de transition pour la création d'objets afin de protéger et d'isoler le processus spécifique de création d'objets afin d'atteindre l'objectif d'amélioration de la flexibilité.

Le modèle d'usine est divisé en trois catégories. :

1) Modèle d'usine simple (usine simple) : non propice à la production d'une série de produits ;
2) Modèle de méthode d'usine (méthode d'usine) : également connu sous le nom d'usine polymorphe ; également appelé boîte à outils, produit une famille de produits, mais il n'est pas propice à la production de nouveaux produits

1. Modèle d'usine simple

Le modèle d'usine simple est également appelé modèle de méthode d'usine statique ; Il ressort du changement de nom que ce mode doit être très simple. Son but est simple : définir une interface de création d'objets.

Dans le modèle d'usine simple, une classe d'usine est au centre de l'appel d'instanciation de classe de produit. Elle détermine quelle classe de produit doit être instanciée, tout comme un agent de la circulation se tenant dans le flux de véhicules qui passent et décidant dans quelle direction lâcher prise. les véhicules circulent dans cette direction. Jetons d'abord un coup d'œil à ses composants :

1) Rôle d'usine : c'est le cœur de ce modèle et contient une certaine logique métier et une logique de jugement. En Java, il est souvent implémenté par une classe concrète.

2) Rôle abstrait du produit : Il s'agit généralement de la classe parent héritée d'un produit spécifique ou de l'interface implémentée. Il est implémenté en Java par interface ou classe abstraite.
3) Rôle produit spécifique : L'objet créé par la classe factory est une instance de ce rôle. Implémenté par une classe concrète en Java.

2. Modèle de méthode d'usine

Le modèle de méthode d'usine est une abstraction et une promotion supplémentaires du modèle d'usine simple. Dans le modèle de méthode d'usine, ce n'est plus seulement une classe d'usine qui détermine quelle classe de produit doit être instanciée. la décision est confiée à Laisser la sous-classe d’usine abstraite le faire. Jetons un coup d'œil à sa composition :

1) Rôle d'usine abstrait : c'est le cœur du modèle de méthode d'usine, et cela n'a rien à voir avec l'application. C'est l'interface qu'un rôle d'usine spécifique doit implémenter ou la classe parent qui doit être héritée. En Java, il est implémenté par des classes abstraites ou des interfaces.

2) Rôle d'usine spécifique : il contient du code lié à une logique métier spécifique. Appelé par une application pour créer un objet correspondant à un produit spécifique.
3) Rôle produit abstrait : C'est la classe parent héritée par un produit spécifique ou l'interface implémentée. En Java, il existe généralement des classes ou interfaces abstraites à implémenter.
4) Rôle produit spécifique : L'objet créé par le rôle d'usine spécifique est une instance de ce rôle. Il est implémenté par des classes spécifiques en Java.

Le modèle de méthode d'usine utilise plusieurs sous-classes héritées du rôle d'usine abstraite pour remplacer la "classe Dieu" dans le modèle d'usine simple. Comme mentionné ci-dessus, cela partage la pression sur l'objet ; et cela rend la structure plus flexible - lorsqu'un nouveau produit (c'est-à-dire la voiture parvenue) est produit, à condition qu'il soit fourni conformément au rôle de produit abstrait et au rôle d'usine abstrait. Des contrats sont générés, qui peuvent ensuite être utilisés par les clients sans avoir à modifier le code existant. On voit que la structure du rôle de l'usine est également conforme au principe d'ouverture et de fermeture !

Le code est le suivant :

//抽象产品角色
public interface Moveable {
  void run();
}
//具体产品角色
public class Plane implements Moveable {
  @Override
  public void run() {
    System.out.println("plane....");
  }
}
public class Broom implements Moveable {
  @Override
  public void run() {
    System.out.println("broom.....");
  }
}
//抽象工厂
public abstract class VehicleFactory {
  abstract Moveable create();
}
//具体工厂
public class PlaneFactory extends VehicleFactory{
  public Moveable create() {
    return new Plane();
  }
}
public class BroomFactory extends VehicleFactory{
  public Moveable create() {
    return new Broom();
  }
}
//测试类
public class Test {
  public static void main(String[] args) {
    VehicleFactory factory = new BroomFactory();
    Moveable m = factory.create();
    m.run();
  }
}

3. Abstract Factory Pattern

Le code est le suivant

//抽象工厂类
public abstract class AbstractFactory {
  public abstract Vehicle createVehicle();
  public abstract Weapon createWeapon();
  public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
  @Override
  public Food createFood() {
    return new Apple();
  }
  @Override
  public Vehicle createVehicle() {
    return new Car();
  }
  @Override
  public Weapon createWeapon() {
    return new AK47();
  }
}
//测试类
public class Test {
  public static void main(String[] args) {
    AbstractFactory f = new DefaultFactory();
    Vehicle v = f.createVehicle();
    v.run();
    Weapon w = f.createWeapon();
    w.shoot();
    Food a = f.createFood();
    a.printName();
  }
}

Dans le pattern Abstract Factory, il peut y avoir un ou plusieurs produits abstraits (AbstractProduct), formant ainsi un ou plusieurs familles de produits (Product Family). Dans le cas d’une seule famille de produits, le modèle d’usine abstrait dégénère en fait en modèle de méthode d’usine.

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!