תבנית Builder: בניית אובייקט מורכב צעד אחר צעד, מימוש מלא, Fluent Builder ו-Director

import java.util.List;

// Builder: one method per construction step.
interface RouteBuilder {
    void start(String place);
    void leg(String to, int km);
    void finish();
}

// ConcreteBuilder 1: builds human-readable driving directions.
class DirectionsBuilder implements RouteBuilder {
    private final StringBuilder text = new StringBuilder();
    private int step = 0;

    @Override public void start(String place) {
        text.append("Start at ").append(place).append('\n');
    }

    @Override public void leg(String to, int km) {
        step++;
        text.append(step).append(". Drive ").append(km).append(" km to ").append(to).append('\n');
    }

    @Override public void finish() {
        text.append("Arrived.");
    }

    String getResult() { return text.toString(); }
}

// A second, unrelated product type.
class TripSummary {
    private final String origin;
    private final String destination;
    private final int totalKm;
    private final int legs;

    TripSummary(String origin, String destination, int totalKm, int legs) {
        this.origin = origin;
        this.destination = destination;
        this.totalKm = totalKm;
        this.legs = legs;
    }

    @Override public String toString() {
        return origin + " -> " + destination + ": " + totalKm + " km in " + legs + " legs";
    }
}

// ConcreteBuilder 2: builds the summary from the same steps.
class SummaryBuilder implements RouteBuilder {
    private String origin;
    private String destination;
    private int totalKm = 0;
    private int legs = 0;

    @Override public void start(String place) { origin = place; }

    @Override public void leg(String to, int km) {
        destination = to;
        totalKm += km;
        legs++;
    }

    @Override public void finish() {
        // Nothing to add at the end for this representation.
    }

    TripSummary getResult() { return new TripSummary(origin, destination, totalKm, legs); }
}

// Director: owns the construction order, knows nothing about representations.
class RouteDirector {
    private final List<String> stops;
    private final List<Integer> distances;

    RouteDirector(List<String> stops, List<Integer> distances) {
        if (distances.size() != stops.size() - 1) {
            throw new IllegalArgumentException("need one distance per leg");
        }
        this.stops = stops;
        this.distances = distances;
    }

    void construct(RouteBuilder builder) {
        builder.start(stops.get(0));
        for (int i = 1; i < stops.size(); i++) {
            builder.leg(stops.get(i), distances.get(i - 1));
        }
        builder.finish();
    }
}

public class Main {
    public static void main(String[] args) {
        RouteDirector director = new RouteDirector(
            List.of("Haifa", "Hadera", "Tel Aviv", "Jerusalem"),
            List.of(50, 50, 65));

        DirectionsBuilder directions = new DirectionsBuilder();
        director.construct(directions);
        System.out.println(directions.getResult());

        SummaryBuilder summary = new SummaryBuilder();
        director.construct(summary);
        System.out.println(summary.getResult());
    }
}

Start at Haifa
1. Drive 50 km to Hadera
2. Drive 50 km to Tel Aviv
3. Drive 65 km to Jerusalem
Arrived.
Haifa -> Jerusalem: 165 km in 3 legs

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

// The product: immutable and always complete once built.
final class Email {
    private final String to;
    private final String subject;
    private final List<String> cc;
    private final boolean urgent;

    private Email(Builder b) {
        this.to = b.to;
        this.subject = b.subject;
        this.cc = List.copyOf(b.cc);
        this.urgent = b.urgent;
    }

    static Builder builder(String to) { return new Builder(to); }

    @Override public String toString() {
        return (urgent ? "[URGENT] " : "") + subject + " -> " + to + (cc.isEmpty() ? "" : " cc " + cc);
    }

    // The builder collects values, then validates once in build().
    static final class Builder {
        private final String to;                 // required
        private String subject = "(no subject)"; // optional, with a default
        private final List<String> cc = new ArrayList<>();
        private boolean urgent = false;

        private Builder(String to) { this.to = to; }

        Builder subject(String value) { this.subject = value; return this; }
        Builder cc(String address) { this.cc.add(address); return this; }
        Builder urgent() { this.urgent = true; return this; }

        Email build() {
            if (!to.contains("@")) {
                throw new IllegalStateException("invalid recipient: " + to);
            }
            return new Email(this);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Email plain = Email.builder("[email protected]").build();
        Email full = Email.builder("[email protected]")
            .subject("Disk almost full")
            .cc("[email protected]")
            .urgent()
            .build();
        System.out.println(plain);
        System.out.println(full);
    }
}

class DirectionsBuilder:
    def __init__(self):
        self.lines, self.step = [], 0

    def start(self, place):
        self.lines.append(f"Start at {place}")

    def leg(self, to, km):
        self.step += 1
        self.lines.append(f"{self.step}. Drive {km} km to {to}")

    def finish(self):
        self.lines.append("Arrived.")

    def result(self):
        return "\n".join(self.lines)


class SummaryBuilder:
    def __init__(self):
        self.origin = self.destination = None
        self.total_km = self.legs = 0

    def start(self, place):
        self.origin = place

    def leg(self, to, km):
        self.destination, self.total_km, self.legs = to, self.total_km + km, self.legs + 1

    def finish(self):
        pass

    def result(self):
        return f"{self.origin} -> {self.destination}: {self.total_km} km in {self.legs} legs"


def construct(stops, distances, builder):
    builder.start(stops[0])
    for stop, km in zip(stops[1:], distances):
        builder.leg(stop, km)
    builder.finish()


for builder in (DirectionsBuilder(), SummaryBuilder()):
    construct(["Haifa", "Hadera", "Tel Aviv", "Jerusalem"], [50, 50, 65], builder)
    print(builder.result())