Decorator Pattern: Adding Behavior Without Subclassing

// VIOLATION: every combination of add-ons needs its own subclass
abstract class Beverage {
    abstract double cost();
    abstract String description();
}
 
class Espresso extends Beverage {
    double cost() { return 2.00; }
    String description() { return "Espresso"; }
}
 
class EspressoWithMilk extends Beverage {
    double cost() { return 2.00 + 0.50; }
    String description() { return "Espresso, Milk"; }
}
 
class EspressoWithMilkAndWhip extends Beverage {
    double cost() { return 2.00 + 0.50 + 0.70; }
    String description() { return "Espresso, Milk, Whip"; }
}
 
class EspressoWithDoubleShotAndMilkAndWhip extends Beverage {
    double cost() { return 2.00 + 2.00 + 0.50 + 0.70; }
    String description() { return "Espresso, Double Shot, Milk, Whip"; }
}
// N add-ons → up to 2^N subclasses. Adding a new add-on ("Caramel") means
// writing a new subclass for every EXISTING combination that could include it too.

// FIXED: Beverage stays abstract; decorators wrap ANY Beverage, including each other.
abstract class Beverage {
    abstract double cost();
    abstract String description();
}
 
class Espresso extends Beverage {
    double cost() { return 2.00; }
    String description() { return "Espresso"; }
}
 
// The decorator IS a Beverage (so it's transparent to callers) and HAS a Beverage (so it can wrap one)
abstract class BeverageDecorator extends Beverage {
    protected final Beverage wrapped;
    BeverageDecorator(Beverage wrapped) { this.wrapped = wrapped; }
}
 
class MilkDecorator extends BeverageDecorator {
    MilkDecorator(Beverage wrapped) { super(wrapped); }
    double cost() { return wrapped.cost() + 0.50; }
    String description() { return wrapped.description() + ", Milk"; }
}
 
class WhipDecorator extends BeverageDecorator {
    WhipDecorator(Beverage wrapped) { super(wrapped); }
    double cost() { return wrapped.cost() + 0.70; }
    String description() { return wrapped.description() + ", Whip"; }
}
 
class ExtraShotDecorator extends BeverageDecorator {
    ExtraShotDecorator(Beverage wrapped) { super(wrapped); }
    double cost() { return wrapped.cost() + 2.00; }
    String description() { return wrapped.description() + ", Extra Shot"; }
}

// Any combination, composed at runtime — zero new classes for a new COMBINATION,
// only one new class ever needed for a genuinely new ADD-ON.
Beverage order = new WhipDecorator(
                      new MilkDecorator(
                          new ExtraShotDecorator(
                              new Espresso())));
 
System.out.println(order.description()); // "Espresso, Extra Shot, Milk, Whip"
System.out.println(order.cost());        // 2.00 + 2.00 + 0.50 + 0.70 = 5.20

// Each layer wraps the previous stream, adding one capability:
InputStream stream = new BufferedInputStream(          // adds buffering
                          new GZIPInputStream(          // adds decompression
                              new FileInputStream(       // reads raw bytes from disk
                                  "data.csv.gz")));
 
// Reader side mirrors it:
BufferedReader reader = new BufferedReader(              // adds line-based reading + buffering
                             new InputStreamReader(        // adapts bytes -> characters (this layer is actually an Adapter!)
                                 new FileInputStream("data.csv"),
                                 StandardCharsets.UTF_8));

interface HttpClient {
    HttpResponse send(HttpRequest request);
}
 
class BasicHttpClient implements HttpClient {
    public HttpResponse send(HttpRequest request) { /* actual network call */ return new HttpResponse(200); }
}
 
abstract class HttpClientDecorator implements HttpClient {
    protected final HttpClient wrapped;
    HttpClientDecorator(HttpClient wrapped) { this.wrapped = wrapped; }
}
 
class RetryingHttpClient extends HttpClientDecorator {
    private final int maxAttempts;
    RetryingHttpClient(HttpClient wrapped, int maxAttempts) { super(wrapped); this.maxAttempts = maxAttempts; }
 
    public HttpResponse send(HttpRequest request) {
        RuntimeException lastFailure = null;
        for (int attempt = 1; attempt <= maxAttempts; attempt++) {
            try {
                return wrapped.send(request);
            } catch (RuntimeException e) {
                lastFailure = e;
            }
        }
        throw lastFailure;
    }
}
 
class MetricsHttpClient extends HttpClientDecorator {
    MetricsHttpClient(HttpClient wrapped) { super(wrapped); }
 
    public HttpResponse send(HttpRequest request) {
        long start = System.nanoTime();
        try {
            return wrapped.send(request);
        } finally {
            recordLatency(System.nanoTime() - start);
        }
    }
 
    private void recordLatency(long nanos) { /* emit to metrics backend */ }
}
 
// Composed per call site — a background job might skip metrics, a user-facing
// call might want both:
HttpClient resilientClient = new MetricsHttpClient(
                                  new RetryingHttpClient(
                                      new BasicHttpClient(), 3));