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

Cet article présente principalement les informations relatives au modèle de méthode d'usine compilées par la Power Node Java Academy. Les amis dans le besoin peuvent s'y référer

Définition : Définir une interface pour créer des objets, laissez les sous-classes. décidez quelle classe instancier et les méthodes d'usine reportent l'instanciation d'une classe à ses sous-classes.

Type : Créer un modèle de classe

Diagramme de classe :

Code du modèle de méthode d'usine

interface IProduct { 
  public void productMethod(); 
} 
class Product implements IProduct { 
  public void productMethod() { 
    System.out.println("产品"); 
  } 
} 

interface IFactory { 
  public IProduct createProduct(); 
} 
 
class Factory implements IFactory { 
  public IProduct createProduct() { 
    return new Product(); 
  } 
} 

public class Client { 
  public static void main(String[] args) { 
    IFactory factory = new Factory(); 
    IProduct prodect = factory.createProduct(); 
    prodect.productMethod(); 
  } 
}

Modèle d'usine :

Nous devons d’abord parler du mode usine. Le modèle d'usine est divisé en trois types selon le degré d'abstraction : le modèle d'usine simple (également appelé modèle d'usine statique), le modèle de méthode d'usine décrit dans cet article et le modèle d'usine abstrait. Le modèle d'usine est un modèle souvent utilisé en programmation. Ses principaux avantages sont les suivants :

• peut rendre la structure du code claire et encapsuler efficacement les modifications. En programmation, l'instanciation des classes de produits est parfois complexe et modifiable. Grâce au modèle d'usine, l'instanciation du produit est encapsulée, de sorte que l'appelant n'a pas du tout besoin de se soucier du processus d'instanciation du produit, mais seulement de le faire. comptez sur l'usine pour obtenir le produit que vous souhaitez.

• Bloquer des catégories de produits spécifiques à l'appelant. Si vous utilisez le modèle d'usine, l'appelant ne se soucie que de l'interface du produit. Quant à l'implémentation spécifique, l'appelant n'a pas besoin de s'en soucier du tout. Même si l'implémentation spécifique est modifiée, cela n'aura aucun impact sur l'appelant.

• Réduire l'accouplement. L'instanciation des classes de produits est généralement très compliquée. Elle dépend de nombreuses classes, et ces classes n'ont pas besoin d'être connues de l'appelant. Si une méthode d'usine est utilisée, il suffit d'instancier la classe de produit. à l'appelant pour utilisation. Pour l'appelant, les classes dont dépend le produit sont transparentes.

Modèle de méthode d'usine :

Vous pouvez voir sur le diagramme de classes du modèle de méthode d'usine que le modèle de méthode d'usine a quatre éléments :

• Interface d'usine. L'interface d'usine est au cœur du modèle de méthode d'usine, qui interagit directement avec l'appelant pour fournir des produits. Dans la programmation réelle, une classe abstraite est parfois utilisée comme interface pour interagir avec l'appelant, ce qui est essentiellement la même.

• Mise en œuvre en usine. En programmation, l'implémentation en usine détermine comment instancier les produits, ce qui constitue le moyen de réaliser l'expansion. Le nombre de produits nécessaires dépend du nombre d'implémentations d'usine spécifiques nécessaires.

• Interface produit. L'objectif principal de l'interface produit est de définir les spécifications du produit, et toutes les implémentations de produit doivent suivre les spécifications définies par l'interface produit. L'interface du produit est ce qui préoccupe le plus l'appelant. La qualité de la définition de l'interface du produit détermine directement la stabilité du code de l'appelant. De même, les interfaces de produits peuvent également être remplacées par des classes abstraites, mais veillez à ne pas violer le principe de substitution de Liskov.

• Mise en œuvre du produit. La classe spécifique qui implémente l'interface du produit détermine le comportement spécifique du produit dans le client.
  

Le modèle d'usine simple mentionné ci-dessus est très similaire au modèle de méthode d'usine. La différence est que l'usine simple n'a que trois éléments, elle n'a pas d'interface d'usine et le modèle de méthode d'usine. la méthode d’obtention du produit est générale et statique. Parce qu'il n'y a pas d'interface d'usine, l'évolutivité de l'implémentation de l'usine est légèrement plus faible. Elle peut être considérée comme une version simplifiée du modèle de méthode d'usine. Le modèle d'usine simple sera brièvement mentionné ici.

Scénarios applicables :

Qu'il s'agisse d'un modèle d'usine simple, d'un modèle de méthode d'usine ou d'un modèle d'usine abstrait, ils ont des caractéristiques similaires, donc leur Les scénarios applicables sont également similaires.

Tout d'abord, en tant que modèle de création de classe, le modèle de méthode d'usine peut être utilisé partout où des objets complexes doivent être générés. Une chose à noter est que les objets complexes conviennent à l'utilisation du modèle d'usine, tandis que les objets simples, en particulier ceux qui ne peuvent être créés que via new, n'ont pas besoin d'utiliser le modèle d'usine. Si vous utilisez le modèle d'usine, vous devez introduire une classe d'usine, ce qui augmentera la complexité du système.

Deuxièmement, le mode usine est un mode de découplage typique, et la loi de Dimit est particulièrement évidente dans le mode usine. Si l'appelant assemble lui-même le produit et doit ajouter des dépendances, il peut envisager d'utiliser le modèle d'usine. Réduira considérablement le couplage entre les objets.

Troisièmement, comme le modèle d'usine repose sur une architecture abstraite, il confie la tâche d'instancier les produits à la classe d'implémentation et offre une meilleure évolutivité. En d’autres termes, lorsque le système doit avoir une meilleure évolutivité, le modèle d’usine peut être envisagé et différents produits sont assemblés à l’aide de différentes usines de mise en œuvre.                                                                                                                 

       要说明工厂模式的优点，可能没有比组装汽车更合适的例子了。场景是这样的：汽车由发动机、轮、底盘组成，现在需要组装一辆车交给调用者。假如不使用工厂模式，代码如下：

class Engine { 
  public void getStyle(){ 
    System.out.println("这是汽车的发动机"); 
  } 
} 
class Underpan { 
  public void getStyle(){ 
    System.out.println("这是汽车的底盘"); 
  } 
} 
class Wheel { 
  public void getStyle(){ 
    System.out.println("这是汽车的轮胎"); 
  } 
} 
public class Client { 
  public static void main(String[] args) { 
    Engine engine = new Engine(); 
    Underpan underpan = new Underpan(); 
    Wheel wheel = new Wheel(); 
    ICar car = new Car(underpan, wheel, engine); 
    car.show(); 
  } 
}

        可以看到，调用者为了组装汽车还需要另外实例化发动机、底盘和轮胎，而这些汽车的组件是与调用者无关的，严重违反了迪米特法则，耦合度太高。并且非常不利于扩展。另外，本例中发动机、底盘和轮胎还是比较具体的，在实际应用中，可能这些产品的组件也都是抽象的，调用者根本不知道怎样组装产品。假如使用工厂方法的话，整个架构就显得清晰了许多。

interface IFactory { 
  public ICar createCar(); 
} 
class Factory implements IFactory { 
  public ICar createCar() { 
    Engine engine = new Engine(); 
    Underpan underpan = new Underpan(); 
    Wheel wheel = new Wheel(); 
    ICar car = new Car(underpan, wheel, engine); 
    return car; 
  } 
} 
public class Client { 
  public static void main(String[] args) { 
    IFactory factory = new Factory(); 
    ICar car = factory.createCar(); 
    car.show(); 
  } 
}

        使用工厂方法后，调用端的耦合度大大降低了。并且对于工厂来说，是可以扩展的，以后如果想组装其他的汽车，只需要再增加一个工厂类的实现就可以。无论是灵活性还是稳定性都得到了极大的提高。

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!