[JAVA] Modèle de conception (2): constructeur

Qu'est-ce que Builder

Lorsqu'un traitement commun est requis entre plusieurs instances, en masquant ce traitement Une implémentation qui permet le même traitement mais un traitement interne différent. Ici, les Japonais et les Américains sont créés sur la base de la classe People, qui a un champ appelé mainLanguage.

Étape ①

Créez une interface qui définit le traitement commun entre plusieurs instances. (= Classe Builder)

Builder.java

public interface Builder {
	void createMainLanguage(); //Définir la langue principale
	People getResult(); //Instance de retour de personnes
}

People.java

public class People {
    //matière
	private String mainLanguage;

	public String getMainLanguage() {
		return mainLanguage;
	}

	public void setMainLanguage(String mainLanguage) {
		this.mainLanguage = mainLanguage;
	}
	
	void hello() {
		System.out.println("Bonjour. La langue principale est" + mainLanguage);
	}
}

Étape ②

Créez une classe avec une implémentation de l'interface définie. (= Classe ConcreteBuilder) ** Lorsque les types d'instances à créer augmentent, génèrent et augmentent cette classe **

JapaneseBuilder.java

//Constructeur japonais
public class JapaneseBuilder implements Builder {
	private People people;
	
	public JapaneseBuilder() {
		this.people = new People();
	}

	@Override
	public void createMainLanguage() {
		people.setMainLanguage("Japanese"); //Le japonais est la langue principale
	}

	@Override
	public People getResult() {
		return this.people;
	}
}

AmericanBuilder.java

//Constructeur américain
public class AmericanBuilder implements Builder {
	private People people;
	
	public AmericanBuilder() {
		this.people = new People();
	}

	@Override
	public void createMainLanguage() {
		people.setMainLanguage("English"); //L'anglais est la langue principale
	}

	@Override
	public People getResult() {
		return this.people;
	}
}

Étape ③

Créez une classe responsable de l'instanciation réelle. (= Classe de directeur) ** * Assurez-vous d'avoir l'interface comme argument du constructeur ** En passant Builder à Director, il devient indépendant de la classe ConcreteBuilder. En d'autres termes, Director ne sait pas ce qu'est la classe réelle, ConcreteBuilder.

Director.java

public class Director {
	private Builder builder;
	
	public Director(Builder builder) {
		this.builder = builder;
	}
	
	public People construct() {
		builder.createMainLanguage();
		return builder.getResult();
	}
}

Comment appeler

(1) Créez une instance de générateur qui a une interface de générateur comme type. Le traitement réel dépend de ConcreteBuilder au moment de la génération. (2) Créez une instance de Director avec l'instance de générateur comme argument.

Main.java

public class Main {
	public static void main(String[] args) {
		if (args[0].equals("Japanese")) {
			//Générer un constructeur japonais
			Builder builder = new JapaneseBuilder();
			//Director ne fait que passer l'interface Bulder, donc il ne connaît même pas l'implémentation interne de Builder.
			Director director = new Director(builder);
			People people = director.construct();
			people.hello();
		} else if (args[0].equals("English")) {
			Builder builder = new AmericanBuilder();
			Director director = new Director(builder);
			People people = director.construct();
			people.hello();
		} else {
			throw new IllegalArgumentException();
		}
	}
}

• À propos, dans certains cas, le modèle Builder a été réalisé en utilisant une classe abstraite au lieu d'une interface. *
• Lequel est le meilleur ... Je ne sais pas. .. .. *