Model Builder

Modalità Builder (Generatore Pattern) utilizzando una pluralità di oggetti semplici per costruire passo dopo passo in un oggetto complesso. Questo tipo di modelli di progettazione appartengono creare schema, che fornisce il modo migliore per creare oggetti.

Classe Builder è un passo per passo per costruire l'oggetto finale. La classe Builder è indipendente dagli altri oggetti.

introduzione

Scopi: un complesso costruire sua separazione rappresentazione, in modo che lo stesso processo di costruzione può creare rappresentazioni differenti.

Principalmente per risolvere: la soluzione principale nel sistema software, a volte di fronte a "un oggetto complesso" per creare lavoro, che è di solito un certo algoritmo consiste di varie parti del sub-oggetto, a causa di cambiamenti nella domanda, le varie parti di questa complessa spesso faccia un drastico cambiamento, ma combinerà algoritmo è relativamente stabile.

Quando utilizzare: non cambierà alcuni dei componenti di base, e loro combinazioni in continuo mutamento volte.

Come risolvere: la cambiata e invariato separati.

La chiave codice: Builder: creare e fornire esempi, Direttore: gestione delle dipendenze costruito in esempio.

Esempi di applicazione: 1, andare a KFC, hamburger, coca cola, patatine fritte, ali di pollo fritte, ecc è costante, e la sua composizione è in continua evoluzione, generando un cosiddetto "pacchetto".2, JAVA in StringBuilder.

Vantaggi: 1, un costruttore indipendente, facile da espandere.2, facile controllare i dettagli di rischio.

Svantaggi: 1, il prodotto deve avere in comune, la gamma è limitata.2. I complessi cambiamenti interni, ci saranno un sacco di classi di costruzione.

scenari di utilizzo: 1, è necessario generare l'oggetto ha una struttura interna complessa.2, devono essere generati all'interno della proprietà dell'oggetto stesso interdipendenti.

Nota: La differenza tra il modello di impianto è: modello Builder è più interessato con l'ordine di montaggio delle parti.

realizzazione

Partiamo dal presupposto che un fast-food caso ristorante aziendale, in cui un pacchetto può essere un hamburger tipico (Burger) e un bicchiere di freddo (bevanda fredda). Burger (Burger) può essere hamburger vegetali (Veg Burger) o hamburger di pollo (pollo Burger), sono avvolti nel vassoio della carta. Freddo (bevanda fredda) può essere una Coca-Cola (coke) o Pepsi (Pepsi), sono confezionati in bottiglie.

Creeremo una rappresentazione di prodotti alimentari (come hamburger e fredda) di interfacciaarte l'interfaccia implementazione della classe entitàdel lotto,e un'entità interfaccia e implementazione rappresentaimballaggioalimenti interfacciaImballaggioconfezionamento, Amburgo è il pacchetto nel vassoio della carta è freddo confezionati in bottiglie.

Viene creato unclassi di cibo,ArrayList e unpastoper creare diversi tipi di oggetti attraverso una combinazione diMealBuilder ArticoloconItem.BuilderPatternDemo, dimostriamo l'uso di classeMealBuilderper creare unpasto.

fase 1

Crea un'interfaccia ingresso di cibo e imballaggi per alimenti.

Item.java

Interfaccia pubblica Item {
   Nome public String ();
   Imballaggio pubblico imballaggio ();
   prezzo float pubblico ();	
}

Packing.java

interfaccia pubblica di imballaggio {
   Public String pack ();
}

fase 2

Imballaggio creare classi di entità implementano l'interfaccia.

Wrapper.java

implementa public class Wrapper imballaggio {

   @Override
   Public String pack () {
      tornare "wrapper";
   }
}

Bottle.java

implementa public class bottiglia imballaggio {

   @Override
   Public String pack () {
      tornare "bottiglia";
   }
}

fase 3

Creare un'interfaccia astratta classe Item, la classe fornisce una funzione predefinita.

Burger.java

public abstract class Burger implementa item {

   @Override
   Imballaggio pubblico imballaggio () {
      restituire nuova Wrapper ();
   }

   @Override
   prezzo galleggiante astratto pubblico ();
}

ColdDrink.java

classe astratta pubblica ColdDrink implementa item {

	@Override
	Imballaggio pubblico imballaggio () {
       restituire nuova bottiglia ();
	}

	@Override
	prezzo galleggiante astratto pubblico ();
}

fase 4

La creazione di un ampliamento della classi di entità Burger e ColdDrink.

VegBurger.java

public class VegBurger estende Burger {

   @Override
   prezzo float pubblico () {
      tornare 25.0f;
   }

   @Override
   String name pubblico () {
      tornare "Veg Burger";
   }
}

ChickenBurger.java

public class Chickenburger estende Burger {

   @Override
   prezzo float pubblico () {
      tornare 50.5f;
   }

   @Override
   String name pubblico () {
      tornare "Chicken Burger";
   }
}

Coke.java

public class Coke estende ColdDrink {

   @Override
   prezzo float pubblico () {
      tornare 30.0f;
   }

   @Override
   String name pubblico () {
      tornare "Coke";
   }
}

Pepsi.java

public class Pepsi estende ColdDrink {

   @Override
   prezzo float pubblico () {
      tornare 35.0f;
   }

   @Override
   String name pubblico () {
      tornare "Pepsi";
   }
}

fase 5

Creare una classe pasto, con l'oggetto Item sopra definito.

Meal.java

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

public class pasto {
   Elenco privato <item> articoli = new ArrayList <item> ();	

   public void addItem (Item item) {
      Items.Add (voce);
   }

   float pubblico getCost () {
      costo float = 0.0f;
      per (voce dell'oggetto: articoli) {
         cost + = item.price ();
      }		
      tornare costo;
   }

   showItems public void () {
      per (voce dell'oggetto: articoli) {
         System.out.print ( "Voce:" + item.name ());
         System.out.print (. ", Packing:" + Item.packing () pack ());
         System.out.println ( "Prezzo:" + item.price ());
      }		
   }	
}

passo 6

MealBuilder creare una classe, il costruttore vero e proprio responsabile della creazione dell'oggetto di classe pasto.

MealBuilder.java

public class MealBuilder {

   pubblica Meal prepareVegMeal () {
      pasto pasto = new pasto ();
      meal.addItem (nuova VegBurger ());
      meal.addItem (New Coke ());
      tornare pasto;
   }   

   pubblica Meal prepareNonVegMeal () {
      pasto pasto = new pasto ();
      meal.addItem (nuova Chickenburger ());
      meal.addItem (nuova Pepsi ());
      tornare pasto;
   }
}

passo 7

BuiderPatternDemo utilizzare MealBuider per dimostrare la modalità builder (Builder Pattern).

BuilderPatternDemo.java

public class BuilderPatternDemo {
   Main (string [] args) {public static void
      MealBuilder mealBuilder = new MealBuilder ();

      Pasto vegMeal = mealBuilder.prepareVegMeal ();
      System.out.println ( "Veg pasto");
      vegMeal.showItems ();
      System.out.println ( "Costo totale:" + vegMeal.getCost ());

      Pasto nonVegMeal = mealBuilder.prepareNonVegMeal ();
      System.out.println ( "\ n \ nNon-Veg pasto");
      nonVegMeal.showItems ();
      System.out.println ( "Costo totale:" + nonVegMeal.getCost ());
   }
}

step 8

Verifica uscita.

veg Meal
Articolo: Veg Burger, Imballaggio: Wrapper, Prezzo: 25.0
Articolo: Coke, di imballaggio: Bottiglia, Prezzo: 30.0
Costo totale: 55.0


Non-Veg Meal
Articolo: Chicken Burger, Imballaggio: Wrapper, Prezzo: 50.5
Articolo: Pepsi, imballaggio: Bottiglia, Prezzo: 35.0
Costo totale: 85.5