[JAVA] Modèle de conception (1): AbstractFactory

Qu'est-ce que Abstract Factory

En créant une classe (Factory) spécialisée dans l'instanciation Un modèle de conception qui crée définitivement des instances pertinentes. En d'autres termes, une implémentation dans laquelle les instances qui peuvent être créées sont déterminées pour chaque classe Factory.

Étape ①

Créez une classe (= classe Factory) qui crée des classes associées. ** Exemple): Tokyo et le japonais, Washington DC et l'anglais sont liés. ** **

Factory.java

public interface Factory {
	Capital getCapital();
	Language getLanguage();
}

JapanFactory.java

//Classe d'usine japonaise
public class JapanFactory implements Factory {
	@Override
	public Capital getCapital() {
		return new Tokyo(); //La capitale est Tokyo
	}

	@Override
	public Language getLanguage() {
		return new Japanese(); //La langue est le japonais
	}
}

UsaFactory.java

//Classe d'usine américaine
public class UsaFactory implements Factory {
	@Override
	public Capital getCapital() {
		return new WashingtonDC(); //La capitale est Washington DC
	}

	@Override
	public Language getLanguage() {
		return new English(); //La langue est l'anglais
	}
}

Étape ②

Créez une classe qui hérite de la classe abstraite qui est la valeur de retour de la méthode implémentée dans l'interface Factory. Cette classe est la classe qui est réellement retournée par chaque classe Factory. ** Exemple): la classe Tokyo qui hérite de la classe Capital et la classe Washington DC sont en fait renvoyées par la classe Factory. ** **

Capital.java

public abstract class Capital {
    //Les champs ici ne sont pas particulièrement pertinents pour la description de AbstractFactory.
	protected String name;
	protected int population;
}

Tokyo.java

public class Tokyo extends Capital {
	public Tokyo() {
		this.name = "Tokyo";
		this.population = 13510000;
	}
}

WashingtonDC.java

public class WashingtonDC extends Capital {
	public WashingtonDC() {
		this.name = "Washington D.C";
		this.population = 601723;
	}
}

Étape ③

Implémentez le processus de génération de la classe Factory côté appelant. À ce stade, une branche pour changer la classe Factory est requise.

Main.java

public class Main {
	public static void main(String[] args) {
		String name = "Japan";
		Factory factory = createFactory(name);
		Capital capital = factory.getCapital();
		Language language = factory.getLanguage();
		System.out.println("Le nom de la capitale est" + capital.name);
		System.out.println("Population" + capital.population);
	}
	
	private static Factory createFactory(String name) {
		switch (name) {
			case "Japan":
				return new JapanFactory();
			case "USA":
				return new UsaFactory();
			default:
				throw new IllegalArgumentException();
		}
	}
}

Résultat d'exécution

Le nom de la capitale est Tokyo
La population est de 13510000

mérite

En créant une instance via la classe Factory, vous pouvez créer en toute sécurité une instance associée. ** → En créant une instance Japan Factory, vous pouvez toujours créer une instance Tokyo et une instance japonaise. ** ** (Si vous créez explicitement une instance, vous pouvez créer une instance avec la mauvaise combinaison.)

De plus, puisque la valeur de retour est acquise par la classe abstraite, l'appelant n'a pas à se soucier de l'implémentation interne de la classe Factory. ** → Il n'est pas nécessaire de connaître le type d'implémentation de la classe Tokyo ou de la classe Washington DC. ** **