Practice Questions — Introduction to Design Patterns

public enum Logger {
    INSTANCE;
    private int counter = 0;

    public void info(String msg) { log("INFO", msg); }
    public void warn(String msg) { log("WARN", msg); }
    public void error(String msg) { log("ERROR", msg); }

    private void log(String level, String msg) {
        counter++;
        System.out.printf("[%d] %s: %s%n", counter, level, msg);
    }

    public static void main(String[] args) {
        Logger.INSTANCE.info("Application started");
        Logger.INSTANCE.warn("Low memory");
        Logger.INSTANCE.error("NullPointerException");
        System.out.println("Same instance: " + (Logger.INSTANCE == Logger.INSTANCE));
    }
}

interface Shape {
    double getArea();
    String getName();
}

class Circle implements Shape {
    double radius;
    Circle(double r) { radius = r; }
    public double getArea() { return Math.PI * radius * radius; }
    public String getName() { return "Circle"; }
}

class Rectangle implements Shape {
    double width, height;
    Rectangle(double w, double h) { width = w; height = h; }
    public double getArea() { return width * height; }
    public String getName() { return "Rectangle"; }
}

class Triangle implements Shape {
    double base, height;
    Triangle(double b, double h) { base = b; height = h; }
    public double getArea() { return 0.5 * base * height; }
    public String getName() { return "Triangle"; }
}

class ShapeFactory {
    static Shape create(String type, double... dims) {
        return switch (type.toLowerCase()) {
            case "circle" -> new Circle(dims[0]);
            case "rectangle" -> new Rectangle(dims[0], dims[1]);
            case "triangle" -> new Triangle(dims[0], dims[1]);
            default -> throw new IllegalArgumentException("Unknown: " + type);
        };
    }
}

public class FactoryChallenge {
    public static void main(String[] args) {
        Shape[] shapes = {
            ShapeFactory.create("circle", 5),
            ShapeFactory.create("rectangle", 4, 6),
            ShapeFactory.create("triangle", 3, 8)
        };
        for (Shape s : shapes) {
            System.out.printf("%s: area = %.2f%n", s.getName(), s.getArea());
        }
    }
}

public class Student {
    private final String name;
    private final int age;
    private final String email;
    private final String phone;
    private final String department;
    private final double gpa;

    private Student(Builder b) {
        this.name = b.name; this.age = b.age;
        this.email = b.email; this.phone = b.phone;
        this.department = b.department; this.gpa = b.gpa;
    }

    public String toString() {
        return String.format("Student{name=%s, age=%d, email=%s, gpa=%.1f}", name, age, email, gpa);
    }

    public static class Builder {
        private final String name;
        private final int age;
        private String email = ""; private String phone = "";
        private String department = ""; private double gpa = -1;

        public Builder(String name, int age) { this.name = name; this.age = age; }
        public Builder email(String e) { email = e; return this; }
        public Builder phone(String p) { phone = p; return this; }
        public Builder department(String d) { department = d; return this; }
        public Builder gpa(double g) { gpa = g; return this; }

        public Student build() {
            if (name == null || name.isEmpty()) throw new IllegalArgumentException("Name required");
            if (age < 16 || age > 30) throw new IllegalArgumentException("Age must be 16-30");
            if (gpa != -1 && (gpa < 0 || gpa > 10)) throw new IllegalArgumentException("GPA must be 0-10");
            return new Student(this);
        }
    }

    public static void main(String[] args) {
        Student s = new Student.Builder("Arjun", 20).email("arjun@email.com").gpa(8.5).build();
        System.out.println(s);
        try {
            new Student.Builder("", 20).build();
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

import java.util.*;

interface EventListener {
    void onEvent(String eventType, String data);
}

class EventBus {
    private Map<String, List<EventListener>> subscribers = new HashMap<>();

    void subscribe(String event, EventListener listener) {
        subscribers.computeIfAbsent(event, k -> new ArrayList<>()).add(listener);
    }

    void unsubscribe(String event, EventListener listener) {
        List<EventListener> list = subscribers.get(event);
        if (list != null) list.remove(listener);
    }

    void publish(String event, String data) {
        List<EventListener> list = subscribers.getOrDefault(event, Collections.emptyList());
        for (EventListener l : list) l.onEvent(event, data);
    }
}

public class EventSystemChallenge {
    public static void main(String[] args) {
        EventBus bus = new EventBus();

        EventListener authLogger = (type, data) -> System.out.println("AuthLog: [" + type + "] " + data);
        EventListener purchaseTracker = (type, data) -> System.out.println("Purchase: [" + type + "] " + data);
        EventListener allEvents = (type, data) -> System.out.println("Monitor: [" + type + "] " + data);

        bus.subscribe("login", authLogger);
        bus.subscribe("purchase", purchaseTracker);
        bus.subscribe("login", allEvents);
        bus.subscribe("purchase", allEvents);

        System.out.println("--- Login Event ---");
        bus.publish("login", "User Arjun logged in");
        System.out.println("\n--- Purchase Event ---");
        bus.publish("purchase", "Order #1234 placed");
    }
}

import java.util.*;

interface DiscountStrategy {
    double applyDiscount(double total);
    String describe();
}

class NoDiscount implements DiscountStrategy {
    public double applyDiscount(double total) { return total; }
    public String describe() { return "No discount"; }
}

class PercentageDiscount implements DiscountStrategy {
    private double percent;
    PercentageDiscount(double p) { percent = p; }
    public double applyDiscount(double total) { return total * (1 - percent / 100); }
    public String describe() { return percent + "% discount"; }
}

class FlatDiscount implements DiscountStrategy {
    private double amount;
    FlatDiscount(double a) { amount = a; }
    public double applyDiscount(double total) { return Math.max(0, total - amount); }
    public String describe() { return "Flat " + (int) amount + " discount"; }
}

class ShoppingCart {
    private List<Double> items = new ArrayList<>();
    private DiscountStrategy strategy = new NoDiscount();

    void addItem(double price) { items.add(price); }
    void setDiscount(DiscountStrategy s) { strategy = s; }

    double checkout() {
        double total = items.stream().mapToDouble(Double::doubleValue).sum();
        double finalPrice = strategy.applyDiscount(total);
        System.out.printf("%s: %.2f -> %.2f%n", strategy.describe(), total, finalPrice);
        return finalPrice;
    }
}

public class DiscountChallenge {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(500); cart.addItem(300); cart.addItem(200);

        cart.setDiscount(new NoDiscount());
        cart.checkout();

        cart.setDiscount(new PercentageDiscount(10));
        cart.checkout();

        cart.setDiscount(new FlatDiscount(200));
        cart.checkout();
    }
}