Modèle d'usine simple de modèles de conception courants en Java

1. Modèle d'usine simple

Le modèle de fabrique simple appartient au modèle de création, qui est responsable de la création de l'instanciation d'autres classes en définissant une classe. Les instances créées ont généralement une classe ou une interface parente commune.

Deux, diagramme de structure

• Factory : La classe de fabrique, le cœur du modèle de fabrique simple, est responsable de l'implémentation de la création d'une instance. La méthode de création d'un produit dans la classe de fabrique peut être directement appelée par le monde extérieur.
• IProduct : classe de produit abstraite, chargée de décrire l'interface commune à toutes les instances
• Produit : La catégorie de produit spécifique est l'objectif du modèle d'usine simple.

Troisièmement, démonstration de code

À travers l'exemple du fruit, nous avons d'abord besoin d'une interface fruitée abstraite

package 简单工厂模式;

public interface Fruit {
    
    
	//	生产水果
	public void get();
}

Ensuite, nous devons créer une classe de fruits spécifique (par exemple: pomme et poire), et la laisser hériter de l'interface fruit

public class Pear implements Fruit{
    
    

	public void get() {
    
    
		// TODO Auto-generated method stub
		System.out.println("生产梨子！");
		
	}
}

public class Apple implements Fruit {
    
    

	@Override
	public void get() {
    
    
		// TODO Auto-generated method stub
		System.out.println("生产苹果！");
	}
}

Ensuite, vous devez créer une fabrique de fruits, qui produit des fruits en passant des paramètres

package 简单工厂模式;

public class FruitFactory {
    
    
//	第一种 ：简单
//	public	static Fruit getApple() {
    
    
//		return new Apple();
//		
//	}
//	public static Fruit getPear() {
    
    
//		return new Pear();
//		
//	}
	
//	第二种方式：通用
	
	public static Fruit getFruit(String type) {
    
    
//		返回水果对象
		if("apple".equals(type)) {
    
    
			return new Apple();
		}else if("Pear".equals(type)) {
    
    
			return new Pear();
		}else {
    
    
			return null;
		}
	}
}

Ensuite, appelez-le en créant une classe d'entité!

package 简单工厂模式;
//测试类
public class Text {
    
    
public static void main(String[] args) {
    
    
/**	第三种方式 简单工厂模式
 * 
 * 直接通过工厂去调用实例化对象，
 * 不需要考虑如何后端是如何实现
 */
//	简单型
//	Fruit apple = FruitFactory.getApple();
//	apple.get();
//	Fruit pear = FruitFactory.getApple();
//	apple.get();
	
//	通用型
	Fruit apple = FruitFactory.getFruit("apple");
	apple.get();
	Fruit pear = FruitFactory.getFruit("Pear");
	pear.get();
}
}

Quatrièmement, les avantages et les inconvénients du modèle d'usine simple

Dans ce modèle, la classe de fabrique est la clé de tout le modèle. Il contient les jugements logiques nécessaires, qui peuvent déterminer quel objet de classe spécifique doit être créé en fonction des informations fournies par le monde extérieur. L'utilisateur peut créer directement l'instance requise en fonction de la classe de fabrique lors de son utilisation, sans avoir à comprendre comment ces objets de classe sont créés et comment ils sont organisés. Propice à l'optimisation de l'ensemble de l'architecture logicielle.
Il n'est pas difficile de trouver que les défauts du modèle d'usine simple se reflètent également dans sa classe d'usine. Puisque la classe d'usine concentre la logique de création de toutes les instances, elle n'est pas bonne à == "haute cohésion" ==. En outre, lorsque les catégories de produits spécifiques dans le système continuent d'augmenter, il peut sembler que les catégories d'usine doivent être modifiées en conséquence.L'évolutivité n'est pas très bonne