Basics of OOP — Senior Level¶

// Identity hash code is NOT the memory address (common myth)
Object o = new Object();
int hash1 = System.identityHashCode(o);
System.gc(); // object may be moved in memory
int hash2 = System.identityHashCode(o);
assert hash1 == hash2; // always true — hash is stable

// Only these three classes can extend Shape
public sealed class Shape permits Circle, Rectangle, Triangle {
    abstract double area();
}

public final class Circle extends Shape {
    private final double radius;
    Circle(double r) { this.radius = r; }
    @Override double area() { return Math.PI * radius * radius; }
}

public final 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; }
}

public final class Triangle extends Shape {
    private final double base, height;
    Triangle(double b, double h) { this.base = b; this.height = h; }
    @Override double area() { return 0.5 * base * height; }
}

class Suboptimal {
    boolean a;  // 1 byte + 7 padding (if followed by long)
    long b;     // 8 bytes
    boolean c;  // 1 byte + 7 padding
    // Total: 32 bytes (header 12 + fields 24 aligned)
}
// JVM actually reorders to: long b, boolean a, boolean c
// Total: 24 bytes (header 12 + 8 + 1 + 1 + 2 padding)

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(1)
@State(Scope.Thread)
public class ObjectCreationBenchmark {

    @Benchmark
    public Object createPlainObject() {
        return new Object();
    }

    @Benchmark
    public Point createRecordObject() {
        return new Point(1, 2);
    }

    @Benchmark
    public LegacyPoint createLegacyObject() {
        return new LegacyPoint(1, 2);
    }

    @Benchmark
    public int avoidCreation_returnPrimitive() {
        return 1 + 2; // no object created — scalar replacement by JIT
    }

    record Point(int x, int y) {}

    static class LegacyPoint {
        final int x, y;
        LegacyPoint(int x, int y) { this.x = x; this.y = y; }
    }
}

import java.util.ArrayDeque;

public class Main {
    public static void main(String[] args) {
        ObjectPool<StringBuilder> pool = new ObjectPool<>(
            () -> new StringBuilder(256),   // factory
            sb -> sb.setLength(0),           // reset
            16                               // max size
        );

        // Borrow, use, return
        StringBuilder sb = pool.borrow();
        sb.append("Hello ").append("World");
        String result = sb.toString();
        pool.returnToPool(sb);

        System.out.println(result);
        System.out.println("Pool size: " + pool.size());
    }
}

class ObjectPool<T> {
    private final ArrayDeque<T> pool;
    private final java.util.function.Supplier<T> factory;
    private final java.util.function.Consumer<T> resetter;
    private final int maxSize;

    ObjectPool(java.util.function.Supplier<T> factory,
               java.util.function.Consumer<T> resetter,
               int maxSize) {
        this.pool = new ArrayDeque<>(maxSize);
        this.factory = factory;
        this.resetter = resetter;
        this.maxSize = maxSize;
    }

    T borrow() {
        T obj = pool.pollFirst();
        return obj != null ? obj : factory.get();
    }

    void returnToPool(T obj) {
        resetter.accept(obj);
        if (pool.size() < maxSize) {
            pool.offerFirst(obj);
        }
    }

    int size() { return pool.size(); }
}

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Triangle(3, 8)
        };

        for (Shape s : shapes) {
            System.out.printf("%s -> area=%.2f, description=%s%n",
                s.getClass().getSimpleName(), s.area(), describe(s));
        }
    }

    // Exhaustive pattern matching (Java 21+ preview)
    static String describe(Shape shape) {
        // Traditional approach (works in Java 17)
        if (shape instanceof Circle c) {
            return "Circle with radius " + c.getRadius();
        } else if (shape instanceof Rectangle r) {
            return "Rectangle " + r.getWidth() + "x" + r.getHeight();
        } else if (shape instanceof Triangle t) {
            return "Triangle base=" + t.getBase();
        }
        throw new IllegalStateException("Unknown shape"); // sealed guarantees this never happens
    }
}

sealed class Shape permits Circle, Rectangle, Triangle {
    abstract double area();
}

final class Circle extends Shape {
    private final double radius;
    Circle(double radius) { this.radius = radius; }
    double getRadius() { return radius; }
    @Override double area() { return Math.PI * radius * radius; }
}

final class Rectangle extends Shape {
    private final double width, height;
    Rectangle(double w, double h) { this.width = w; this.height = h; }
    double getWidth() { return width; }
    double getHeight() { return height; }
    @Override double area() { return width * height; }
}

final class Triangle extends Shape {
    private final double base, height;
    Triangle(double b, double h) { this.base = b; this.height = h; }
    double getBase() { return base; }
    @Override double area() { return 0.5 * base * height; }
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Color red1 = Color.valueOf("RED");
        Color red2 = Color.valueOf("RED");
        System.out.println(red1 == red2); // true — same instance
        System.out.println("Cache size: " + Color.cacheSize());
    }
}

class Color {
    private static final Map<String, Color> CACHE = new HashMap<>();

    private final int r, g, b;
    private final String name;

    private Color(int r, int g, int b, String name) {
        this.r = r; this.g = g; this.b = b; this.name = name;
    }

    public static Color valueOf(String name) {
        return CACHE.computeIfAbsent(name.toUpperCase(), k -> {
            switch (k) {
                case "RED": return new Color(255, 0, 0, "RED");
                case "GREEN": return new Color(0, 255, 0, "GREEN");
                case "BLUE": return new Color(0, 0, 255, "BLUE");
                default: throw new IllegalArgumentException("Unknown: " + k);
            }
        });
    }

    public static int cacheSize() { return CACHE.size(); }
}

public class Main {
    public static void main(String[] args) {
        User user = findUser(999); // returns NullUser
        System.out.println(user.getName()); // "Unknown" — no NPE
        user.sendEmail("Hello");           // does nothing silently
    }

    static User findUser(int id) {
        if (id == 1) return new RealUser("Alice", "alice@mail.com");
        return NullUser.INSTANCE; // instead of returning null
    }
}

interface User {
    String getName();
    void sendEmail(String msg);
}

class RealUser implements User {
    private final String name, email;
    RealUser(String name, String email) { this.name = name; this.email = email; }
    public String getName() { return name; }
    public void sendEmail(String msg) {
        System.out.println("Sending '" + msg + "' to " + email);
    }
}

class NullUser implements User {
    static final NullUser INSTANCE = new NullUser();
    private NullUser() {}
    public String getName() { return "Unknown"; }
    public void sendEmail(String msg) { /* no-op */ }
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        TypeSafeMap map = new TypeSafeMap();
        map.put(String.class, "Hello");
        map.put(Integer.class, 42);
        map.put(Double.class, 3.14);

        String s = map.get(String.class);     // type-safe — no cast needed
        Integer i = map.get(Integer.class);
        System.out.println(s + " " + i);      // Hello 42
    }
}

class TypeSafeMap {
    private final Map<Class<?>, Object> map = new HashMap<>();

    public <T> void put(Class<T> type, T value) {
        map.put(type, type.cast(value));
    }

    public <T> T get(Class<T> type) {
        return type.cast(map.get(type));
    }
}

// Only OrderService and Order are public — minimal API surface
public class OrderService {
    private final OrderRepository repo;       // interface (public)
    private final OrderValidator validator;    // package-private impl
    // ...
}

// Package-private — invisible outside com.example.order
class OrderValidator {
    boolean isValid(Order order) { /* ... */ }
}

public abstract class DomainException extends RuntimeException {
    private final String errorCode;
    private final Map<String, Object> context;

    protected DomainException(String message, String errorCode) {
        super(message);
        this.errorCode = errorCode;
        this.context = new HashMap<>();
    }

    public DomainException with(String key, Object value) {
        context.put(key, value);
        return this;
    }

    public String getErrorCode() { return errorCode; }
    public Map<String, Object> getContext() { return Collections.unmodifiableMap(context); }
}

public class EntityNotFoundException extends DomainException {
    public EntityNotFoundException(String entity, Object id) {
        super(entity + " not found with id: " + id, "ENTITY_NOT_FOUND");
        with("entity", entity).with("id", id);
    }
}

// ❌ Deserialization can bypass constructor validation
class User implements Serializable {
    private String role;
    public User(String role) {
        if (!List.of("USER", "ADMIN").contains(role))
            throw new IllegalArgumentException("Invalid role");
        this.role = role;
    }
}
// Attacker can craft a serialized byte stream with role="SUPERADMIN"
// bypassing the constructor check entirely

// ✅ Add readResolve/readObject validation
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
    ois.defaultReadObject();
    if (!List.of("USER", "ADMIN").contains(this.role)) {
        throw new InvalidObjectException("Invalid role: " + this.role);
    }
}

// JIT may replace this with two local variables (scalar replacement)
void process(int x, int y) {
    Point p = new Point(x, y); // allocated on stack, not heap
    int sum = p.x + p.y;
    return sum;
}
// After JIT optimization: equivalent to return x + y;

// ❌ Objects.hash() creates int[] on every call
@Override
public int hashCode() {
    return Objects.hash(field1, field2, field3); // allocates varargs array
}

// ✅ Pre-compute for immutable objects
final class OrderKey {
    private final String customerId;
    private final long orderId;
    private final int hash;

    OrderKey(String customerId, long orderId) {
        this.customerId = customerId;
        this.orderId = orderId;
        this.hash = 31 * customerId.hashCode() + Long.hashCode(orderId);
    }

    @Override public int hashCode() { return hash; }
    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof OrderKey)) return false;
        OrderKey k = (OrderKey) o;
        return orderId == k.orderId && customerId.equals(k.customerId);
    }
}

// ❌ Using auto-generated @Id in equals — breaks before entity is persisted
@Entity
class Order {
    @Id @GeneratedValue
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Order)) return false;
        return Objects.equals(id, ((Order) o).id); // both null before persist!
    }
}

// ✅ Use business key (natural key)
@Entity
class Order {
    @Id @GeneratedValue
    private Long id;

    @Column(unique = true, nullable = false)
    private String orderNumber;

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

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

// Private fields can be accessed via reflection
Field nameField = User.class.getDeclaredField("name");
nameField.setAccessible(true); // bypasses private!
nameField.set(user, "Hacked");

// ❌ This class is a time bomb in any HashMap
class Key {
    final String value;
    Key(String v) { this.value = v; }

    @Override
    public boolean equals(Object o) {
        return o instanceof Key && value.equals(((Key) o).value);
    }
    // hashCode() not overridden — uses Object.hashCode() (identity)
}

// ❌ finalize is deprecated, non-deterministic, and delays GC
class Resource {
    @Override
    protected void finalize() throws Throwable {
        close(); // may never run, or run much later
    }
}

// ✅ Use Cleaner (Java 9+) or try-with-resources
class Resource implements AutoCloseable {
    @Override
    public void close() { /* release resource */ }
}

record Temperature(double value, String unit) {
    // Compact constructor — no parameter list
    Temperature {
        if (unit == null || unit.isBlank()) throw new IllegalArgumentException("unit required");
        unit = unit.toUpperCase(); // reassigns the parameter, NOT the field
        // Fields are assigned automatically AFTER this block
    }
}

class Container implements Cloneable {
    List<String> items = new ArrayList<>();

    @Override
    public Container clone() {
        try {
            Container copy = (Container) super.clone(); // shallow copy
            // copy.items is the SAME list object — mutation affects both!
            copy.items = new ArrayList<>(items); // deep copy needed
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

@Entity
class Product {
    @Id @GeneratedValue
    private Long id;
    private String name;

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Product)) return false;
        return Objects.equals(id, ((Product) o).id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

class Packed {
    long a;     // 8 bytes
    int b;      // 4 bytes
    short c;    // 2 bytes
    byte d;     // 1 byte
    boolean e;  // 1 byte
}