Object-Oriented Programming in Java

Object-Oriented Programming (OOP) is the foundation of Java. Everything in Java revolves around objects and classes, making it one of the most naturally OOP-friendly languages available.

Core Concepts

1. Class & Object

A class is a blueprint. An object is an instance of that blueprint.

public class Car {
    String brand;
    int year;

    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public void drive() {
        System.out.println(brand + " is driving!");
    }
}

// Creating an object
Car myCar = new Car("Toyota", 2022);
myCar.drive(); // Toyota is driving!

---

2. Encapsulation

Encapsulation means bundling data (fields) and behavior (methods) together, while restricting direct access to internal state using access modifiers.

Key Idea

Hide the data, expose the behavior.

public class BankAccount {
    private double balance; // hidden from outside

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

Access Modifiers:

Modifier	Same Class	Same Package	Subclass	Everywhere
private	✅	❌	❌	❌
(default)	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

Spring Tip

Spring beans rely heavily on encapsulation. @Service, @Repository, and @Component classes expose only what's needed through public methods or interfaces.

---

3. Inheritance

Inheritance allows a class to acquire properties and methods from a parent class using the extends keyword.

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void makeSound() {
        System.out.println(name + " makes a sound.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name); // call parent constructor
    }

    @Override
    public void makeSound() {
        System.out.println(name + " barks!");
    }
}

Animal dog = new Dog("Rex");
dog.makeSound(); // Rex barks!

Key rules:

• Java supports single inheritance only (one parent class)
• Use super to access parent class members
• @Override annotation signals an intentional method override — always use it!

warning

Avoid deep inheritance chains (more than 2–3 levels). They make code harder to understand and maintain. Prefer composition over inheritance when possible.

---

4. Polymorphism

Polymorphism means "many forms" — the same interface can behave differently depending on the actual object.

Compile-time (Method Overloading)

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) { // same name, different params
        return a + b;
    }
}

Runtime (Method Overriding)

public class Shape {
    public double area() {
        return 0;
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

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

public class Rectangle extends Shape {
    private double width, height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

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

// Polymorphic behavior
List<Shape> shapes = List.of(new Circle(5), new Rectangle(4, 6));
shapes.forEach(s -> System.out.println(s.area()));

Spring Tip

Polymorphism powers Spring's dependency injection. You program to an interface, and Spring injects the correct implementation at runtime.

---

5. Abstraction

Abstraction hides implementation details and exposes only the essential features. Java achieves this through abstract classes and interfaces.

Abstract Class

public abstract class Vehicle {
    protected String model;

    public Vehicle(String model) {
        this.model = model;
    }

    public abstract void fuelUp(); // must be implemented by subclass

    public void startEngine() {    // shared behavior
        System.out.println(model + " engine started.");
    }
}

public class ElectricCar extends Vehicle {
    public ElectricCar(String model) {
        super(model);
    }

    @Override
    public void fuelUp() {
        System.out.println(model + " is charging...");
    }
}

Interface

public interface Payable {
    void processPayment(double amount); // implicitly public & abstract

    default void printReceipt() {       // default method (Java 8+)
        System.out.println("Payment processed.");
    }
}

public class CreditCardPayment implements Payable {
    @Override
    public void processPayment(double amount) {
        System.out.println("Charging $" + amount + " to credit card.");
    }
}

Abstract Class vs Interface:

Feature	Abstract Class	Interface
Instantiation	❌ Cannot	❌ Cannot
Multiple inheritance	❌ No	✅ Yes (implements A, B)
Constructor	✅ Yes	❌ No
Fields	Any type	public static final only
Methods	Abstract + concrete	Abstract + default/static

Spring Tip

Interfaces are everywhere in Spring. JpaRepository, ApplicationContext, BeanFactory — you always code to the interface, letting Spring provide the implementation.

---

SOLID Principles

These 5 principles guide writing clean, maintainable OOP code.

Principle	Description
Single Responsibility	A class should have only one reason to change
Open/Closed	Open for extension, closed for modification
Liskov Substitution	Subclasses must be substitutable for their base class
Interface Segregation	Prefer small, specific interfaces over large, general ones
Dependency Inversion	Depend on abstractions, not concrete implementations

// ✅ Dependency Inversion in Spring
@Service
public class OrderService {
    private final PaymentGateway paymentGateway; // interface, not implementation

    public OrderService(PaymentGateway paymentGateway) { // injected by Spring
        this.paymentGateway = paymentGateway;
    }
}

note

Following SOLID principles naturally leads to better Spring application design — especially Dependency Inversion, which is the backbone of Spring's IoC container.

---

Quick Reference

OOP in Java
├── Encapsulation  → private fields + public getters/setters
├── Inheritance    → extends (single), super keyword
├── Polymorphism   → overloading (compile-time), overriding (runtime)
└── Abstraction    → abstract class, interface

Further Reading

• Java OOP Documentation (Oracle)
• Effective Java – Joshua Bloch
• Spring Framework & OOP Patterns

---

Advanced Editorial Pass: OOP as Boundary Design, Not Boilerplate

Architectural Lens

• OOP value comes from explicit boundaries, invariants, and change isolation.
• Encapsulation should protect business rules, not merely hide fields.
• Composition strategy should reflect domain volatility and extension pressure.

Common Misuse Patterns

• Inheritance used for code reuse instead of semantic substitutability.
• Anemic models that move all behavior into service layers.
• Over-abstracted class hierarchies without real variation.

Senior Heuristics

1. Keep domain invariants close to the data they constrain.
2. Prefer composition when behavior variation is runtime-driven.
3. Audit object responsibilities regularly to prevent god objects.

Compare Next

• Java Fundamentals: Core Language Concepts
• Java Collections Framework: Deep Dive
• Java Interview Questions & Answers