Object-Oriented Programming

public class Order {
    private static final AtomicLong ID_GEN = new AtomicLong();
    private final long id;
    private BigDecimal total;

    static {
        // Runs once when Order class is first used (loaded + initialized)
        log.info("Order class initialized");
    }

    {
        // Runs before every constructor on this instance
        if (total == null) total = BigDecimal.ZERO;
    }

    public Order(BigDecimal total) {
        this.id = ID_GEN.incrementAndGet();
        this.total = total;
    }

    public long getId() { return id; }

    public static long peekNextId() {
        return ID_GEN.get();  // no "this" in static context
    }
}

public class LineItem {
    private final String sku;
    private final int qty;

    public LineItem(String sku) {
        this(sku, 1);  // delegate to full constructor
    }

    public LineItem(String sku, int qty) {
        this.sku = sku;
        this.qty = qty;
    }
}

public class User {
    private final String email;
    private final String displayName;

    public User(String email) {
        this(email, email.substring(0, email.indexOf('@')));
    }

    public User(String email, String displayName) {
        this.email = Objects.requireNonNull(email, "email");
        this.displayName = Objects.requireNonNullElse(displayName, email);
    }
}

public class AdminUser extends User {
    private final int level;

    public AdminUser(String email, int level) {
        super(email);              // User(String) must exist
        this.level = level;
    }
}

public final class TagSet {
    private final String[] tags;

    public TagSet(String[] tags) {
        this.tags = tags.clone();  // defensive copy on way in
    }

    public TagSet(TagSet other) {
        this(other.tags);          // copy constructor
    }

    public String[] tags() {
        return tags.clone();       // defensive copy on way out
    }
}

public class Payment {
    protected BigDecimal amount;

    protected void validateAmount() {
        if (amount == null || amount.signum() <= 0) {
            throw new IllegalArgumentException("amount");
        }
    }
}

public class CardPayment extends Payment {
    private final String last4;

    public CardPayment(BigDecimal amount, String last4) {
        this.amount = amount;
        this.last4 = last4;
    }

    @Override
    public String toString() {
        return "Card*" + last4 + " " + amount;
    }

    public void validate() {
        super.validateAmount();
        if (last4 == null || last4.length() != 4) {
            throw new IllegalArgumentException("last4");
        }
    }
}

public sealed interface PaymentMethod permits Card, BankTransfer { }

public final class Card implements PaymentMethod {
    private final String last4;
    public Card(String last4) { this.last4 = last4; }
}

public final class BankTransfer implements PaymentMethod {
    private final String iban;
    public BankTransfer(String iban) { this.iban = iban; }
}

// Exhaustive switch (with sealed + final permits)
static String describe(PaymentMethod pm) {
    return switch (pm) {
        case Card c -> "card " + c;
        case BankTransfer b -> "bank " + b;
    };  // no default needed — compiler knows all cases
}

class Printer {
    void print(int x) { System.out.println("int " + x); }
    void print(long x) { System.out.println("long " + x); }
    void print(String s) { System.out.println("str " + s); }
}

Printer p = new Printer();
p.print(5);      // int — literal int fits int overload
p.print(5L);     // long

Payment payment = new CardPayment(amount, "4242");
payment.validate();  // CardPayment.validate if declared on Payment

// Static methods — no dynamic dispatch
class Parent { static void greet() { System.out.println("parent"); } }
class Child extends Parent { static void greet() { System.out.println("child"); } }
Parent ref = new Child();
ref.greet();  // "parent" — resolved by reference type Parent

class Animal {
    Animal reproduce() { return new Animal(); }
}
class Dog extends Animal {
    @Override
    Dog reproduce() { return new Dog(); }  // covariant return
}

public abstract class HttpClientBase {
    protected final Duration timeout;

    protected HttpClientBase(Duration timeout) {
        this.timeout = timeout;
    }

    public final String get(String url) {  // template method — not overridable
        validateUrl(url);
        return doGet(url);
    }

    protected abstract String doGet(String url);

    protected void validateUrl(String url) {
        Objects.requireNonNull(url);
    }
}

public interface Repository<T, ID> {
    Optional<T> findById(ID id);
    void save(T entity);

    default T findByIdOrThrow(ID id) {
        return findById(id).orElseThrow(() -> notFound(id));
    }

    static <ID> RuntimeException notFound(ID id) {
        return new NoSuchElementException("id=" + id);
    }

    private void audit(String op) {  // Java 9+
        System.out.println(op);
    }
}

@FunctionalInterface
interface EventHandler {
    void onEvent(String payload);
    // default/static methods OK — still one abstract method
}

EventHandler log = msg -> System.out.println(msg);
list.forEach(log::onEvent);

// Built-in SAMs in java.util.function
Predicate<String> nonBlank = s -> !s.isBlank();
Function<String, Integer> len = String::length;

public class Account {
    private final String id;
    private BigDecimal balance;

    public Account(String id, BigDecimal opening) {
        this.id = id;
        this.balance = opening;
    }

    public void debit(BigDecimal amount) {
        if (amount.signum() <= 0) throw new IllegalArgumentException();
        balance = balance.subtract(amount);
    }

    public BigDecimal balance() { return balance; }  // accessor, no setter
}

public record Money(BigDecimal amount, Currency currency) {
    public Money {  // compact constructor — validate before fields assigned
        Objects.requireNonNull(amount);
        Objects.requireNonNull(currency);
        if (amount.signum() < 0) throw new IllegalArgumentException("negative");
    }

    public Money add(Money other) {
        if (!currency.equals(other.currency)) throw new IllegalArgumentException();
        return new Money(amount.add(other.amount), currency);
    }
}

public final class UserId {
    private final UUID value;

    public UserId(UUID value) {
        this.value = Objects.requireNonNull(value);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof UserId that)) return false;
        return value.equals(that.value);
    }

    @Override
    public int hashCode() {
        return value.hashCode();  // or Objects.hash(value)
    }
}

@Override
public String toString() {
    return "Order{id=" + id + ", total=" + total + "}";
}
// Records: compiler generates toString listing components

// Prefer explicit copy
List<String> copy = new ArrayList<>(original);
// Or List.copyOf(original) for unmodifiable snapshot

try (var in = Files.newInputStream(path)) {
    process(in);
}  // close called automatically — deterministic cleanup