Une brève introduction au modèle d'usine simple des modèles de conception Java

Le concept du modèle d'usine simple

est d'établir une classe d'usine pour créer des instances de certaines classes qui implémentent la même interface. L'essence du modèle d'usine simple est qu'une classe d'usine détermine dynamiquement quelle instance de la classe de produits (ces classes de produits héritent d'une classe ou d'une interface parent) doit être créée en fonction des paramètres entrants.

Diagramme UML d'un modèle d'usine simple

Code de modèle d'usine simple
Quand j'ai appris le modèle d'usine simple, j'ai utilisé un humain là-bas sont des exemples pertinents. Les êtres humains sont divisés en hommes et femmes dans le monde. Définissez d'abord une interface abstraite pour les produits humains

/**
 * This is factory patter package
 */
package com.roc.factory;
 
/**
 * 产品的抽象接口 人类
 * @author liaowp
 *
 */
public interface Human {
  
 public void say();
 
}

, puis définissez les hommes et les femmes. , qui sont tous deux identiques. La façon de parler.

/**
 * This is factory patter package
 */
package com.roc.factory;
 
/**
 * man 男人
 * @author liaowp
 *
 */
public class Man implements Human {
 
 /* say method
 * @see com.roc.factory.Human#say()
 */
 @Override
 public void say() {
 System.out.println("男人");
 }
 
}

/**
 * This is factory patter package
 */
package com.roc.factory;
 
/**女人
 * @author liaowp
 *
 */
public class Woman implements Human {
 
 /* say method
 * @see com.roc.factory.Human#say()
 */
 @Override
 public void say() {
 System.out.println("女人");
 }
 
}

Enfin écrire un cours d'usine pour créer des hommes et des femmes. La première consiste à utiliser un jugement logique.

package com.roc.factory;
/**
 * 简单工厂
 * @author liaowp
 *
 */
public class SampleFactory {
 public static Human makeHuman(String type){
 if(type.equals("man")){
  Human man = new Man();
  return man;
 }else if(type.equals("womman")){
  Human woman = new Woman();
  return woman;
 }else{
  System.out.println("生产不出来");
  return null;
 } 
 }
}

La deuxième façon est d'utiliser le rayonnement de Java. Je pense que ce type d'implémentation est meilleur.

package com.roc.factory;
/**
 * 简单工厂放射实现
 * @author liaowp
 *
 */
public class SampleFactory1 {
 public static Human makeHuman(Class c){
 Human human = null;
 try {
  human = (Human) Class.forName(c.getName()).newInstance();
 } catch (InstantiationException e) {
  // TODO Auto-generated catch block
  System.out.println("不支持抽象类或接口");
  e.printStackTrace();
 } catch (IllegalAccessException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  System.out.println("没有足够权限，即不能访问私有对象");
 } catch (ClassNotFoundException e) {
  // TODO Auto-generated catch block
  System.out.println("类不存在");
  e.printStackTrace();
 }
 return human;
 }
}

Le dernier est le code client

package com.roc.factory;
/**
 * 简单工厂测试
 * @author liaowp
 *
 */
public class Client {
 public static void main(String[] args) {
// Human man = SampleFactory.makeHuman("man");
// man.say();
// Human womman = SampleFactory.makeHuman("womman");
// womman.say();
// Human test = SampleFactory.makeHuman("tttt");
  
 Human man = SampleFactory1.makeHuman(Man.class);
 man.say();
 Human woman = SampleFactory1.makeHuman(Woman.class);
 woman.say();
 }
}

Scénario d'application simple en mode usine

Avantages : La classe usine est la clé de l'ensemble du modèle. Elle contient le jugement logique nécessaire pour déterminer quelle classe spécifique d'objets doit être créée en fonction des informations fournies par le monde extérieur. En utilisant la classe usine, le monde extérieur peut obtenir. débarrassé de la situation embarrassante de créer directement des objets de produits spécifiques. Sortez, il vous suffit d'être responsable de « consommer » l'objet. Peu importe la façon dont ces objets sont créés et organisés. Clarifier leurs responsabilités et droits respectifs est propice à l’optimisation de l’ensemble de l’architecture logicielle.

Inconvénients : Parce que la classe d'usine concentre la logique de création de toutes les instances, elle viole le principe d'allocation des responsabilités à haute cohésion et concentre toute la logique de création dans une seule classe d'usine, les classes qu'elle peut créer ne peuvent qu'elle ; Il a été considéré à l'avance que si une nouvelle classe devait être ajoutée, la classe d'usine devait être modifiée. Lorsque le nombre de catégories de produits spécifiques dans le système continue d'augmenter, la classe d'usine peut avoir besoin de créer différentes instances en fonction de différentes conditions. Ce type de jugement sur les conditions et le jugement sur des types de produits spécifiques sont étroitement liés, ce qui rend difficile d'éviter la propagation des fonctions du module et est très préjudiciable à la maintenance et à l'expansion du système

Ce qui précède est l'ensemble ; contenu de cet article, j'espère qu'il sera utile à tout le monde. L'apprentissage est utile et j'espère que tout le monde soutiendra le site Web PHP chinois.

Pour plus d'articles liés à la brève introduction du modèle d'usine simple aux modèles de conception Java, veuillez faire attention au site Web PHP chinois !