[JAVA] Modèle de méthode d'usine

Modèle de méthode d'usine

Dans le modèle de méthode de modèle , le cadre de traitement est créé du côté de la superclasse et le traitement spécifique est étoffé du côté de la sous-classe. Le modèle de méthode d'usine est une application de ce modèle à la scène d'instanciation.

Le rôle du produit

Une classe abstraite qui définit l'interface qu'une instance générée par ce modèle doit avoir. Le contenu spécifique est déterminé par le rôle du produit en béton.

package factoryMethod;

public abstract class Product {
	public abstract void use();
}

Le rôle du créateur

Une classe abstraite qui crée un rôle Product. Le contenu spécifique est déterminé par Contrete Creator. Le rôle de créateur ne sait rien du rôle de produit concret qu'il crée réellement. La seule chose que sait le rôle Créateur est que si vous appelez le rôle Produit et la méthode d'instanciation, le Produit sera créé. En remplaçant l'instanciation réelle par new par l'appel de méthode pour l'instanciation, la superclasse est libérée de la liaison par le nom de classe concret.

package factoryMethod;

public abstract class Factory {
	public final Product create(String owner) {
		Product p = createProduct(owner);
		registerProduct(p);
		return p;
	}

	protected abstract Product createProduct(String owner);
	protected abstract void registerProduct(Product product);

}

Le rôle du produit en béton

Déterminez des produits spécifiques.

package factoryMethod;

public class IdCard extends Product {
	private String owner;
	 public IdCard(String owner) {
		 System.out.println(owner + "Faire une carte");
		 this.owner = owner;
	}

	 @Override
	 public void use() {
		 System.out.println(owner + "Utilisez la carte");
	 }

	 public String getOwner() {
		 return owner;
	 }
}

Le rôle de Concrete Creator

Définissez une classe pour créer un produit spécifique.

package factoryMethod;

import java.util.ArrayList;
import java.util.List;

public class IdCardFactory extends Factory {
	private List<String> owners = new ArrayList<>();

	@Override
	protected Product createProduct(String owner) {
		return new IdCard(owner);
	}

	@Override
	protected void registerProduct(Product product) {
		owners.add(((IdCard)product).getOwner());
	}

	public List<String> getOwners() {
		return owners;
	}
}

Votre interlocuteur

package factoryMethod;

public class Main {

	public static void main(String[] args) {
		Factory factory = new IdCardFactory();
		Product card1 = factory.create("Tanaka");
		Product card2 = factory.create("Suzuki");
		Product card3 = factory.create("Sato");
		card1.use();
		card2.use();
		card3.use();

	}
}

//Résultat d'exécution
//Faire une carte Tanaka
//Faire une carte Suzuki
//Faire la carte de Sato
//J'utiliserai la carte de Tanaka
//J'utiliserai la carte de Suzuki
//J'utiliserai la carte de Sato

Un numéro de série a été ajouté à la classe IdCard ci-dessus, et la classe IdCardFactory a été modifiée afin d'avoir une table de correspondance entre le numéro de série et le propriétaire.

package factoryMethod;

public class IdCard extends Product {
	private String owner;
	private int serial;
	 public IdCard(String owner, int serial) {
		 System.out.println(owner + "(" + serial + ")Faire une carte");
		 this.owner = owner;
		 this.serial = serial;
	}

	 @Override
	 public void use() {
		 System.out.println(owner + "(" + serial + ")Utilisez la carte");
	 }

	 public String getOwner() {
		 return owner;
	 }

	 public int getSerial() {
		 return serial;
	 }
}

package factoryMethod;

import java.util.HashMap;

public class IdCardFactory extends Factory {
	private HashMap<Integer, String> database = new HashMap<>();
	private int serial = 1;


	@Override
	protected synchronized Product createProduct(String owner) {
		return new IdCard(owner, serial++);
	}

	@Override
	protected void registerProduct(Product product) {
		IdCard card = (IdCard)product;
		database.put(card.getSerial(), card.getOwner());
	}

	public HashMap<Integer, String> getDatabase() {
		return database;
	}
}

package factoryMethod;

public class Main {

	public static void main(String[] args) {
		Factory factory = new IdCardFactory();
		Product card1 = factory.create("Tanaka");
		Product card2 = factory.create("Suzuki");
		Product card3 = factory.create("Sato");
		card1.use();
		card2.use();
		card3.use();

	}

}
//Résultat d'exécution
//Tanaka(1)Faire une carte
//Suzuki(2)Faire une carte
//Sato(3)Faire une carte
//Tanaka(1)Utilisez la carte
//Suzuki(2)Utilisez la carte
//Sato(3)Utilisez la carte

J'ai pu apporter des modifications sans changer la classe Product, la classe Factory et la classe Main.