[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":87,"_71":88,"_35":89},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":19,"_63":64,"_65":66,"_67":68,"_69":70},"id",11,"title","Composition Over Inheritance","slug","clean-code-part-10-composition","excerpt","Achieve flexibility through composition: delegation, decorator, composite, and forwarding patterns to avoid fragile inheritance hierarchies.","# Advanced Clean Code Patterns Part 10: Composition Over Inheritance\n\n\"Favor composition over inheritance\" is one of the most cited principles in object-oriented design, yet inheritance remains overused. This article explores practical patterns for achieving flexibility through composition: delegation, decorator, composite, and mixins.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Patterns Covered | Delegation, Decorator, Composite, Forwarding |\n| Primary Benefit | Flexible runtime behavior, reduced coupling |\n| Trade-offs | More objects, indirection |\n| Java Features | Default methods, Records |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Delegation Pattern** for forwarding behavior\n- **Decorator Pattern** for adding responsibilities dynamically\n- **Composite Pattern** for tree structures\n- **Mixin simulation** with default methods\n- **When inheritance is still appropriate**\n\n---\n\n## Production Story: The Inheritance Nightmare\n\nA payment processing system started with a simple hierarchy:\n\n```java\n// Year 1: Looks clean\nclass Payment { }\nclass CreditCardPayment extends Payment { }\nclass DebitCardPayment extends Payment { }\n```\n\nThree years later:\n\n```java\n// Year 3: Inheritance explosion\nclass Payment { }\nclass CreditCardPayment extends Payment { }\nclass DebitCardPayment extends Payment { }\nclass InternationalCreditCardPayment extends CreditCardPayment { }\nclass RewardsCreditCardPayment extends CreditCardPayment { }\nclass InternationalRewardsCreditCardPayment extends ??? // Problem!\nclass CorporateCreditCardPayment extends CreditCardPayment { }\nclass CorporateRewardsPayment extends ??? // Multiple inheritance needed!\n```\n\n**The problems:**\n- Diamond inheritance problem (Java doesn't support multiple inheritance)\n- Changes to `Payment` broke all 15 subclasses\n- Testing required understanding entire hierarchy\n- Adding new features required new subclasses\n\n**The fix:** Composition with decorators:\n\n```java\n// Features as composable behaviors\ninterface PaymentProcessor {\n PaymentResult process(Payment payment);\n}\n\nclass BasePaymentProcessor implements PaymentProcessor { ... }\nclass InternationalDecorator implements PaymentProcessor { ... }\nclass RewardsDecorator implements PaymentProcessor { ... }\nclass CorporateDecorator implements PaymentProcessor { ... }\n\n// Compose any combination\nPaymentProcessor processor = new CorporateDecorator(\n new RewardsDecorator(\n new InternationalDecorator(\n new BasePaymentProcessor())));\n```\n\n---\n\n## Mental Model: Inheritance vs Composition\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ INHERITANCE VS COMPOSITION │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ INHERITANCE (\"is-a\") │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ Animal │ │\n│ │ / \\ │ │\n│ │ Dog Cat │ │\n│ │ | │ │\n│ │ FlyingDog ??? ← Can't mix behaviors! │ │\n│ │ │ │\n│ │ Problems: │ │\n│ │ - Compile-time fixed │ │\n│ │ - Single inheritance limit │ │\n│ │ - Tight coupling to parent │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ ↓ │\n│ COMPOSITION (\"has-a\") │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │\n│ │ │ Walkable │ │ Swimmable │ │ Flyable │ │ │\n│ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │\n│ │ │ │ │ │ │\n│ │ └────────────────┼────────────────┘ │ │\n│ │ ↓ │ │\n│ │ ┌─────────┐ │ │\n│ │ │ Dog │ ← Compose any behaviors! │ │\n│ │ └─────────┘ │ │\n│ │ │ │\n│ │ Benefits: │ │\n│ │ - Runtime flexible │ │\n│ │ - Mix multiple behaviors │ │\n│ │ - Loose coupling │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Delegation\n\n**Use when:** You want to reuse behavior without inheritance.\n\n```java\n// ❌ Inheritance for code reuse\npublic class LoggingList extends ArrayList {\n @Override\n public boolean add(E element) {\n log.info(\"Adding: {}\", element);\n return super.add(element); // Tightly coupled to ArrayList\n }\n // Must override ALL mutating methods!\n}\n\n// ✅ Delegation - wraps any List implementation\npublic class LoggingList implements List {\n private final List delegate;\n private final Logger log;\n\n public LoggingList(List delegate) {\n this.delegate = delegate;\n this.log = LoggerFactory.getLogger(LoggingList.class);\n }\n\n @Override\n public boolean add(E element) {\n log.info(\"Adding: {}\", element);\n return delegate.add(element);\n }\n\n @Override\n public E get(int index) {\n return delegate.get(index);\n }\n\n // Delegate all other methods...\n}\n\n// Usage - works with any List!\nList list = new LoggingList<>(new LinkedList<>());\nList list2 = new LoggingList<>(new ArrayList<>());\n```\n\n**Forwarding Class Pattern:**\n\n```java\n// ✅ Forwarding class to reduce boilerplate\npublic class ForwardingList implements List {\n private final List delegate;\n\n protected ForwardingList(List delegate) {\n this.delegate = delegate;\n }\n\n protected List delegate() {\n return delegate;\n }\n\n @Override public int size() { return delegate().size(); }\n @Override public boolean isEmpty() { return delegate().isEmpty(); }\n @Override public boolean add(E e) { return delegate().add(e); }\n @Override public E get(int index) { return delegate().get(index); }\n // ... all 25+ methods forwarded\n}\n\n// Now subclasses only override what they need\npublic class LoggingList extends ForwardingList {\n public LoggingList(List delegate) {\n super(delegate);\n }\n\n @Override\n public boolean add(E element) {\n log.info(\"Adding: {}\", element);\n return super.add(element);\n }\n}\n```\n\n---\n\n### Pattern 2: Decorator Pattern\n\n**Use when:** Adding responsibilities to objects dynamically without modifying their class.\n\n```java\n// ✅ Decorator Pattern\n\n// 1. Component interface\npublic interface Coffee {\n String getDescription();\n BigDecimal getCost();\n}\n\n// 2. Base implementation\npublic class Espresso implements Coffee {\n @Override\n public String getDescription() {\n return \"Espresso\";\n }\n\n @Override\n public BigDecimal getCost() {\n return new BigDecimal(\"2.00\");\n }\n}\n\n// 3. Abstract decorator\npublic abstract class CoffeeDecorator implements Coffee {\n protected final Coffee coffee;\n\n protected CoffeeDecorator(Coffee coffee) {\n this.coffee = coffee;\n }\n}\n\n// 4. Concrete decorators\npublic class MilkDecorator extends CoffeeDecorator {\n public MilkDecorator(Coffee coffee) {\n super(coffee);\n }\n\n @Override\n public String getDescription() {\n return coffee.getDescription() + \", Milk\";\n }\n\n @Override\n public BigDecimal getCost() {\n return coffee.getCost().add(new BigDecimal(\"0.50\"));\n }\n}\n\npublic class WhipDecorator extends CoffeeDecorator {\n public WhipDecorator(Coffee coffee) {\n super(coffee);\n }\n\n @Override\n public String getDescription() {\n return coffee.getDescription() + \", Whip\";\n }\n\n @Override\n public BigDecimal getCost() {\n return coffee.getCost().add(new BigDecimal(\"0.70\"));\n }\n}\n\npublic class SyrupDecorator extends CoffeeDecorator {\n private final String flavor;\n\n public SyrupDecorator(Coffee coffee, String flavor) {\n super(coffee);\n this.flavor = flavor;\n }\n\n @Override\n public String getDescription() {\n return coffee.getDescription() + \", \" + flavor + \" Syrup\";\n }\n\n @Override\n public BigDecimal getCost() {\n return coffee.getCost().add(new BigDecimal(\"0.40\"));\n }\n}\n\n// Usage - compose any combination!\nCoffee order = new SyrupDecorator(\n new WhipDecorator(\n new MilkDecorator(\n new Espresso())),\n \"Vanilla\");\n\norder.getDescription(); // \"Espresso, Milk, Whip, Vanilla Syrup\"\norder.getCost(); // 3.60\n```\n\n**Real-World Example: InputStream Decorators:**\n\n```java\n// Java I/O uses decorator pattern extensively\nInputStream is = new BufferedInputStream(\n new GZIPInputStream(\n new FileInputStream(\"data.gz\")));\n\n// Each layer adds functionality:\n// FileInputStream - reads bytes from file\n// GZIPInputStream - decompresses\n// BufferedInputStream - adds buffering\n```\n\n---\n\n### Pattern 3: Composite Pattern\n\n**Use when:** Treating individual objects and compositions uniformly (tree structures).\n\n```java\n// ✅ Composite Pattern for menu system\n\n// Component\npublic interface MenuComponent {\n String getName();\n BigDecimal getPrice();\n void print();\n\n // Default implementations for composite operations\n default void add(MenuComponent component) {\n throw new UnsupportedOperationException();\n }\n default void remove(MenuComponent component) {\n throw new UnsupportedOperationException();\n }\n}\n\n// Leaf\npublic class MenuItem implements MenuComponent {\n private final String name;\n private final BigDecimal price;\n private final String description;\n\n public MenuItem(String name, BigDecimal price, String description) {\n this.name = name;\n this.price = price;\n this.description = description;\n }\n\n @Override\n public String getName() { return name; }\n\n @Override\n public BigDecimal getPrice() { return price; }\n\n @Override\n public void print() {\n System.out.printf(\" %s - $%.2f%n %s%n\",\n name, price, description);\n }\n}\n\n// Composite\npublic class Menu implements MenuComponent {\n private final String name;\n private final List components = new ArrayList<>();\n\n public Menu(String name) {\n this.name = name;\n }\n\n @Override\n public void add(MenuComponent component) {\n components.add(component);\n }\n\n @Override\n public void remove(MenuComponent component) {\n components.remove(component);\n }\n\n @Override\n public String getName() { return name; }\n\n @Override\n public BigDecimal getPrice() {\n return components.stream()\n .map(MenuComponent::getPrice)\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n }\n\n @Override\n public void print() {\n System.out.println(\"\\n\" + name);\n System.out.println(\"-\".repeat(name.length()));\n components.forEach(MenuComponent::print);\n }\n}\n\n// Usage\nMenu allMenus = new Menu(\"ALL MENUS\");\n\nMenu breakfast = new Menu(\"BREAKFAST\");\nbreakfast.add(new MenuItem(\"Pancakes\", new BigDecimal(\"8.99\"), \"Fluffy buttermilk\"));\nbreakfast.add(new MenuItem(\"Eggs Benedict\", new BigDecimal(\"12.99\"), \"Poached eggs\"));\n\nMenu lunch = new Menu(\"LUNCH\");\nlunch.add(new MenuItem(\"Burger\", new BigDecimal(\"14.99\"), \"Angus beef\"));\nlunch.add(new MenuItem(\"Salad\", new BigDecimal(\"9.99\"), \"Garden fresh\"));\n\nallMenus.add(breakfast);\nallMenus.add(lunch);\n\nallMenus.print(); // Prints entire tree\nallMenus.getPrice(); // Total of all items\n```\n\n---\n\n### Pattern 4: Mixins with Default Methods\n\n**Use when:** Sharing behavior across unrelated classes.\n\n```java\n// ✅ Mixin-like behavior with interfaces\n\npublic interface Timestamped {\n Instant getCreatedAt();\n Instant getUpdatedAt();\n\n default Duration getAge() {\n return Duration.between(getCreatedAt(), Instant.now());\n }\n\n default boolean isOlderThan(Duration duration) {\n return getAge().compareTo(duration) > 0;\n }\n}\n\npublic interface Identifiable {\n ID getId();\n\n default boolean hasId() {\n return getId() != null;\n }\n}\n\npublic interface Auditable {\n String getCreatedBy();\n String getUpdatedBy();\n\n default String getLastModifier() {\n return getUpdatedBy() != null ? getUpdatedBy() : getCreatedBy();\n }\n}\n\n// Compose multiple \"mixins\"\npublic class Article implements Timestamped, Identifiable, Auditable {\n private Long id;\n private String title;\n private Instant createdAt;\n private Instant updatedAt;\n private String createdBy;\n private String updatedBy;\n\n // Implement required methods\n @Override public Long getId() { return id; }\n @Override public Instant getCreatedAt() { return createdAt; }\n @Override public Instant getUpdatedAt() { return updatedAt; }\n @Override public String getCreatedBy() { return createdBy; }\n @Override public String getUpdatedBy() { return updatedBy; }\n\n // Inherited behavior from all interfaces:\n // - getAge(), isOlderThan() from Timestamped\n // - hasId() from Identifiable\n // - getLastModifier() from Auditable\n}\n```\n\n**Another example - behavior mixins:**\n\n```java\n// Behavior mixins\npublic interface Loggable {\n default Logger log() {\n return LoggerFactory.getLogger(this.getClass());\n }\n\n default void logInfo(String message, Object... args) {\n log().info(message, args);\n }\n\n default void logError(String message, Throwable t) {\n log().error(message, t);\n }\n}\n\npublic interface Validatable {\n List validate();\n\n default boolean isValid() {\n return validate().isEmpty();\n }\n\n default T validateAndReturn() {\n List errors = validate();\n if (!errors.isEmpty()) {\n throw new ValidationException(errors);\n }\n @SuppressWarnings(\"unchecked\")\n T self = (T) this;\n return self;\n }\n}\n\n// Any class can mix these in\npublic class UserRegistration implements Loggable, Validatable {\n private String email;\n private String password;\n\n @Override\n public List validate() {\n List errors = new ArrayList<>();\n if (email == null || !email.contains(\"@\")) {\n errors.add(\"Invalid email\");\n }\n if (password == null || password.length() < 8) {\n errors.add(\"Password too short\");\n }\n return errors;\n }\n\n public UserRegistration process() {\n logInfo(\"Processing registration for: {}\", email);\n return validateAndReturn();\n }\n}\n```\n\n---\n\n### Pattern 5: Strategy as Composition\n\n**Use when:** Behavior varies independently of the object using it.\n\n```java\n// ✅ Composing behaviors via strategy\n\npublic interface ValidationStrategy {\n List validate(Object target);\n}\n\npublic interface PersistenceStrategy {\n T save(T entity);\n Optional findById(Object id);\n}\n\npublic interface NotificationStrategy {\n void notify(String recipient, String message);\n}\n\n// Compose strategies into service\npublic class UserService {\n private final ValidationStrategy validation;\n private final PersistenceStrategy persistence;\n private final NotificationStrategy notification;\n\n public UserService(\n ValidationStrategy validation,\n PersistenceStrategy persistence,\n NotificationStrategy notification) {\n this.validation = validation;\n this.persistence = persistence;\n this.notification = notification;\n }\n\n public User register(User user) {\n List errors = validation.validate(user);\n if (!errors.isEmpty()) {\n throw new ValidationException(errors);\n }\n\n User saved = persistence.save(user);\n notification.notify(user.getEmail(), \"Welcome!\");\n return saved;\n }\n}\n\n// Flexible configuration\nUserService service = new UserService(\n new StrictValidation(), // or RelaxedValidation\n new JpaUserRepository(), // or InMemoryRepository\n new EmailNotification() // or SmsNotification, NoOpNotification\n);\n```\n\n---\n\n## When to Use Inheritance\n\nInheritance is appropriate when:\n\n```java\n// ✅ TRUE \"is-a\" relationship with behavior extension\npublic abstract class Shape {\n protected final Color color;\n\n public Shape(Color color) {\n this.color = color;\n }\n\n public abstract double area();\n public abstract double perimeter();\n\n // Shared behavior\n public void draw(Canvas canvas) {\n canvas.setColor(color);\n render(canvas);\n }\n\n protected abstract void render(Canvas canvas);\n}\n\npublic class Circle extends Shape {\n private final double radius;\n\n public Circle(Color color, double radius) {\n super(color);\n this.radius = radius;\n }\n\n @Override public double area() {\n return Math.PI * radius * radius;\n }\n\n @Override public double perimeter() {\n return 2 * Math.PI * radius;\n }\n\n @Override protected void render(Canvas canvas) {\n canvas.drawCircle(radius);\n }\n}\n\n// ✅ Framework extension points\npublic class CustomAuthenticationProvider extends AbstractAuthenticationProvider {\n @Override\n protected UserDetails retrieveUser(String username) {\n // Custom implementation\n }\n}\n```\n\n---\n\n## Decision Guide: Inheritance vs Composition\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ DECISION FLOWCHART │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ Is there a TRUE \"is-a\" relationship? │\n│ │ │\n│ ├── No ──→ Use COMPOSITION │\n│ │ │\n│ └── Yes │\n│ │ │\n│ ▼ │\n│ Will you need to combine with other behaviors? │\n│ │ │\n│ ├── Yes ──→ Use COMPOSITION (decorators/mixins) │\n│ │ │\n│ └── No │\n│ │ │\n│ ▼ │\n│ Is the parent designed for inheritance? │\n│ │ │\n│ ├── No ──→ Use COMPOSITION │\n│ │ │\n│ └── Yes │\n│ │ │\n│ ▼ │\n│ Is Liskov Substitution Principle satisfied? │\n│ │ │\n│ ├── No ──→ Use COMPOSITION │\n│ │ │\n│ └── Yes ──→ INHERITANCE may be appropriate │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Inheriting for Code Reuse Only\n\n```java\n// ❌ Inheritance just to reuse code\npublic class Stack extends ArrayList {\n public E push(E item) { add(item); return item; }\n public E pop() { return remove(size() - 1); }\n public E peek() { return get(size() - 1); }\n // But now Stack has add(), get(), remove() - not stack behavior!\n}\n\n// ✅ Composition\npublic class Stack {\n private final List elements = new ArrayList<>();\n\n public E push(E item) {\n elements.add(item);\n return item;\n }\n public E pop() {\n return elements.remove(elements.size() - 1);\n }\n public E peek() {\n return elements.get(elements.size() - 1);\n }\n // Only stack operations exposed\n}\n```\n\n### Mistake 2: Deep Inheritance Hierarchies\n\n```java\n// ❌ Too deep\nclass Entity { }\nclass NamedEntity extends Entity { }\nclass TimestampedNamedEntity extends NamedEntity { }\nclass AuditableTimestampedNamedEntity extends TimestampedNamedEntity { }\nclass VersionedAuditableTimestampedNamedEntity extends AuditableTimestampedNamedEntity { }\n\n// ✅ Flat with composition\nclass Entity {\n private final EntityName name;\n private final Timestamps timestamps;\n private final AuditInfo audit;\n private final Version version;\n}\n```\n\n---\n\n## 🐛 Debug This: The Decorator Disaster\n\nA developer reports: \"Our logging decorator works fine alone, but when we combine it with the caching decorator, the logs show incorrect values!\"\n\n```java\npublic interface DataService {\n String getData(String key);\n}\n\npublic class DatabaseService implements DataService {\n @Override\n public String getData(String key) {\n // Simulates slow database call\n return \"DB:\" + key + \":\" + System.currentTimeMillis();\n }\n}\n\npublic class CachingDecorator implements DataService {\n private final DataService delegate;\n private final Map cache = new HashMap<>();\n\n public CachingDecorator(DataService delegate) {\n this.delegate = delegate;\n }\n\n @Override\n public String getData(String key) {\n if (!cache.containsKey(key)) {\n cache.put(key, delegate.getData(key));\n }\n return cache.get(key);\n }\n}\n\npublic class LoggingDecorator implements DataService {\n private final DataService delegate;\n\n public LoggingDecorator(DataService delegate) {\n this.delegate = delegate;\n }\n\n @Override\n public String getData(String key) {\n String result = delegate.getData(key);\n System.out.println(\"getData(\" + key + \") = \" + result);\n return delegate.getData(key); // BUG: Calling delegate twice!\n }\n}\n\n// Usage - different results depending on decorator order!\nDataService service1 = new LoggingDecorator(\n new CachingDecorator(new DatabaseService()));\n\nDataService service2 = new CachingDecorator(\n new LoggingDecorator(new DatabaseService()));\n\n// service1.getData(\"test\") - logs one value, returns different value\n// service2.getData(\"test\") - caches the wrong call count\n```\n\n**Why does decorator order matter here, and what's the hidden bug?**\n\n---\n\n**✅ Solution:**\n\nThe bug is in `LoggingDecorator.getData()` - it calls `delegate.getData(key)` **twice**:\n1. Once to get the result for logging\n2. Once again to return the value\n\nThis causes:\n- **With LoggingDecorator → CachingDecorator**: First call hits cache miss, second call gets cached value (different!)\n- **With CachingDecorator → LoggingDecorator**: Each call to logging generates two database calls\n\n**Correct implementation:**\n\n```java\npublic class LoggingDecorator implements DataService {\n private final DataService delegate;\n\n public LoggingDecorator(DataService delegate) {\n this.delegate = delegate;\n }\n\n @Override\n public String getData(String key) {\n String result = delegate.getData(key); // Call once\n System.out.println(\"getData(\" + key + \") = \" + result);\n return result; // Return the same result\n }\n}\n```\n\n**The lesson:** In decorator pattern, always call the delegate exactly once and reuse the result. Multiple calls can cause subtle bugs especially with caching, counting, or side-effect decorators.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Forwarding Wrapper\n⭐ Difficulty: Easy | ⏱️ Time: 15 minutes\n\n**Task:** Create a forwarding wrapper that adds size tracking to any `List`.\n\n```java\n// Create a SizeTrackingList that:\n// 1. Wraps any List implementation\n// 2. Tracks the maximum size the list ever reached\n// 3. Provides getMaxSize() method\n\nList list = new SizeTrackingList<>(new ArrayList<>());\nlist.add(\"a\");\nlist.add(\"b\");\nlist.add(\"c\"); // max = 3\nlist.remove(\"b\"); // size = 2, max still 3\nlist.getMaxSize(); // Returns 3\n```\n\n**✅ Solution:**\n\n```java\npublic class SizeTrackingList implements List {\n private final List delegate;\n private int maxSize = 0;\n\n public SizeTrackingList(List delegate) {\n this.delegate = delegate;\n this.maxSize = delegate.size();\n }\n\n public int getMaxSize() {\n return maxSize;\n }\n\n private void updateMaxSize() {\n maxSize = Math.max(maxSize, delegate.size());\n }\n\n @Override\n public boolean add(E e) {\n boolean result = delegate.add(e);\n updateMaxSize();\n return result;\n }\n\n @Override\n public void add(int index, E element) {\n delegate.add(index, element);\n updateMaxSize();\n }\n\n @Override\n public boolean addAll(Collection c) {\n boolean result = delegate.addAll(c);\n updateMaxSize();\n return result;\n }\n\n // Forward all other List methods to delegate\n @Override public int size() { return delegate.size(); }\n @Override public boolean isEmpty() { return delegate.isEmpty(); }\n @Override public E get(int index) { return delegate.get(index); }\n @Override public E remove(int index) { return delegate.remove(index); }\n @Override public boolean remove(Object o) { return delegate.remove(o); }\n // ... other methods forwarded\n}\n```\n\n---\n\n### Exercise 2: Decorator Chain\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Implement a text processing pipeline using decorators.\n\n```java\n// Create decorators for TextProcessor:\n// - UpperCaseDecorator: converts to uppercase\n// - TrimDecorator: trims whitespace\n// - CensorDecorator: replaces bad words with ***\n\npublic interface TextProcessor {\n String process(String text);\n}\n\n// Should work like:\nTextProcessor processor = new CensorDecorator(\n new UpperCaseDecorator(\n new TrimDecorator(\n new BaseTextProcessor())),\n List.of(\"bad\", \"ugly\"));\n\nprocessor.process(\" bad word here \");\n// Returns: \"*** WORD HERE\"\n```\n\n**✅ Solution:**\n\n```java\npublic interface TextProcessor {\n String process(String text);\n}\n\npublic class BaseTextProcessor implements TextProcessor {\n @Override\n public String process(String text) {\n return text;\n }\n}\n\npublic abstract class TextProcessorDecorator implements TextProcessor {\n protected final TextProcessor delegate;\n\n protected TextProcessorDecorator(TextProcessor delegate) {\n this.delegate = delegate;\n }\n}\n\npublic class TrimDecorator extends TextProcessorDecorator {\n public TrimDecorator(TextProcessor delegate) {\n super(delegate);\n }\n\n @Override\n public String process(String text) {\n return delegate.process(text).trim();\n }\n}\n\npublic class UpperCaseDecorator extends TextProcessorDecorator {\n public UpperCaseDecorator(TextProcessor delegate) {\n super(delegate);\n }\n\n @Override\n public String process(String text) {\n return delegate.process(text).toUpperCase();\n }\n}\n\npublic class CensorDecorator extends TextProcessorDecorator {\n private final List bannedWords;\n\n public CensorDecorator(TextProcessor delegate, List bannedWords) {\n super(delegate);\n this.bannedWords = bannedWords.stream()\n .map(String::toUpperCase)\n .toList();\n }\n\n @Override\n public String process(String text) {\n String result = delegate.process(text);\n for (String banned : bannedWords) {\n result = result.replaceAll(\"(?i)\" + banned, \"***\");\n }\n return result;\n }\n}\n```\n\n---\n\n### Exercise 3: Composite File System\n⭐⭐ Difficulty: Medium | ⏱️ Time: 25 minutes\n\n**Task:** Implement a composite pattern for a file system that calculates total size.\n\n```java\n// FileSystemComponent interface with:\n// - getName()\n// - getSize()\n// - print(indent)\n\n// File (leaf): has fixed size\n// Directory (composite): size is sum of contents\n\nDirectory root = new Directory(\"root\");\nroot.add(new File(\"readme.txt\", 100));\nroot.add(new File(\"config.json\", 50));\n\nDirectory src = new Directory(\"src\");\nsrc.add(new File(\"Main.java\", 500));\nsrc.add(new File(\"Utils.java\", 300));\nroot.add(src);\n\nroot.getSize(); // 950\nroot.print(\"\");\n// root/\n// readme.txt (100 bytes)\n// config.json (50 bytes)\n// src/\n// Main.java (500 bytes)\n// Utils.java (300 bytes)\n```\n\n**✅ Solution:**\n\n```java\npublic interface FileSystemComponent {\n String getName();\n long getSize();\n void print(String indent);\n}\n\npublic class File implements FileSystemComponent {\n private final String name;\n private final long size;\n\n public File(String name, long size) {\n this.name = name;\n this.size = size;\n }\n\n @Override\n public String getName() { return name; }\n\n @Override\n public long getSize() { return size; }\n\n @Override\n public void print(String indent) {\n System.out.printf(\"%s%s (%d bytes)%n\", indent, name, size);\n }\n}\n\npublic class Directory implements FileSystemComponent {\n private final String name;\n private final List contents = new ArrayList<>();\n\n public Directory(String name) {\n this.name = name;\n }\n\n public void add(FileSystemComponent component) {\n contents.add(component);\n }\n\n public void remove(FileSystemComponent component) {\n contents.remove(component);\n }\n\n @Override\n public String getName() { return name; }\n\n @Override\n public long getSize() {\n return contents.stream()\n .mapToLong(FileSystemComponent::getSize)\n .sum();\n }\n\n @Override\n public void print(String indent) {\n System.out.println(indent + name + \"/\");\n for (FileSystemComponent component : contents) {\n component.print(indent + \" \");\n }\n }\n}\n```\n\n---\n\n### Exercise 4: Mixin Interfaces\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Create mixin interfaces for common entity behaviors.\n\n```java\n// Create these mixin interfaces with default methods:\n// - Comparable with compareTo based on a key\n// - Cacheable with cache key generation\n// - JsonSerializable with toJson()\n\n// Example entity using all mixins:\npublic class Product implements\n KeyComparable,\n Cacheable,\n JsonSerializable {\n\n private Long id;\n private String name;\n private BigDecimal price;\n\n // Should automatically get:\n // - compareTo() based on id\n // - getCacheKey() returning \"Product:123\"\n // - toJson() returning {\"id\":123,\"name\":\"...\"}\n}\n```\n\n**✅ Solution:**\n\n```java\npublic interface KeyComparable extends Comparable {\n Comparable getComparisonKey();\n\n @Override\n default int compareTo(T other) {\n if (other instanceof KeyComparable kc) {\n @SuppressWarnings(\"unchecked\")\n Comparable