Design Patterns - Builder Pattern

Il pattern Builder costruisce un oggetto complesso utilizzando oggetti semplici e utilizzando un approccio graduale. Questo tipo di modello di progettazione rientra nel modello di creazione poiché questo modello fornisce uno dei modi migliori per creare un oggetto.

Una classe Builder costruisce l'oggetto finale passo dopo passo. Questo builder è indipendente da altri oggetti.

Implementazione

Abbiamo considerato un caso aziendale di fast-food dove un pasto tipico potrebbe essere un hamburger e una bibita fresca. L'hamburger può essere sia un hamburger vegetariano che un hamburger di pollo e sarà confezionato da un involucro. La bevanda fredda può essere una coca cola o una pepsi e sarà confezionata in una bottiglia.

Creeremo un'interfaccia Item che rappresenta prodotti alimentari come hamburger e bevande fredde e classi concrete che implementano l' interfaccia Item e un'interfaccia Packing che rappresenta l'imballaggio di prodotti alimentari e classi concrete che implementano l' interfaccia Packing poiché l'hamburger sarebbe confezionato in involucri e bevande fredde sarebbe confezionato come bottiglia.

Creiamo quindi una classe Meal con ArrayList of Item e un MealBuilder per costruire diversi tipi di oggetti Meal combinando Item . BuilderPatternDemo , la nostra classe demo utilizzerà MealBuilder per creare un pasto .

Passo 1

Creare un'interfaccia Item che rappresenti il ​​cibo e l'imballaggio.

Item.java

public interface Item {
   public String name();
   public Packing packing();
   public float price();	
}

Packing.java

public interface Packing {
   public String pack();
}

Passo 2

Crea classi concrete che implementano l'interfaccia Packing.

Wrapper.java

public class Wrapper implements Packing {

   @Override
   public String pack() {
      return "Wrapper";
   }
}

Bottle.java

public class Bottle implements Packing {

   @Override
   public String pack() {
      return "Bottle";
   }
}

Passaggio 3

Crea classi astratte che implementano l'interfaccia dell'elemento fornendo funzionalità predefinite.

Burger.java

public abstract class Burger implements Item {

   @Override
   public Packing packing() {
      return new Wrapper();
   }

   @Override
   public abstract float price();
}

ColdDrink.java

public abstract class ColdDrink implements Item {

	@Override
	public Packing packing() {
       return new Bottle();
	}

	@Override
	public abstract float price();
}

Passaggio 4

Crea classi concrete che estendono le classi Burger e ColdDrink

VegBurger.java

public class VegBurger extends Burger {

   @Override
   public float price() {
      return 25.0f;
   }

   @Override
   public String name() {
      return "Veg Burger";
   }
}

ChickenBurger.java

public class ChickenBurger extends Burger {

   @Override
   public float price() {
      return 50.5f;
   }

   @Override
   public String name() {
      return "Chicken Burger";
   }
}

Coke.java

public class Coke extends ColdDrink {

   @Override
   public float price() {
      return 30.0f;
   }

   @Override
   public String name() {
      return "Coke";
   }
}

Pepsi.java

public class Pepsi extends ColdDrink {

   @Override
   public float price() {
      return 35.0f;
   }

   @Override
   public String name() {
      return "Pepsi";
   }
}

Passaggio 5

Crea una classe Meal con oggetti Item definiti sopra.

Pasto.java

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

public class Meal {
   private List<Item> items = new ArrayList<Item>();	

   public void addItem(Item item){
      items.add(item);
   }

   public float getCost(){
      float cost = 0.0f;
      
      for (Item item : items) {
         cost += item.price();
      }		
      return cost;
   }

   public void showItems(){
   
      for (Item item : items) {
         System.out.print("Item : " + item.name());
         System.out.print(", Packing : " + item.packing().pack());
         System.out.println(", Price : " + item.price());
      }		
   }	
}

Passaggio 6

Creare una classe MealBuilder, la vera classe builder responsabile della creazione di oggetti Meal.

MealBuilder.java

public class MealBuilder {

   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   

   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

Passaggio 7

BuiderPatternDemo usa MealBuider per dimostrare il modello del generatore.

BuilderPatternDemo.java

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

      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " + vegMeal.getCost());

      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " + nonVegMeal.getCost());
   }
}

Passaggio 8

Verifica l'output.

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0


Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5