Refactoring Toward Creational Patterns — Hands-On Tasks¶

public class Money {
    private final long amount;
    private final String currency;
    private Money(long amount, String currency) { this.amount = amount; this.currency = currency; }

    public static Money ofCents(long cents, String currency) { return new Money(cents, currency); }
    public static Money ofMajor(double major, String currency) {
        return new Money(Math.round(major * 100), currency);
    }
}

Money fiveDollars = Money.ofMajor(5, "USD");   // unambiguous
Money fiveCents   = Money.ofCents(5, "USD");

public final class ExporterFactory {
    public enum Format { PDF, CSV, HTML }
    public Exporter create(Format f) {
        return switch (f) {
            case PDF  -> new PdfExporter();
            case CSV  -> new CsvExporter();
            case HTML -> new HtmlExporter();
        };
    }
}
// PdfExporter/CsvExporter/HtmlExporter drop `public` → package-private.
// Clients: exporterFactory.create(Format.PDF) — concretions are now a package secret.

abstract class ConnectionPoolManager {
    final void warmUp() {
        // 15 lines of pool-sizing (ONCE) ...
        DataSource ds = createDataSource();    // polymorphic hook
        // 10 lines registering ds (ONCE) ...
    }
    protected abstract DataSource createDataSource();   // Factory Method
}
class PostgresPoolManager extends ConnectionPoolManager {
    protected DataSource createDataSource() { return new PgDataSource(); }
}
class MySqlPoolManager extends ConnectionPoolManager {
    protected DataSource createDataSource() { return new MySqlDataSource(); }
}

public class EmailMessage {
    private final String to, subject, body; private final boolean html; private final List<String> cc;
    private EmailMessage(Builder b){ to=b.to; subject=b.subject; body=b.body; html=b.html; cc=b.cc; }

    public static class Builder {
        private final String to;
        private String subject = ""; private String body = "";
        private boolean html = false; private List<String> cc = List.of();
        public Builder(String to){ this.to = to; }
        public Builder subject(String s){ this.subject = s; return this; }
        public Builder body(String b){ this.body = b; return this; }
        public Builder html(boolean h){ this.html = h; return this; }
        public Builder cc(List<String> c){ this.cc = List.copyOf(c); return this; }
        public EmailMessage build() {
            if (to == null || to.isBlank()) throw new IllegalStateException("recipient required");
            return new EmailMessage(this);
        }
    }
}
EmailMessage m = new EmailMessage.Builder("a@x.com").subject("Hi").body("Body").html(true).build();

class PaymentGatewayFactory {
    PaymentGateway create(String provider, Map<String,String> secrets) {
        return switch (provider) {
            case "stripe" -> new StripeGateway(secrets.get("stripe_key"));
            case "paypal" -> new PaypalGateway(secrets.get("pp_id"), secrets.get("pp_secret"));
            default        -> new MockGateway();
        };
    }
}
class CheckoutService {
    private final PaymentGateway gateway;
    CheckoutService(PaymentGateway gateway) { this.gateway = gateway; }   // just receives it
    void charge(Order o) { gateway.charge(o.total()); }
}

class IngestionComponentFactory {
    Parser    newParser(String ext)   { return ext.equals("csv") ? new CsvParser() : new JsonParser(); }
    Validator newValidator(Schema s)  { return new SchemaValidator(s); }
    Sink      newSink(Config c)       { return c.dryRun() ? new NullSink() : new DbSink(c.dsn()); }
}
class IngestionPipeline {
    private final IngestionComponentFactory factory;
    IngestionPipeline(IngestionComponentFactory factory) { this.factory = factory; }
    void run(Path file) { /* ingestion only, asks factory for components */ }
}

interface ThemeFactory { Button createButton(); Panel createPanel(); Icon createIcon(); }
class DarkThemeFactory implements ThemeFactory {
    public Button createButton(){ return new DarkButton(); }
    public Panel  createPanel(){  return new DarkPanel();  }
    public Icon   createIcon(){   return new DarkIcon();   }
}
class LightThemeFactory implements ThemeFactory { /* light family */ }
// Root: ThemeFactory tf = dark ? new DarkThemeFactory() : new LightThemeFactory();

class SimulationRunner {
    private final Grid prototype = new Grid(parseTerrain("map.dat"), computeDefaultRules()); // once
    Grid run(String scenario) {
        Grid g = prototype.copy();       // cheap
        applyScenario(g, scenario);
        return g;
    }
}
final class Grid {
    private final Terrain terrain;   // immutable → share
    private Ruleset rules;           // mutable → deep-copy
    Grid(Terrain t, Ruleset r){ terrain=t; rules=r; }
    Grid(Grid o){ this.terrain = o.terrain; this.rules = o.rules.copy(); }
    Grid copy(){ return new Grid(this); }
}

class FeatureFlags {
    private final Map<String,Boolean> flags;
    public FeatureFlags(Map<String,Boolean> flags) { this.flags = flags; }   // injectable
    public boolean isOn(String key) { return flags.getOrDefault(key, false); }
}
class Renderer {
    private final FeatureFlags flags;
    Renderer(FeatureFlags flags) { this.flags = flags; }     // explicit dependency
    void draw() { if (flags.isOn("new_ui")) drawNewUi(); }
}
// Root: FeatureFlags flags = new FeatureFlags(loadFromEnv()); new Renderer(flags);