Implement the Creational Design Patterns

src/practice/creational/builder/BuilderDemo.java

@@ -0,0 +1,21 @@
+package practice.creational.builder;
+
+import practice.creational.builder.CustomPizza.PizzaChef;
+import practice.creational.builder.PizzaElement.DoughType;
+import practice.creational.builder.PizzaElement.SauceType;
+import practice.creational.builder.PizzaElement.ToppingType;
+
+/**
+ * Example of Builder Design Pattern
+ */
+public final class BuilderDemo {
+
+  public static void main(final String... arguments) {
+
+    new PizzaChef(DoughType.BAKED).setSauceType(SauceType.HOT)
+        .setTopping(ToppingType.CAPSICUM_MUSHROOM).cookPizza().eatPizza();
+
+    new PizzaChef(DoughType.CROSS).setSauceType(SauceType.MILD)
+        .setTopping(ToppingType.CHEESE_CORN_TOMATO).cookPizza().eatPizza();
+  }
+}

src/practice/creational/builder/CustomPizza.java

@@ -0,0 +1,47 @@
+package practice.creational.builder;
+
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import lombok.extern.java.Log;
+
+@Log
+@ToString
+@EqualsAndHashCode
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+public final class CustomPizza {
+
+  @NonNull
+  private final PizzaElement.DoughType doughType;
+  @NonNull
+  private final PizzaElement.SauceType sauceType;
+  @NonNull
+  private final PizzaElement.ToppingType topping;
+
+  public void eatPizza() {
+    log.info("EATING Pizza => " + this);
+  }
+
+  @Setter
+  @ToString
+  @EqualsAndHashCode
+  @RequiredArgsConstructor
+  @Accessors(chain = true)
+  protected static final class PizzaChef {
+
+    @NonNull
+    private final PizzaElement.DoughType doughType;
+
+    private PizzaElement.SauceType sauceType;
+    private PizzaElement.ToppingType topping;
+
+    public CustomPizza cookPizza() {
+      log.info("COOKING Pizza => " + this); // In OVEN
+      return new CustomPizza(doughType, sauceType, topping);
+    }
+  }
+}

src/practice/creational/builder/PizzaElement.java

@@ -0,0 +1,24 @@
+package practice.creational.builder;
+
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@ToString
+@EqualsAndHashCode
+public final class PizzaElement {
+
+  protected enum DoughType {
+
+    BAKED, CROSS
+  }
+
+  protected enum SauceType {
+
+    HOT, MILD
+  }
+
+  protected enum ToppingType {
+
+    CAPSICUM_MUSHROOM, CHEESE_CORN_TOMATO
+  }
+}

src/practice/creational/factory/BronzeCoin.java

@@ -0,0 +1,25 @@
+package practice.creational.factory;
+
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import lombok.extern.java.Log;
+
+@Log
+@ToString
+@EqualsAndHashCode
+@RequiredArgsConstructor
+public final class BronzeCoin implements MetalCoin {
+
+  private static final Integer PRINCIPAL_COST = 2_500;
+
+  @NonNull
+  private final Float demandFactor; // Price MULTIPLIER
+
+  @Override
+  public void printWorth() {
+    final var value = (PRINCIPAL_COST * demandFactor) + " INR";
+    log.info("Monetary WORTH of BRONZE Coin => " + value);
+  }
+}

src/practice/creational/factory/CoinFactory.java

@@ -0,0 +1,18 @@
+package practice.creational.factory;
+
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.extern.java.Log;
+
+@Log
+@EqualsAndHashCode
+public abstract sealed class CoinFactory permits MassFactory, RareFactory {
+
+  protected abstract Float getDemandFactor(); // Get SPECIFIC multiplier
+
+  public MetalCoin mintCoin(@NonNull final CoinType coinType) {
+    var mintedCoin = coinType.getCreator().apply(getDemandFactor());
+    log.info("CATEGORY of Minted COIN => [" + mintedCoin + "]");
+    return mintedCoin; // Return the SPECIFIC category of minted COIN
+  }
+}

src/practice/creational/factory/CoinType.java

@@ -0,0 +1,17 @@
+package practice.creational.factory;
+
+import java.util.function.Function;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum CoinType {
+
+  BRONZE(BronzeCoin::new), // Holds CONSTRUCTOR
+  SILVER(SilverCoin::new); // Holds CONSTRUCTOR
+
+  @NonNull
+  private final Function<Float, MetalCoin> creator;
+}

src/practice/creational/factory/FactoryDemo.java

@@ -0,0 +1,21 @@
+package practice.creational.factory;
+
+import java.util.List;
+
+/**
+ * Example of Factory Method Design Pattern
+ */
+public final class FactoryDemo {
+
+  public static void main(final String... arguments) {
+
+    createCoinMints().forEach(coinFactory -> {
+      coinFactory.mintCoin(CoinType.BRONZE).printWorth();
+      coinFactory.mintCoin(CoinType.SILVER).printWorth();
+    });
+  }
+
+  private static List<CoinFactory> createCoinMints() {
+    return List.of(new MassFactory(), new RareFactory());
+  }
+}

src/practice/creational/factory/MassFactory.java

@@ -0,0 +1,25 @@
+package practice.creational.factory;
+
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.ToString;
+import lombok.extern.java.Log;
+
+@Log
+@ToString
+@NoArgsConstructor
+public final class MassFactory extends CoinFactory {
+
+  private static final Float DEMAND_FACTOR = 1.2F;
+
+  @Override
+  protected Float getDemandFactor() {
+    return DEMAND_FACTOR;
+  }
+
+  @Override
+  public MetalCoin mintCoin(@NonNull final CoinType coinType) {
+    log.info("Current FACTORY for MINT => [" + this + "]");
+    return super.mintCoin(coinType); // Get CURRENT minted COIN
+  }
+}

src/practice/creational/factory/MetalCoin.java

@@ -0,0 +1,6 @@
+package practice.creational.factory;
+
+public sealed interface MetalCoin permits BronzeCoin, SilverCoin {
+
+  void printWorth(); // Prints monetary WORTH of minted Metal COIN
+}

src/practice/creational/factory/RareFactory.java

@@ -0,0 +1,25 @@
+package practice.creational.factory;
+
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.ToString;
+import lombok.extern.java.Log;
+
+@Log
+@ToString
+@NoArgsConstructor
+public final class RareFactory extends CoinFactory {
+
+  private static final Float DEMAND_FACTOR = 4.8F;
+
+  @Override
+  protected Float getDemandFactor() {
+    return DEMAND_FACTOR;
+  }
+
+  @Override
+  public MetalCoin mintCoin(@NonNull final CoinType coinType) {
+    log.info("Current FACTORY for MINT => [" + this + "]");
+    return super.mintCoin(coinType); // Get CURRENT minted COIN
+  }
+}

src/practice/creational/factory/SilverCoin.java

@@ -0,0 +1,25 @@
+package practice.creational.factory;
+
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import lombok.extern.java.Log;
+
+@Log
+@ToString
+@EqualsAndHashCode
+@RequiredArgsConstructor
+public final class SilverCoin implements MetalCoin {
+
+  private static final Integer PRINCIPAL_COST = 5_000;
+
+  @NonNull
+  private final Float demandFactor; // Price MULTIPLIER
+
+  @Override
+  public void printWorth() {
+    final var value = (PRINCIPAL_COST * demandFactor) + " INR";
+    log.info("Monetary WORTH of SILVER Coin => " + value);
+  }
+}

src/practice/creational/notional/AbstractDemo.java

@@ -0,0 +1,25 @@
+package practice.creational.notional;
+
+import java.util.Arrays;
+import java.util.List;
+import practice.creational.factory.CoinFactory;
+import practice.creational.factory.CoinType;
+
+/**
+ * Example of Abstract Factory Design Pattern
+ */
+public final class AbstractDemo {
+
+  public static void main(final String... arguments) {
+
+    createCoinFactories().forEach(coinFactory -> {
+      coinFactory.mintCoin(CoinType.BRONZE).printWorth();
+      coinFactory.mintCoin(CoinType.SILVER).printWorth();
+    });
+  }
+
+  private static List<CoinFactory> createCoinFactories() {
+    final var factoryTypes = FactoryType.values(); // LIST of Factory TYPES
+    return Arrays.stream(factoryTypes).map(FactoryMaker::makeMint).toList();
+  }
+}

src/practice/creational/notional/FactoryMaker.java

@@ -0,0 +1,21 @@
+package practice.creational.notional;
+
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import lombok.experimental.UtilityClass;
+import lombok.extern.java.Log;
+import practice.creational.factory.CoinFactory;
+
+@Log
+@ToString
+@UtilityClass
+@EqualsAndHashCode
+public final class FactoryMaker {
+
+  public static CoinFactory makeMint(@NonNull final FactoryType factoryType) {
+    final CoinFactory coinFactory = factoryType.getCreator().get(); // Creation
+    log.info("CATEGORY of Coin Minting FACTORY => [" + coinFactory + "]");
+    return coinFactory; // Return the SPECIFIC category of COIN minting FACTORY
+  }
+}

src/practice/creational/notional/FactoryType.java

@@ -0,0 +1,20 @@
+package practice.creational.notional;
+
+import java.util.function.Supplier;
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import practice.creational.factory.CoinFactory;
+import practice.creational.factory.MassFactory;
+import practice.creational.factory.RareFactory;
+
+@Getter
+@RequiredArgsConstructor
+public enum FactoryType {
+
+  MASS(MassFactory::new), // Holds CONSTRUCTOR
+  RARE(RareFactory::new); // Holds CONSTRUCTOR
+
+  @NonNull
+  private final Supplier<CoinFactory> creator;
+}

src/practice/creational/pool/Candidate.java

@@ -0,0 +1,31 @@
+package practice.creational.pool;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import lombok.ToString;
+import lombok.extern.java.Log;
+
+@Log
+@ToString
+@EqualsAndHashCode
+public final class Candidate {
+
+  private static final AtomicInteger counter = new AtomicInteger(0);
+
+  @NonNull
+  private final int id;
+
+  public Candidate() {
+    id = counter.incrementAndGet();
+    try {
+      Thread.sleep(100L); // TIME to BIRTH
+    } catch (final InterruptedException exception) {
+      log.warning(exception.getLocalizedMessage());
+    }
+  }
+
+  public void print() {
+    log.info("INSTANCE from Pool => [" + this + "]");
+  }
+}