1 Übersicht
Das Builder-Muster (Builder Pattern) wird hauptsächlich zum „Schritt-für-Schritt-Aufbau eines komplexen Objekts“ verwendet. Dabei handelt es sich bei „Schritt für Schritt“ um einen stabilen Algorithmus, während sich die verschiedenen Teile des komplexen Objekts häufig ändern. Daher wird das Builder-Muster hauptsächlich zur Lösung der sich ändernden Anforderungen des „Objektteils“ verwendet. Dies ermöglicht eine detailliertere Kontrolle über den Objektkonstruktionsprozess.
2 Beispiele
Am Beispiel der Herstellung von Mobiltelefonen ist jedes Mobiltelefon in Bildschirm, CPU und Akku unterteilt. Derzeit werden zwei Arten von Mobiltelefonen hergestellt: Apple und Samsung.
Apfel:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.before.use;
import java.util.ArrayList;
java.util.List importieren;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche Klasse ApplePhone {
List<String> parts = new ArrayList<String>();
public void createCPU() {
parts.add("CUP: Qualcomm");
}
public void createScreen() {
parts.add("BILDSCHIRM: JDI");
}
public void createBattery() {
parts.add("BATTERIE: DeSai");
}
public void show(){
System.out.print("Produktkomponenteninformationen:");
for(String part : parts){
System.out.print(part + "/t");
}
}
}
Samsung:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.before.use;
import java.util.ArrayList;
java.util.List importieren;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche Klasse SamsungPhone {
List<String> parts = new ArrayList<String>();
public void createCPU() {
parts.add("CUP: MTK");
}
public void createScreen() {
parts.add("BILDSCHIRM: Samsung");
}
public void createBattery() {
parts.add("BATTERIE: DeSai");
}
public void show(){
System.out.print("Produktkomponenteninformationen:");
for(String part : parts){
System.out.print(part + "/t");
}
}
}
Testkunde:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.before.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche Klasse BuilderTest {
privates statisches ApplePhone iphone = neues ApplePhone();
privates statisches SamsungPhone samPhone = new SamsungPhone();
public static void main(String args[]){
iphone.createCPU();
iphone.createScreen();
iphone.createBattery();
iphone.show();
samPhone.createCPU();
samPhone.createScreen();
samPhone.createBattery();
samPhone.show();
}
}
Haben Sie ein Problem gefunden? Das heißt, jeder Prozess zur Herstellung von Mobiltelefonen ist derselbe, aber die spezifische Verarbeitung jedes Prozesses ist unterschiedlich. Es gibt nur wenige Schritte Verarbeitung der einzelnen Prozessänderungen, daraus können wir das Unveränderliche, „Unveränderte, um allen Änderungen gerecht zu werden“, extrahieren und das Veränderliche auf bestimmte Produkte übertragen.
Wie geht das konkret? Diesmal ist der Builder-Modus praktisch.
Werfen wir zunächst einen Blick auf die Telefonoberfläche:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
import java.util.ArrayList;
java.util.List importieren;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche abstrakte Klasse Telefon {
protected List<String> parts = new ArrayList<String>();
public void add(String part){
parts.add(part);
}
public void show(){
System.out.print("Produktkomponenteninformationen:");
for(String part : parts){
System.out.print(part + "/t");
}
}
}
Kategorie der Apple-Handys:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche Klasse ApplePhone erweitert Phone{
}
Samsung-Handykategorie:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche Klasse SamsungPhone erweitert Phone{
}
Definieren Sie dann einen Interface Builder für den Produktionsschritt:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentlicher Schnittstellen-Builder {
public void buildCPU();
public void buildScreen();
public void buildBattery();
öffentliches Telefon getPhone();
}
Builder für iPhone:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
Die öffentliche Klasse ApplePhoneBuilder implementiert Builder{
privates Telefon phone = new ApplePhone();
@Override
public void buildCPU() {
phone.add("CUP: Qualcomm");
}
@Override
public void buildScreen() {
phone.add("BILDSCHIRM: JDI");
}
@Override
public void buildBattery() {
phone.add("BATTERIE: DeSai");
}
@Override
öffentliches Telefon getPhone() {
Telefon zurückgeben;
}
}
Builder für Samsung-Handys:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
Die öffentliche Klasse SamsungPhoneBuilder implementiert Builder{
privates Telefon phone = neues SamsungPhone();
@Override
public void buildCPU() {
phone.add("CUP: MTK");
}
@Override
public void buildScreen() {
phone.add("BILDSCHIRM: Samsung");
}
@Override
public void buildBattery() {
phone.add("BATTERIE: DeSai");
}
@Override
öffentliches Telefon getPhone() {
Telefon zurückgeben;
}
}
Direktor, der die spezifische Produktion von Mobiltelefonen leitet:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentlicher Klassenleiter {
privater Bauunternehmer;
öffentlicher Direktor(Builder Builder){
this.builder = Builder;
}
öffentliches void-Konstrukt(){
builder.buildCPU();
builder.buildScreen();
builder.buildBattery();
}
}
Schreiben Sie abschließend eine Testklasse:
Kopieren Sie den Codecode wie folgt:
Paket org.scott.builder.after.use;
/**
* @Autor Scott
* @Version 20.11.2013
* @Beschreibung
*/
öffentliche Klasse BuilderTest {
privater statischer Builder iPhoneBuilder = new ApplePhoneBuilder();
privater statischer Builder samPhoneBuilder = new SamsungPhoneBuilder();
public static void main(String[] args) {
Director Director = neuer Director(iPhoneBuilder);
Director.construct();
Telefon phone = iPhoneBuilder.getPhone();
System.out.println("iphone");
phone.show();
Director = neuer Director(samPhoneBuilder);
Director.construct();
phone = samPhoneBuilder.getPhone();
System.out.println("/nsamSung");
phone.show();
}
}
Laufergebnisse:
Kopieren Sie den Codecode wie folgt:
iPhone
Produktteilinformationen: BECHER: Qualcomm BILDSCHIRM: JDI BATTERIE: DeSai
Samsung
Produktteilinformationen: BECHER: MTK BILDSCHIRM: Samsung BATTERIE: DeSai
Die beiden Phone-Entitätsklassen sind hier leer. Wenn dies der Fall ist, können sie weggelassen werden. Wenn die Phone-Schnittstelle auch weggelassen werden kann, bleiben nur die Director-, Builder- und bestimmte Builder-Implementierungsklassen übrig. Darüber hinaus handelt es sich bei der ApplePhone-Klasse und der SamsungPhone-Klasse um zwei unterschiedliche Mobiltelefonmarken Wie kann also der Rückgabewert der in der Builder-Schnittstelle angegebenen Methode getPhone () ermittelt werden?
Unabhängig davon, ob der Rückgabewerttyp ApplePhone oder SamsungPhone ist, treten Probleme auf, da die Typen der zurückgegebenen Ergebnisse nicht einheitlich sind. Zu diesem Zeitpunkt kann Phone als leere Schnittstelle definiert werden (eine Schnittstelle, die keine Methoden enthält) und dann diese spezifischen Produktklassen, die keine Beziehung zueinander haben, diese Schnittstelle implementieren lassen Dann ist der Rückgabewerttyp von getPhone(. )-Methode, die in der Builder-Schnittstelle angegeben ist. Es handelt sich immer noch um einen Telefontyp, der das Problem löst. In diesem Fall ist es jedoch nicht erforderlich, den Builder-Modus zu verwenden.