Fluent Interface — Practice Tasks¶

public final class Report {
    private final StringBuilder b = new StringBuilder();
    public Report title(String t) { b.append("# ").append(t).append("\n"); return this; }
    public Report line(String s)  { b.append("- ").append(s).append("\n"); return this; }
    public String render()        { return b.toString(); }   // terminal
}
String out = new Report().title("Daily").line("3 deploys").line("0 incidents").render();

public final class Sql {
    private String cols, table, where, orderBy;
    private Integer limit;
    public static Sql select(String cols) { Sql s = new Sql(); s.cols = cols; return s; }
    public Sql from(String t)    { this.table = t; return this; }
    public Sql where(String w)   { this.where = w; return this; }
    public Sql orderBy(String o) { this.orderBy = o; return this; }
    public Sql limit(int n)      { this.limit = n; return this; }
    public String build() {
        StringBuilder q = new StringBuilder("SELECT ").append(cols).append(" FROM ").append(table);
        if (where != null)   q.append(" WHERE ").append(where);
        if (orderBy != null) q.append(" ORDER BY ").append(orderBy);
        if (limit != null)   q.append(" LIMIT ").append(limit);
        return q.toString();
    }
}
String sql = Sql.select("id, name").from("users").where("active").limit(10).build();

public record Config(String region, Duration timeout, int retries) {
    public Config withRegion(String r)    { return new Config(r, timeout, retries); }
    public Config withTimeout(Duration t) { return new Config(region, t, retries); }
    public Config withRetries(int n)      { return new Config(region, timeout, n); }
}
Config base = new Config("us-east-1", Duration.ofSeconds(5), 3);
Config eu   = base.withRegion("eu-west-1").withRetries(5);   // base untouched

public final class Check<T> {
    private final T value; private final List<String> errs = new ArrayList<>();
    private Check(T v) { this.value = v; }
    public static <T> Check<T> that(T v) { return new Check<>(v); }
    public Check<T> require(Predicate<T> p, String msg) {
        if (!p.test(value)) errs.add(msg); return this;
    }
    public T orThrow() {
        if (!errs.isEmpty()) throw new IllegalArgumentException(String.join("; ", errs));
        return value;
    }
}
String name = Check.that(input)
    .require(Objects::nonNull, "required")
    .require(s -> s != null && s.length() <= 50, "too long")
    .orThrow();

Optional<Integer> out = Optional.of(raw)
    .map(Fns::parse)
    .filter(Fns::isValid)
    .map(Fns::normalize);   // empty short-circuits remaining maps

public final class Email {
    public interface FromStep    { ToStep from(String a); }
    public interface ToStep      { SubjectStep to(String a); }
    public interface SubjectStep { Sendable subject(String s); }
    public interface Sendable    { Sendable cc(String a); Email build(); }

    public static FromStep builder() { return new Impl(); }
    private static final class Impl implements FromStep, ToStep, SubjectStep, Sendable {
        String from, to, subject; List<String> cc = new ArrayList<>();
        public ToStep      from(String a)    { this.from = a; return this; }
        public SubjectStep to(String a)      { this.to = a; return this; }
        public Sendable    subject(String s) { this.subject = s; return this; }
        public Sendable    cc(String a)      { cc.add(a); return this; }
        public Email       build()           { return new Email(from, to, subject, List.copyOf(cc)); }
    }
    private Email(String f, String t, String s, List<String> cc) { /* ... */ }
}
// Email.builder().from("a@x").to("b@y").subject("Hi").build();
// builder().to(...) -> compile error

Notification n = new Notification();
n.setTo("a@x"); n.setTitle("Hi"); n.setBody("...");
n.send();

public final class Notification {
    private String to, title, body;
    public Notification to(String t)    { this.to = t; return this; }
    public Notification title(String t) { this.title = t; return this; }
    public Notification body(String b)  { this.body = b; return this; }
    public void send() { /* dispatch */ }   // terminal (void here — nothing to return)
}
new Notification().to("a@x").title("Hi").body("...").send();

public final class Assert<T> {
    private final T actual;
    private Assert(T a) { this.actual = a; }
    public static <T> Assert<T> assertThat(T a) { return new Assert<>(a); }
    public Assert<T> isNotNull() {
        if (actual == null) throw new AssertionError("expected non-null"); return this;
    }
    public Assert<T> isEqualTo(T expected) {
        if (!actual.equals(expected)) throw new AssertionError("expected " + expected + " but was " + actual);
        return this;
    }
}
// assertThat(x).isNotNull().isEqualTo(y);

List<Integer> out = IntStream.range(0, 10).boxed()
    .map(x -> x * 2)
    .filter(x -> x > 5)
    .collect(Collectors.toList());   // terminal triggers single fused pass