SOLID, Dependency Injection and Spring Boot Basics for Java Interviews

import java.util.*;

public class DependencyInjection {
    interface MessageSender {
        void send(String to, String text);
    }

    static class EmailSender implements MessageSender {
        public void send(String to, String text) {
            System.out.println("EMAIL to " + to + ": " + text);
        }
    }

    static class FakeSender implements MessageSender {              // a hand-written test double
        final List<String> sent = new ArrayList<>();

        public void send(String to, String text) {
            sent.add(to + "|" + text);
        }
    }

    static class OrderService {
        private final MessageSender sender;                          // depends on the abstraction

        OrderService(MessageSender sender) {                         // constructor injection
            this.sender = sender;
        }

        void placeOrder(String customer) {
            sender.send(customer, "Your order is confirmed");
        }
    }

    public static void main(String[] args) {
        new OrderService(new EmailSender()).placeOrder("asha@example.com");

        FakeSender fake = new FakeSender();
        new OrderService(fake).placeOrder("ben@example.com");
        System.out.println(fake.sent);                               // [ben@example.com|Your order is confirmed]
    }
}

import java.util.*;
import java.util.function.*;

public class Patterns {
    enum Registry {                          // Singleton: the JVM guarantees a single enum instance
        INSTANCE;
        private int counter;

        int next() {
            return ++counter;
        }
    }

    static class Pizza {                     // Builder: readable construction of an object with many options
        private final String size;
        private final List<String> toppings;

        private Pizza(Builder builder) {
            this.size = builder.size;
            this.toppings = List.copyOf(builder.toppings);
        }

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

        static class Builder {
            private String size = "medium";
            private final List<String> toppings = new ArrayList<>();

            Builder size(String size) { this.size = size; return this; }
            Builder topping(String topping) { toppings.add(topping); return this; }
            Pizza build() { return new Pizza(this); }
        }

        @Override
        public String toString() {
            return size + " pizza with " + toppings;
        }
    }

    public static void main(String[] args) {
        System.out.println(Registry.INSTANCE.next());                // 1
        System.out.println(Registry.INSTANCE.next());                // 2

        Pizza pizza = Pizza.builder().size("large").topping("olives").topping("corn").build();
        System.out.println(pizza);                                   // large pizza with [olives, corn]

        // Strategy: choose the algorithm at run time, here as lambdas in a map
        Map<String, DoubleUnaryOperator> discounts = Map.of(
                "none", price -> price,
                "festival", price -> price * 0.9,
                "clearance", price -> price * 0.5);
        System.out.println(discounts.get("clearance").applyAsDouble(200));   // 100.0
    }
}