Java Language Specification — Basics of OOP¶

class Parent {
    int x = 10;
    int getX() { return x; }
}
class Child extends Parent {
    int x = 20;               // hides Parent.x
    @Override int getX() { return x; }  // overrides

}
Parent p = new Child();
System.out.println(p.x);      // 10 (field: compile-time type)
System.out.println(p.getX()); // 20 (method: runtime type)

interface A {
    default String name() { return "A"; }
}
interface B extends A {
    default String name() { return "B"; }
}
class C implements A, B {
    // Must override to resolve conflict (or not — B is more specific and wins here)
    // In this case B overrides A, so C inherits B's default
    @Override
    public String name() { return B.super.name(); }  // explicit super call
}

class Producer {
    Object produce() { return new Object(); }
}
class StringProducer extends Producer {
    @Override
    String produce() { return "hello"; }  // covariant: String is-a Object
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    Person(String name) {
        this(name, 0);  // chains to two-arg constructor
    }

    Person() {
        this("Unknown");  // chains to one-arg constructor
    }
}

abstract class Vehicle {
    protected String brand;

    Vehicle(String brand) {      // abstract class CAN have constructor
        this.brand = brand;
    }

    abstract void move();
}

class Car extends Vehicle {
    Car(String brand) {
        super(brand);            // must call abstract class constructor
    }

    @Override
    void move() {
        System.out.println(brand + " car is moving");
    }
}

record Range(int lo, int hi) {
    Range {  // compact constructor — no parameter list needed
        if (lo > hi) {
            throw new IllegalArgumentException("lo > hi");
        }
        // lo and hi are implicitly assigned from components
    }
}

// Example 1: Classes, Inheritance, Polymorphism
// File: OopBasics.java
public class OopBasics {

    // Abstract superclass
    abstract static class Shape {
        protected String color;

        Shape(String color) {
            this.color = color;
        }

        abstract double area();
        abstract double perimeter();

        @Override
        public String toString() {
            return "%s[color=%s, area=%.2f]".formatted(
                getClass().getSimpleName(), color, area());
        }
    }

    // Concrete subclass
    static class Circle extends Shape {
        private final double radius;

        Circle(String color, double radius) {
            super(color);  // call superclass constructor
            this.radius = radius;
        }

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

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

    static class Rectangle extends Shape {
        private final double width, height;

        Rectangle(String color, double width, double height) {
            super(color);
            this.width = width;
            this.height = height;
        }

        @Override
        public double area() { return width * height; }

        @Override
        public double perimeter() { return 2 * (width + height); }
    }

    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle("red", 5.0),
            new Rectangle("blue", 4.0, 6.0),
            new Circle("green", 3.0)
        };

        for (Shape s : shapes) {
            System.out.println(s);  // polymorphic toString and area()
        }

        // Pattern matching with sealed types
        for (Shape s : shapes) {
            String desc = switch (s) {
                case Circle c    -> "Circle with radius " + c.radius;
                case Rectangle r -> "Rect " + r.width + "x" + r.height;
                default          -> "Unknown shape";
            };
            System.out.println(desc);
        }
    }
}

// Example 2: Interfaces with Default Methods
// File: InterfaceDemo.java
import java.util.Comparator;

public class InterfaceDemo {

    // Interface with abstract and default methods
    interface Printable {
        void print();  // abstract

        default void printTwice() {  // default
            print();
            print();
        }

        static Printable of(String msg) {  // static factory
            return () -> System.out.println(msg);
        }
    }

    interface Saveable {
        void save();

        default String describe() { return "Saveable"; }
    }

    // Class implementing multiple interfaces
    static class Document implements Printable, Saveable {
        private final String content;

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

        @Override
        public void print() { System.out.println("Doc: " + content); }

        @Override
        public void save() { System.out.println("Saving: " + content); }

        @Override
        public String describe() { return "Document"; }  // resolves ambiguity
    }

    interface Sortable<T> extends Comparable<T> {
        default boolean isLessThan(T other) {
            return compareTo(other) < 0;
        }
    }

    static class Version implements Sortable<Version> {
        final int major, minor;

        Version(int major, int minor) {
            this.major = major;
            this.minor = minor;
        }

        @Override
        public int compareTo(Version other) {
            int cmp = Integer.compare(this.major, other.major);
            return cmp != 0 ? cmp : Integer.compare(this.minor, other.minor);
        }

        @Override
        public String toString() { return major + "." + minor; }
    }

    public static void main(String[] args) {
        Document doc = new Document("Hello, Java!");
        doc.printTwice();
        doc.save();
        System.out.println(doc.describe());

        // Static factory method on interface
        Printable p = Printable.of("From static factory");
        p.print();

        // Interface type variable
        Version v1 = new Version(2, 0);
        Version v2 = new Version(1, 9);
        System.out.println(v2 + " < " + v1 + ": " + v2.isLessThan(v1));  // true
    }
}

// Example 3: Encapsulation with Accessors and Mutators
// File: Encapsulation.java
import java.util.Objects;

public class Encapsulation {

    static class BankAccount {
        private final String accountId;
        private double balance;
        private String owner;

        BankAccount(String accountId, String owner, double initialBalance) {
            this.accountId = Objects.requireNonNull(accountId, "accountId cannot be null");
            this.owner = Objects.requireNonNull(owner, "owner cannot be null");
            if (initialBalance < 0) throw new IllegalArgumentException("Initial balance must be >= 0");
            this.balance = initialBalance;
        }

        // Accessor (getter)
        public String getAccountId() { return accountId; }
        public double getBalance() { return balance; }
        public String getOwner() { return owner; }

        // Mutator (setter)
        public void setOwner(String owner) {
            this.owner = Objects.requireNonNull(owner, "owner cannot be null");
        }

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

        public void withdraw(double amount) {
            if (amount <= 0) throw new IllegalArgumentException("Withdrawal must be positive");
            if (amount > balance) throw new IllegalStateException("Insufficient funds");
            balance -= amount;
        }

        @Override
        public String toString() {
            return "Account[%s, owner=%s, balance=%.2f]".formatted(accountId, owner, balance);
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount("ACC-001", "Alice", 1000.00);
        System.out.println(account);

        account.deposit(500.00);
        System.out.println("After deposit: " + account.getBalance());

        account.withdraw(200.00);
        System.out.println("After withdrawal: " + account.getBalance());

        try {
            account.withdraw(2000.00);
        } catch (IllegalStateException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

// Example 4: Records and Sealed Classes (Java 21)
// File: ModernOop.java
public class ModernOop {

    // Sealed interface hierarchy
    sealed interface Result<T> permits Success, Failure {}

    record Success<T>(T value) implements Result<T> {}

    record Failure<T>(String error, Exception cause) implements Result<T> {
        Failure(String error) { this(error, null); }
    }

    // Enum with methods and fields
    enum Planet {
        MERCURY(3.303e+23, 2.4397e6),
        VENUS  (4.869e+24, 6.0518e6),
        EARTH  (5.976e+24, 6.37814e6),
        MARS   (6.421e+23, 3.3972e6);

        private final double mass;    // kg
        private final double radius;  // meters

        Planet(double mass, double radius) {
            this.mass = mass;
            this.radius = radius;
        }

        static final double G = 6.67300E-11;

        double surfaceGravity() {
            return G * mass / (radius * radius);
        }

        double surfaceWeight(double otherMass) {
            return otherMass * surfaceGravity();
        }
    }

    // Generic utility with sealed result
    static Result<Integer> safeDivide(int a, int b) {
        if (b == 0) return new Failure<>("Division by zero");
        return new Success<>(a / b);
    }

    static <T> T unwrapOrDefault(Result<T> result, T defaultValue) {
        return switch (result) {
            case Success<T> s -> s.value();
            case Failure<T> f -> {
                System.err.println("Error: " + f.error());
                yield defaultValue;
            }
        };
    }

    public static void main(String[] args) {
        // Records
        Result<Integer> r1 = safeDivide(10, 2);
        Result<Integer> r2 = safeDivide(10, 0);

        System.out.println(unwrapOrDefault(r1, -1));  // 5
        System.out.println(unwrapOrDefault(r2, -1));  // -1 (with error logged)

        // Enum usage
        double earthWeight = 75.0;
        double mass = earthWeight / Planet.EARTH.surfaceGravity();
        for (Planet p : Planet.values()) {
            System.out.printf("Weight on %s: %.2f%n", p, p.surfaceWeight(mass));
        }
    }
}

// Example 5: Complete OOP Design — Strategy Pattern
// File: StrategyPattern.java
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class StrategyPattern {

    // Interface (strategy)
    @FunctionalInterface
    interface SortStrategy<T> {
        List<T> sort(List<T> items);
    }

    // Concrete strategies
    static <T extends Comparable<T>> SortStrategy<T> naturalOrder() {
        return items -> items.stream().sorted().toList();
    }

    static <T> SortStrategy<T> by(Comparator<T> comparator) {
        return items -> items.stream().sorted(comparator).toList();
    }

    // Context class
    static class DataProcessor<T extends Comparable<T>> {
        private final List<T> data;
        private SortStrategy<T> strategy;

        DataProcessor(List<T> data) {
            this.data = List.copyOf(data);
            this.strategy = naturalOrder();  // default strategy
        }

        void setStrategy(SortStrategy<T> strategy) {
            this.strategy = strategy;
        }

        List<T> process() {
            return strategy.sort(data);
        }
    }

    record Employee(String name, int age, double salary) {}

    public static void main(String[] args) {
        List<Employee> employees = List.of(
            new Employee("Charlie", 35, 80000),
            new Employee("Alice", 28, 95000),
            new Employee("Bob", 42, 70000)
        );

        DataProcessor<String> nameProcessor = new DataProcessor<>(
            employees.stream().map(Employee::name).toList()
        );

        // Default: natural order
        System.out.println("Names sorted: " + nameProcessor.process());

        // Custom strategy: reverse order
        nameProcessor.setStrategy(by(Comparator.reverseOrder()));
        System.out.println("Names reversed: " + nameProcessor.process());

        // Strategy using method reference
        List<Employee> byAge = employees.stream()
            .sorted(Comparator.comparingInt(Employee::age))
            .toList();
        byAge.forEach(e -> System.out.printf("%s: %d%n", e.name(), e.age()));

        // Pattern matching for records
        for (var emp : employees) {
            switch (emp) {
                case Employee(String n, int age, double sal) when sal > 85000 ->
                    System.out.println(n + " is a high earner");
                case Employee(String n, _, _) ->
                    System.out.println(n + " is a regular employee");
            }
        }
    }
}