Design Patterns & SOLID

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;

public class Solid {
    record Invoice(String customer, BigDecimal amount) {}

    // Small interfaces, each with one job
    interface TaxPolicy { BigDecimal taxOn(BigDecimal net); }
    interface InvoiceStore { void save(Invoice invoice); List<Invoice> all(); }
    interface Sender { void send(String to, String text); }

    static class FlatGst implements TaxPolicy {
        private final BigDecimal rate;
        FlatGst(String rate) { this.rate = new BigDecimal(rate); }
        public BigDecimal taxOn(BigDecimal net) {
            return net.multiply(rate).setScale(2, RoundingMode.HALF_UP);
        }
    }

    static class InMemoryStore implements InvoiceStore {
        private final List<Invoice> saved = new ArrayList<>();
        public void save(Invoice invoice) { saved.add(invoice); }
        public List<Invoice> all() { return List.copyOf(saved); }
    }

    static class ConsoleSender implements Sender {
        public void send(String to, String text) { System.out.println("[to " + to + "] " + text); }
    }

    // Depends only on interfaces, which are handed in from outside
    static class InvoiceService {
        private final TaxPolicy tax;
        private final InvoiceStore store;
        private final Sender sender;

        InvoiceService(TaxPolicy tax, InvoiceStore store, Sender sender) {
            this.tax = tax;
            this.store = store;
            this.sender = sender;
        }

        Invoice bill(String customer, BigDecimal net) {
            Invoice invoice = new Invoice(customer, net.add(tax.taxOn(net)));
            store.save(invoice);
            sender.send(customer, "Your invoice total is Rs " + invoice.amount());
            return invoice;
        }
    }

    public static void main(String[] args) {
        InvoiceStore store = new InMemoryStore();
        Sender sender = new ConsoleSender();

        InvoiceService domestic = new InvoiceService(new FlatGst("0.18"), store, sender);
        domestic.bill("Kabir", new BigDecimal("1000.00"));
        domestic.bill("Priya", new BigDecimal("2499.00"));

        TaxPolicy zeroRated = net -> BigDecimal.ZERO.setScale(2);
        InvoiceService export = new InvoiceService(zeroRated, store, sender);
        export.bill("Overseas client", new BigDecimal("5000.00"));

        System.out.println("Invoices saved: " + store.all().size());
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Patterns {
    // Strategy: interchangeable algorithms behind one interface
    interface DeliveryCharge { int forKm(int km); }

    // Factory: one place decides which implementation to create
    static DeliveryCharge chargeFor(String plan) {
        return switch (plan) {
            case "standard" -> km -> km <= 5 ? 0 : 40;
            case "express" -> km -> 60 + km * 5;
            case "prime" -> km -> 0;
            default -> throw new IllegalArgumentException("Unknown plan: " + plan);
        };
    }

    // Observer: listeners react to an event; the publisher does not know who they are
    record OrderPlaced(String id, String customer, int total) {}

    static class OrderEvents {
        private final List<Consumer<OrderPlaced>> listeners = new ArrayList<>();
        void subscribe(Consumer<OrderPlaced> listener) { listeners.add(listener); }
        void publish(OrderPlaced event) { listeners.forEach(l -> l.accept(event)); }
    }

    public static void main(String[] args) {
        for (String plan : List.of("standard", "express", "prime")) {
            DeliveryCharge charge = chargeFor(plan);
            System.out.println(plan + ": 3 km = Rs " + charge.forKm(3) + ", 12 km = Rs " + charge.forKm(12));
        }

        OrderEvents events = new OrderEvents();
        events.subscribe(e -> System.out.println("SMS to " + e.customer() + ": order " + e.id() + " confirmed"));
        events.subscribe(e -> System.out.println("Warehouse: pack order " + e.id()));
        events.subscribe(e -> {
            if (e.total() >= 5000) {
                System.out.println("Fraud check queued for " + e.id());
            }
        });

        events.publish(new OrderPlaced("A-101", "Meera", 1299));
        events.publish(new OrderPlaced("A-102", "Rohan", 7499));
    }
}

import java.util.Objects;

public class Tickets {
    // Builder: readable construction of an object with many optional parts
    static final class TrainTicket {
        private final String passenger;
        private final String from;
        private final String to;
        private final String travelClass;
        private final boolean meal;
        private final String berth;

        private TrainTicket(Builder b) {
            passenger = Objects.requireNonNull(b.passenger, "passenger is required");
            from = Objects.requireNonNull(b.from, "from is required");
            to = Objects.requireNonNull(b.to, "to is required");
            travelClass = b.travelClass;
            meal = b.meal;
            berth = b.berth;
        }

        static Builder builder() { return new Builder(); }

        @Override
        public String toString() {
            return passenger + " " + from + " to " + to + " [" + travelClass
                    + ", meal=" + meal + ", berth=" + berth + "]";
        }

        static final class Builder {
            private String passenger;
            private String from;
            private String to;
            private String travelClass = "SL";          // sensible defaults
            private boolean meal = false;
            private String berth = "any";

            Builder passenger(String v) { passenger = v; return this; }
            Builder from(String v) { from = v; return this; }
            Builder to(String v) { to = v; return this; }
            Builder travelClass(String v) { travelClass = v; return this; }
            Builder meal(boolean v) { meal = v; return this; }
            Builder berth(String v) { berth = v; return this; }
            TrainTicket build() { return new TrainTicket(this); }
        }
    }

    // Adapter: make an old API fit the interface the rest of the code expects
    interface Sender { void send(String phone, String text); }

    static class OldSmsLibrary {                         // third-party code we cannot change
        int sendMessage(String text, String mobileWithCountryCode, int priority) {
            System.out.println("OLD LIB -> " + mobileWithCountryCode + " (p" + priority + "): " + text);
            return 0;                                    // 0 means success in this old API
        }
    }

    static class OldSmsAdapter implements Sender {
        private final OldSmsLibrary library = new OldSmsLibrary();

        public void send(String phone, String text) {
            int code = library.sendMessage(text, "+91" + phone, 1);
            if (code != 0) {
                throw new IllegalStateException("SMS failed with code " + code);
            }
        }
    }

    public static void main(String[] args) {
        TrainTicket ticket = TrainTicket.builder()
                .passenger("Ananya").from("Lucknow").to("Pune")
                .travelClass("3A").berth("lower")
                .build();
        System.out.println(ticket);
        System.out.println(TrainTicket.builder().passenger("Farhan").from("Kochi").to("Chennai").build());
        try {
            TrainTicket.builder().passenger("Isha").build();
        } catch (NullPointerException e) {
            System.out.println("Rejected: " + e.getMessage());
        }

        Sender sender = new OldSmsAdapter();
        sender.send("9810000001", "Your PNR is confirmed");
    }
}