Implementing Behavioral Design Patterns

interface ShippingStrategy { Money cost(Order o); }
class GroundShipping implements ShippingStrategy { ... }
class ExpressShipping implements ShippingStrategy { ... }
class Checkout {
    private final ShippingStrategy shipping;
    Checkout(ShippingStrategy s) { this.shipping = s; }
    Money total(Order o) { return o.subTotal().plus(shipping.cost(o)); }
}

class EventBus<E> {
    private final List<Consumer<E>> listeners = new CopyOnWriteArrayList<>();
    public void subscribe(Consumer<E> l) { listeners.add(l); }
    public void publish(E event) { listeners.forEach(l -> l.accept(event)); }
}

interface Command { void execute(); void undo(); }
class TransferCommand implements Command {
    private final Account from, to; private final Money amount;
    public void execute() { from.withdraw(amount); to.deposit(amount); }
    public void undo()    { to.withdraw(amount); from.deposit(amount); }
}

abstract class ReportGenerator {
    public final Report generate() {
        var data = fetch();
        var processed = transform(data);
        return render(processed);
    }
    protected abstract Data fetch();
    protected abstract Data transform(Data d);
    protected Report render(Data d) { return new HtmlReport(d); }
}

abstract class Handler {
    protected Handler next;
    public Handler chain(Handler n) { this.next = n; return n; }
    public final void handle(Request r) {
        if (process(r) == false && next != null) next.handle(r);
    }
    protected abstract boolean process(Request r);
}

interface OrderState { OrderState pay(Order o); OrderState ship(Order o); }
enum States implements OrderState {
    NEW {
        public OrderState pay(Order o)  { o.markPaid(); return PAID; }
        public OrderState ship(Order o) { throw new IllegalStateException(); }
    },
    PAID {
        public OrderState pay(Order o)  { throw new IllegalStateException(); }
        public OrderState ship(Order o) { o.dispatch(); return SHIPPED; }
    },
    SHIPPED { ... }
}

class Editor {
    private String text;
    public Memento save() { return new Memento(text); }
    public void restore(Memento m) { this.text = m.state(); }
    public record Memento(String state) {}
}

interface Logger { void log(String m); }
class NoopLogger implements Logger { public void log(String m) {} }
Logger logger = config.enabled() ? new FileLogger(...) : new NoopLogger();

interface Spec<T> {
    boolean isSatisfiedBy(T t);
    default Spec<T> and(Spec<T> o) { return t -> isSatisfiedBy(t) && o.isSatisfiedBy(t); }
    default Spec<T> or(Spec<T> o)  { return t -> isSatisfiedBy(t) || o.isSatisfiedBy(t); }
    default Spec<T> not()           { return t -> !isSatisfiedBy(t); }
}
Spec<Order> eligible = isPaid.and(notExpired).and(hasStock);

sealed interface OrderState permits New, Paid, Shipped, Cancelled {}
record New() implements OrderState {}
record Paid(Instant paidAt) implements OrderState {}
record Shipped(String tracking) implements OrderState {}
record Cancelled(String reason) implements OrderState {}

String label(OrderState s) {
    return switch (s) {
        case New n          -> "new";
        case Paid p         -> "paid at " + p.paidAt();
        case Shipped sh     -> "shipped " + sh.tracking();
        case Cancelled c    -> "cancelled: " + c.reason();
    };
}