Structural
Patterns

interface Pizza { String getDescription(); double getCost(); }

class MargheritaPizza implements Pizza {
    public String getDescription() { return "Margherita"; }
    public double getCost()        { return 200.0; }
}

// ABSTRACT DECORATOR — IS-A Pizza AND HAS-A Pizza
abstract class ToppingDecorator implements Pizza {
    protected final Pizza pizza;
    public ToppingDecorator(Pizza p) { this.pizza = p; }
}

// Concrete decorators — each adds exactly one topping
class CheeseDecorator extends ToppingDecorator {
    public CheeseDecorator(Pizza p) { super(p); }
    public String getDescription() { return pizza.getDescription() + " + Cheese"; }
    public double getCost()        { return pizza.getCost() + 50.0; }
}
class MushroomDecorator extends ToppingDecorator {
    public String getDescription() { return pizza.getDescription() + " + Mushroom"; }
    public double getCost()        { return pizza.getCost() + 35.0; }
    public MushroomDecorator(Pizza p) { super(p); }
}

// Runtime composition — any order, any combination
Pizza order = new CheeseDecorator(
                 new MushroomDecorator(
                    new CheeseDecorator(   // double cheese!
                       new MargheritaPizza())));
// → "Margherita + Cheese + Mushroom + Cheese"  cost: 335.0

interface CarRentalService {
    Car rentCar(String model, User user);
    void returnCar(String carId, User user);
}

class CarRentalProxy implements CarRentalService {
    private final CarRentalServiceImpl real;
    private final AuthService auth;
    private final Logger log;

    @Override
    public Car rentCar(String model, User user) {
        // 1. Authorization (Protection Proxy)
        if (!auth.hasValidLicense(user))
            throw new UnauthorizedException("No valid license");

        // 2. Pre-logging
        log.log("Renting " + model + " for user " + user.getId());

        // 3. Delegate to real service
        Car car = real.rentCar(model, user);

        // 4. Post-logging
        log.log("Assigned car " + car.getId());
        return car;
    }
    // returnCar similarly delegates after logging
}

// Client sees same interface — proxy is completely transparent
CarRentalService svc = new CarRentalProxy(real, auth, log);
Car c = svc.rentCar("Camry", currentUser);

// Uniform component interface — same for File AND Directory
interface FileSystemComponent {
    String getName();
    long   getSize();
    void   display(String indent);
    void   delete();
}

// LEAF — no children
class File implements FileSystemComponent {
    private final String name; private final long size;
    public long   getSize()           { return size; }
    public void   display(String ind) { System.out.println(ind + "📄 " + name); }
    public void   delete()            { System.out.println("Delete file: " + name); }
    public String getName()           { return name; }
    public File(String n, long s)   { name=n; size=s; }
}

// COMPOSITE — holds children, operations recurse
class Directory implements FileSystemComponent {
    private final String name;
    private final List<FileSystemComponent> children = new ArrayList<>();

    public void add(FileSystemComponent c) { children.add(c); }

    // Recursive — works for any depth of nesting
    public long getSize() {
        return children.stream().mapToLong(FileSystemComponent::getSize).sum();
    }
    public void display(String ind) {
        System.out.println(ind + "📁 " + name + " (" + getSize() + " B)");
        children.forEach(c -> c.display(ind + "  "));
    }
    public void delete() { children.forEach(FileSystemComponent::delete); }
    public String getName() { return name; }
    public Directory(String n) { name = n; }
}

// Client — no instanceof, no type checks needed
Directory root = new Directory("root");
root.add(new File("README.md", 256));
root.add(src);          // src is a Directory — same add() call
root.getSize();         // Recursively sums all nested files

// Complex subsystems — many classes, many responsibilities
class ExpenseService   { Expense createExpense(...) {...} }
class SplitCalculator { Map calculateEqualSplit(...) {...} }
class BalanceService  { Map getNetBalances(...) {...} }
class NotificationService { void notifyMembers(...) {...} }

// FACADE — one class, simple operations, hides all complexity
class SplitwiseFacade {
    private final ExpenseService      expenses;
    private final SplitCalculator    calculator;
    private final BalanceService     balances;
    private final NotificationService notifier;

    // High-level operation — orchestrates 4 subsystems
    public void addExpenseEqualSplit(String groupId, String desc,
                                      double amount, String paidBy,
                                      List<String> members) {
        Expense expense = expenses.createExpense(desc, amount, paidBy);
        Map splits      = calculator.calculateEqualSplit(expense, members);
        balances.updateBalances(groupId, splits, paidBy);
        notifier.notifyExpenseAdded(members, expense);
    }

    public List<Transaction> getSimplifiedSettlements(String groupId) {
        Map<String, Double> netBalances = balances.getNetBalances(groupId);
        return SimplifyAlgorithm.simplify(netBalances); // min transactions
    }
}

// Client — one method call does what used to take 10
SplitwiseFacade sw = new SplitwiseFacade();
sw.addExpenseEqualSplit("grp1", "Dinner", 1200.0, "ajay", members);

// IMPLEMENTATION — HOW to send (one dimension)
interface NotificationSender { void send(String to, String msg); }
class SMSSender   implements NotificationSender { /* ... */ }
class EmailSender implements NotificationSender { /* ... */ }
class PushSender  implements NotificationSender { /* ... */ }

// ABSTRACTION — WHAT to send (other dimension)
abstract class CricketNotification {
    protected final NotificationSender sender; // THE BRIDGE
    public CricketNotification(NotificationSender s) { this.sender = s; }
    public abstract void notify(String recipient, Object event);
}

// Refined abstractions — each is a notification type
class WicketNotification extends CricketNotification {
    public WicketNotification(NotificationSender s) { super(s); }
    public void notify(String r, Object e) {
        sender.send(r, "WICKET! " + e + " is out!"); // uses bridge
    }
}
class SixNotification extends CricketNotification {
    public SixNotification(NotificationSender s) { super(s); }
    public void notify(String r, Object e) {
        sender.send(r, "SIX! " + e + " smashes it!");
    }
}

// Mix and match — N types × M channels without N×M classes
new WicketNotification(new SMSSender()).notify("user1", "Kohli");
new WicketNotification(new EmailSender()).notify("fan@email", "Rohit");
new SixNotification(new PushSender()).notify("device_xyz", "Dhoni");

// FLYWEIGHT — stores INTRINSIC state (shared, immutable)
class ContactMetadata {
    private final String operatorName;  // "Jio", "Airtel" — thousands share this
    private final String contactType;   // "SPAM", "BUSINESS" — few unique values
    private final String spamLabel;     // "Telemarketer", null — shared
    // All final — immutable, so safely shared across threads
}

// FLYWEIGHT FACTORY — pool ensures reuse
class ContactMetadataFactory {
    private static final Map<String,ContactMetadata> pool = new HashMap<>();

    public static ContactMetadata get(String op, String type, String spam) {
        String key = op + "|" + type + "|" + spam;
        return pool.computeIfAbsent(key, k -> new ContactMetadata(op, type, spam));
    }
}

// CLIENT CONTEXT — stores EXTRINSIC state (unique per contact)
class PhoneContact {
    private final String phoneNumber;  // unique — extrinsic
    private final String callerName;   // unique — extrinsic
    private final ContactMetadata meta; // SHARED — flyweight

    public PhoneContact(String num, String name, String op, String type, String spam) {
        this.phoneNumber = num;
        this.callerName  = name;
        this.meta = ContactMetadataFactory.get(op, type, spam); // pool lookup
    }
}

// Memory impact (1 billion contacts):
// Without Flyweight: 1B × 200B metadata = 200 GB
// With Flyweight:    ~1000 unique combos × 200B = 200 KB shared
//                   + 1B × ~30B (phone + name only) = 30 GB extrinsic