Object-Oriented Programming in Java

// BAD: No encapsulation — anyone can mutate balance
public class UnsafeAccount {
    public double balance; // exposed!
}

// Thread A reads balance = 1000, decides to withdraw 800
// Thread B reads balance = 1000, decides to withdraw 600
// Both succeed → balance = -400 (impossible state)

public class BankAccount {
    private double balance;
    private final ReentrantLock lock = new ReentrantLock();

    public BankAccount(double initialBalance) {
        if (initialBalance < 0) throw new IllegalArgumentException("Negative initial balance");
        this.balance = initialBalance;
    }

    public boolean withdraw(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        lock.lock();
        try {
            if (amount > balance) return false;
            balance -= amount;
            return true;
        } finally {
            lock.unlock();
        }
    }

    public double getBalance() {
        return balance; // read-only access — no setter exists
    }
}

public class Order {
    private final String userId;    // mandatory
    private final List<Item> items; // mandatory
    private final String couponCode;
    private final boolean giftWrap;

    private Order(Builder b) {
        this.userId = Objects.requireNonNull(b.userId);
        this.items = List.copyOf(b.items); // defensive copy!
        this.couponCode = b.couponCode;
        this.giftWrap = b.giftWrap;
    }

    public static class Builder {
        private String userId;
        private List<Item> items;
        private String couponCode;
        private boolean giftWrap = false;

        public Builder userId(String id) { this.userId = id; return this; }
        public Builder items(List<Item> items) { this.items = items; return this; }
        public Builder couponCode(String code) { this.couponCode = code; return this; }
        public Builder giftWrap(boolean wrap) { this.giftWrap = wrap; return this; }

        public Order build() {
            if (userId == null || items == null || items.isEmpty())
                throw new IllegalStateException("userId and items are required");
            return new Order(this);
        }
    }
}

@Component
public class PaymentConfig {
    @Value("${payment.retry.max:3}")
    private int maxRetries;

    @Value("${payment.timeout.ms:5000}")
    private int timeoutMs;

    // No setters. Only behavior exposed:
    public RetryPolicy getRetryPolicy() {
        return new RetryPolicy(maxRetries, timeoutMs);
    }
}

// Caller never knows which DB it's talking to
Connection conn = dataSource.getConnection();
PreparedStatement ps = conn.prepareStatement("SELECT * FROM orders WHERE user_id = ?");
ps.setString(1, userId);
ResultSet rs = ps.executeQuery();

// WITHOUT abstraction: manual transaction management
public void transferMoney(String from, String to, double amount) {
    Connection conn = null;
    try {
        conn = dataSource.getConnection();
        conn.setAutoCommit(false);
        debit(conn, from, amount);
        credit(conn, to, amount);
        conn.commit();
    } catch (Exception e) {
        conn.rollback();
        throw e;
    } finally {
        conn.close();
    }
}

// WITH abstraction: one annotation hides all the plumbing
@Transactional
public void transferMoney(String from, String to, double amount) {
    debit(from, amount);
    credit(to, amount);
}

public interface PaymentGateway {
    PaymentResult charge(Money amount, PaymentInstrument instrument);
    PaymentResult refund(String transactionId, Money amount);
    PaymentStatus checkStatus(String transactionId);
}

// Stripe implementation
@Service("stripeGateway")
public class StripePaymentGateway implements PaymentGateway {
    @Override
    public PaymentResult charge(Money amount, PaymentInstrument instrument) {
        // Stripe-specific API calls, retry logic, error mapping
    }
}

// Razorpay implementation
@Service("razorpayGateway")
public class RazorpayPaymentGateway implements PaymentGateway {
    @Override
    public PaymentResult charge(Money amount, PaymentInstrument instrument) {
        // Razorpay-specific API calls
    }
}

public abstract class OrderProcessor {
    // Template method — defines the skeleton
    public final OrderResult process(Order order) {
        validate(order);
        Money total = calculateTotal(order);
        PaymentResult payment = chargePayment(order, total);
        if (payment.isSuccess()) {
            fulfill(order);
        }
        return buildResult(order, payment);
    }

    protected abstract void validate(Order order);
    protected abstract Money calculateTotal(Order order);
    protected abstract void fulfill(Order order);

    // Concrete shared logic
    private PaymentResult chargePayment(Order order, Money total) {
        return gateway.charge(total, order.getPaymentInstrument());
    }
}

public class DigitalOrderProcessor extends OrderProcessor {
    @Override protected void validate(Order o) { /* check download limits */ }
    @Override protected Money calculateTotal(Order o) { /* no shipping */ }
    @Override protected void fulfill(Order o) { /* send download link */ }
}

public class PhysicalOrderProcessor extends OrderProcessor {
    @Override protected void validate(Order o) { /* check address, stock */ }
    @Override protected Money calculateTotal(Order o) { /* + shipping + tax */ }
    @Override protected void fulfill(Order o) { /* create shipment */ }
}

class Entity {
    protected final String id;
    Entity() {
        this.id = UUID.randomUUID().toString();
        System.out.println("Entity created: " + id);
    }
}

class User extends Entity {
    private String email;
    User(String email) {
        // super() is implicitly inserted here
        this.email = email;
        System.out.println("User created: " + email);
    }
}

class AdminUser extends User {
    AdminUser(String email) {
        super(email); // explicitly calling User(email)
        System.out.println("Admin created");
    }
}

new AdminUser("admin@corp.com");
// Output:
// Entity created: <uuid>
// User created: admin@corp.com
// Admin created

// Library code — v1.0
public class InstrumentedHashSet<E> extends HashSet<E> {
    private int addCount = 0;

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }

    public int getAddCount() { return addCount; }
}

InstrumentedHashSet<String> s = new InstrumentedHashSet<>();
s.addAll(List.of("a", "b", "c"));
System.out.println(s.getAddCount()); // Expected 3, actual 6!

public class InstrumentedSet<E> implements Set<E> {
    private final Set<E> delegate; // composition
    private int addCount = 0;

    public InstrumentedSet(Set<E> delegate) { this.delegate = delegate; }

    @Override
    public boolean add(E e) {
        addCount++;
        return delegate.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return delegate.addAll(c); // delegate's addAll won't call OUR add
    }
    // ... delegate all other Set methods
}

public class JsonSerializer {
    public String serialize(Order order) {
        return objectMapper.writeValueAsString(order);
    }

    public String serialize(List<Order> orders) {
        return objectMapper.writeValueAsString(orders);
    }

    public String serialize(Order order, boolean prettyPrint) {
        ObjectWriter writer = prettyPrint
            ? objectMapper.writerWithDefaultPrettyPrinter()
            : objectMapper.writer();
        return writer.writeValueAsString(order);
    }
}

public interface PaymentStrategy {
    PaymentResult execute(PaymentRequest request);
    boolean supports(PaymentMethod method);
}

@Component
public class CreditCardStrategy implements PaymentStrategy {
    @Override
    public PaymentResult execute(PaymentRequest request) {
        // tokenize card, call acquirer, handle 3DS
        return acquirer.charge(request.getAmount(), request.getCardToken());
    }

    @Override
    public boolean supports(PaymentMethod method) {
        return method == PaymentMethod.CREDIT_CARD;
    }
}

@Component
public class UpiStrategy implements PaymentStrategy {
    @Override
    public PaymentResult execute(PaymentRequest request) {
        // generate UPI intent, call PSP
        return psp.collectPayment(request.getVpa(), request.getAmount());
    }

    @Override
    public boolean supports(PaymentMethod method) {
        return method == PaymentMethod.UPI;
    }
}

@Service
public class PaymentService {
    private final List<PaymentStrategy> strategies; // Spring injects ALL implementations

    public PaymentService(List<PaymentStrategy> strategies) {
        this.strategies = strategies;
    }

    public PaymentResult processPayment(PaymentRequest request) {
        return strategies.stream()
            .filter(s -> s.supports(request.getMethod()))
            .findFirst()
            .orElseThrow(() -> new UnsupportedPaymentException(request.getMethod()))
            .execute(request);
    }
}

class AnimalFactory {
    Animal create() { return new Animal(); }
}

class DogFactory extends AnimalFactory {
    @Override
    Dog create() { return new Dog(); } // Dog is a subtype of Animal — valid!
}

@Service
public class OrderService {
    private final OrderRepository repository;     // composition — lifecycle managed by Spring
    private final PaymentGateway paymentGateway;  // composition
    private final EventPublisher eventPublisher;  // composition

    // Constructor injection — Spring wires these; OrderService "owns" them logically
    public OrderService(OrderRepository repository,
                        PaymentGateway paymentGateway,
                        EventPublisher eventPublisher) {
        this.repository = repository;
        this.paymentGateway = paymentGateway;
        this.eventPublisher = eventPublisher;
    }

    @Transactional
    public OrderResult placeOrder(OrderRequest request) {
        Order order = repository.save(Order.from(request));
        PaymentResult payment = paymentGateway.charge(order.getTotal(), request.getInstrument());
        eventPublisher.publish(new OrderPlacedEvent(order.getId()));
        return OrderResult.success(order, payment);
    }
}

public class Employee {
    private String name;
    private String employeeId;
    // Employee exists independently — can transfer departments
}

public class Department {
    private String name;
    private List<Employee> employees; // aggregation — employees outlive the department

    public Department(String name) {
        this.name = name;
        this.employees = new ArrayList<>();
    }

    public void addEmployee(Employee e) { employees.add(e); }
    public void removeEmployee(Employee e) { employees.remove(e); }
    // If department is dissolved, employees still exist
}

// GOD CLASS: UserService handles auth, profile, notifications, and billing
public class UserService {
    public User login(String email, String password) { /* auth logic */ }
    public void updateProfile(User user, ProfileDTO dto) { /* profile logic */ }
    public void sendWelcomeEmail(User user) { /* notification logic */ }
    public Invoice generateInvoice(User user) { /* billing logic */ }
}
// Bug: developer fixing billing breaks auth. 12 test files coupled to this class.

// Every new report type requires modifying this method
public class ReportGenerator {
    public byte[] generate(String type, Data data) {
        if (type.equals("PDF")) { /* PDF logic */ }
        else if (type.equals("CSV")) { /* CSV logic */ }
        else if (type.equals("EXCEL")) { /* Excel logic */ }
        // Adding XML? Must modify this class. Violates OCP.
    }
}

class Rectangle {
    protected int width, height;
    public void setWidth(int w) { this.width = w; }
    public void setHeight(int h) { this.height = h; }
    public int area() { return width * height; }
}

class Square extends Rectangle {
    @Override public void setWidth(int w) { width = w; height = w; }
    @Override public void setHeight(int h) { width = h; height = h; }
}

// Client code:
Rectangle r = new Square();
r.setWidth(5);
r.setHeight(10);
assert r.area() == 50; // FAILS! area() returns 100

interface Worker {
    void code();
    void attendMeeting();
    void writeDocumentation();
    void fixBugs();
    void doCodeReview();
}

// Intern is forced to implement code review — which they can't do
class Intern implements Worker {
    public void doCodeReview() { throw new UnsupportedOperationException(); } // ISP violation
}

// High-level module directly depends on low-level module
public class NotificationService {
    private final SmtpEmailSender sender = new SmtpEmailSender(); // concrete!

    public void notify(User user, String msg) {
        sender.send(user.getEmail(), msg); // can't switch to SES, can't unit test
    }
}

interface Loggable {
    default void log(String msg) {
        System.out.println("[LOG] " + msg);
    }
}

interface Auditable {
    default void log(String msg) {
        System.out.println("[AUDIT] " + msg);
    }
}

class TransactionService implements Loggable, Auditable {
    // COMPILE ERROR: class inherits unrelated defaults for log(String)
    // MUST override to resolve:
    @Override
    public void log(String msg) {
        Loggable.super.log(msg); // explicitly choose
    }
}

interface A { default void hello() { System.out.println("A"); } }
interface B extends A { default void hello() { System.out.println("B"); } }

class C implements A, B {} // Rule 2: B is more specific → B's hello() wins

class D implements A, B {
    @Override
    public void hello() { A.super.hello(); } // explicit resolution
}

public class Employee {
    private final String id;
    private final String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Employee e)) return false;
        return Objects.equals(id, e.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id); // MUST be consistent with equals
    }
}

Map<Employee, String> map = new HashMap<>();
Employee e1 = new Employee("E001", "Vamsi");
map.put(e1, "Engineering");

Employee e2 = new Employee("E001", "Vamsi"); // same logical identity
System.out.println(map.get(e2)); // null! Different hashCode → wrong bucket

@Override
public String toString() {
    return "Order{id=%s, status=%s, total=%s, userId=%s}"
        .formatted(id, status, total, userId);
}

// Instead of clone():
public class Order {
    public Order(Order original) {
        this.id = UUID.randomUUID().toString(); // new ID
        this.items = new ArrayList<>(original.items); // deep copy
        this.status = OrderStatus.DRAFT; // reset state
    }
}

public class DatabaseConnection implements AutoCloseable {
    @Override
    public void close() {
        // deterministic cleanup
        connection.close();
    }
}

class A {
    int x = 10;
    void show() { System.out.println("A: " + x); }
}

class B extends A {
    int x = 20;
    void show() { System.out.println("B: " + x); }
}

public class Test {
    public static void main(String[] args) {
        A obj = new B();
        System.out.println(obj.x);
        obj.show();
    }
}

class Parent {
    int value = 10;
    Parent() { display(); }
    void display() { System.out.println("Parent: " + value); }
}

class Child extends Parent {
    int value = 20;
    Child() { display(); }
    @Override
    void display() { System.out.println("Child: " + value); }
}

public class Test {
    public static void main(String[] args) { new Child(); }
}

class Base {
    static void greet() { System.out.println("Base"); }
}

class Derived extends Base {
    static void greet() { System.out.println("Derived"); }
}

public class Test {
    public static void main(String[] args) {
        Base obj = new Derived();
        obj.greet();
    }
}

class A {
    static { System.out.println("A static"); }
    { System.out.println("A instance"); }
    A() { System.out.println("A constructor"); }
}

class B extends A {
    static { System.out.println("B static"); }
    { System.out.println("B instance"); }
    B() { System.out.println("B constructor"); }
}

public class Test {
    public static void main(String[] args) { new B(); }
}

class Animal {
    Animal create() {
        System.out.println("Animal created");
        return new Animal();
    }
}

class Dog extends Animal {
    @Override
    Dog create() { // covariant return — valid!
        System.out.println("Dog created");
        return new Dog();
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.create();
    }
}

class Parent {
    void process(int x) { System.out.println("Parent int: " + x); }
}

class Child extends Parent {
    void process(long x) { System.out.println("Child long: " + x); }
}

public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.process(10);
    }
}

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        if (o instanceof Point p) return x == p.x && y == p.y;
        return false;
    }
}

class ColorPoint extends Point {
    String color;
    ColorPoint(int x, int y, String color) { super(x, y); this.color = color; }

    @Override
    public boolean equals(Object o) {
        if (o instanceof ColorPoint cp) return super.equals(cp) && color.equals(cp.color);
        if (o instanceof Point) return super.equals(o); // asymmetric!
        return false;
    }
}

public class Test {
    public static void main(String[] args) {
        Point p = new Point(1, 2);
        ColorPoint cp = new ColorPoint(1, 2, "RED");
        System.out.println(p.equals(cp));  // true (Point ignores color)
        System.out.println(cp.equals(p));  // true (ColorPoint falls through to super)

        ColorPoint cp2 = new ColorPoint(1, 2, "BLUE");
        System.out.println(cp.equals(cp2)); // false (different color)
        System.out.println(p.equals(cp));   // true
        System.out.println(p.equals(cp2));  // true
        // Transitivity violated: cp.equals(p) && p.equals(cp2) but !cp.equals(cp2)
    }
}

interface Printable {
    default void print() { System.out.println("Printable"); }
}

interface Showable extends Printable {
    default void print() { System.out.println("Showable"); }
}

class Document implements Printable, Showable {}

public class Test {
    public static void main(String[] args) {
        new Document().print();
    }
}

class Vehicle {}
class Car extends Vehicle {}
class ElectricCar extends Car {}

ElectricCar ec = new ElectricCar();
System.out.println(ec instanceof Vehicle);     // ?
System.out.println(ec instanceof Car);         // ?
System.out.println(ec instanceof ElectricCar); // ?
System.out.println(ec instanceof Object);      // ?

Vehicle v = null;
System.out.println(v instanceof Vehicle);      // ?

List<String> strings = new ArrayList<>();
strings.add("hello");
List rawList = strings;         // raw type — no compile error
rawList.add(42);                // no compile error (raw type bypass)
String s = strings.get(1);     // ClassCastException at runtime!