OOP in Java in Java

public class BankAccount {
    // Instance fields
    private final String owner;   // final = set once in constructor
    private double balance;

    // Constructor
    public BankAccount(String owner, double initialBalance) {
        if (initialBalance < 0) {
            throw new IllegalArgumentException("Balance cannot be negative");
        }
        this.owner   = owner;
        this.balance = initialBalance;
    }

    // Methods
    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > balance) throw new IllegalStateException("Insufficient funds");
        balance -= amount;
    }

    // Getters — no setters for immutable fields
    public String getOwner()   { return owner; }
    public double getBalance() { return balance; }

    @Override
    public String toString() {
        return String.format("BankAccount{owner='%s', balance=%.2f}", owner, balance);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BankAccount that)) return false;
        return owner.equals(that.owner);   // same owner = same account
    }

    @Override
    public int hashCode() {
        return owner.hashCode();
    }
}

// Abstract class — cannot be instantiated, may have abstract methods
abstract class Shape {
    abstract double area();
    abstract double perimeter();

    // Concrete method — shared by all shapes
    void describe() {
        System.out.printf("Area: %.2f, Perimeter: %.2f%n", area(), perimeter());
    }
}

class Circle extends Shape {
    private final double radius;
    Circle(double radius) { this.radius = radius; }

    @Override double area()      { return Math.PI * radius * radius; }
    @Override double perimeter() { return 2 * Math.PI * radius; }
}

class Rectangle extends Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }

    @Override double area()      { return w * h; }
    @Override double perimeter() { return 2 * (w + h); }
}

// Polymorphism — same variable type, different runtime behaviour
Shape[] shapes = { new Circle(5), new Rectangle(4, 3) };
for (Shape s : shapes) {
    s.describe();   // calls Circle.area() or Rectangle.area() at runtime
}

// Interface — a contract (all methods public by default)
interface Printable {
    void print();

    // Default method (Java 8+) — optional implementation
    default void printWithBorder() {
        System.out.println("---");
        print();
        System.out.println("---");
    }

    // Static method in interface (Java 8+)
    static Printable of(String text) {
        return () -> System.out.println(text);   // lambda
    }
}

interface Saveable {
    void save(String path);
}

// A class can implement MULTIPLE interfaces (but extend only ONE class)
class Document implements Printable, Saveable {
    private String content;

    Document(String content) { this.content = content; }

    @Override public void print() { System.out.println(content); }
    @Override public void save(String path) { /* write to file */ }
}

// Functional interface — exactly one abstract method, usable as lambda
@FunctionalInterface
interface Transformer<T, R> {
    R transform(T input);
}

Transformer<String, Integer> lengthOf = String::length;
System.out.println(lengthOf.transform("Hello"));   // 5