OOPs Concepts in Java with Real-World Examples: Encapsulation, Inheritance, Polymorphism, Abstraction

If a field is private final and never mutated, no method can break it. That is why String is immutable and why records are popular for value types. Interview questions that start with “why is String immutable?” are really encapsulation questions; the worked answers are in 30 Java String Programs for Interviews.

For an overridden instance method, the JVM uses the object’s class to find the method at runtime (a virtual call, invokevirtual in bytecode). Static methods, private methods and fields are not dispatched this way; they are resolved from the declared type. The comparison table and a real run showing static-method and field hiding are in the overloading-vs-overriding article linked above.

import java.util.ArrayList;
import java.util.List;

public class BankOop {
    public static void main(String[] args) {
        Customer asha = new Customer("Asha");
        asha.open(new SavingsAccount("SB-101", 100_000, 4.0));
        asha.open(new CurrentAccount("CA-201", 20_000));

        System.out.println("-- Encapsulation: state changes only through rules --");
        Account sb = asha.accounts().get(0);
        sb.deposit(5_000);
        System.out.println(sb.id() + " balance = " + sb.balance());
        try {
            sb.deposit(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
        try {
            sb.withdraw(1_000_000);
        } catch (IllegalStateException e) {
            System.out.println("rejected: " + e.getMessage());
        }

        System.out.println("-- Polymorphism: one call, different behaviour --");
        for (Account a : asha.accounts()) {
            System.out.printf("%s (%s) month-end interest = %.2f%n",
                    a.id(), a.getClass().getSimpleName(), a.monthEndInterest());
        }

        System.out.println("-- Overdraft limit is inherited behaviour, overridden --");
        Account ca = asha.accounts().get(1);
        ca.withdraw(24_000);
        System.out.println(ca.id() + " balance after 24000 withdrawal = " + ca.balance());

        System.out.println("-- Abstraction: callers depend on Statement only --");
        for (Account a : asha.accounts()) {
            Statement s = a;
            System.out.println(s.summary());
        }

        System.out.println("-- IS-A vs HAS-A --");
        System.out.println("SavingsAccount IS-A Account: " + (sb instanceof Account));
        System.out.println("Customer HAS-A list of accounts: " + asha.accounts().size());
        System.out.println("Customer IS-A Account: " + ((Object) asha instanceof Account));
    }
}

interface Statement {
    String summary();
}

abstract class Account implements Statement {
    private final String id;
    private double balance;

    protected Account(String id, double opening) {
        if (opening < 0) throw new IllegalArgumentException("opening balance must be >= 0");
        this.id = id;
        this.balance = opening;
    }

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

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

    public double balance() { return balance; }
    public String id() { return id; }

    protected double overdraftLimit() { return 0; }

    public abstract double monthEndInterest();

    @Override
    public String summary() {
        return id + " | balance " + balance;
    }
}

class SavingsAccount extends Account {
    private final double annualRatePercent;

    SavingsAccount(String id, double opening, double annualRatePercent) {
        super(id, opening);
        this.annualRatePercent = annualRatePercent;
    }

    @Override
    public double monthEndInterest() {
        return balance() * annualRatePercent / 100 / 12;
    }
}

class CurrentAccount extends Account {
    CurrentAccount(String id, double opening) { super(id, opening); }

    @Override
    protected double overdraftLimit() { return 5_000; }

    @Override
    public double monthEndInterest() { return 0; }

    @Override
    public String summary() {
        return super.summary() + " | overdraft limit " + overdraftLimit();
    }
}

class Customer {
    private final String name;
    private final List<Account> accounts = new ArrayList<>();

    Customer(String name) { this.name = name; }

    void open(Account a) { accounts.add(a); }

    List<Account> accounts() { return List.copyOf(accounts); }
}

Encapsulation, inheritance, polymorphism and abstraction. Encapsulation hides state behind methods, inheritance lets a class reuse another, polymorphism lets one call run different code per object, and abstraction exposes a contract while hiding the implementation.

A class is the blueprint (fields and methods). An object is one instance created with new, with its own copy of the instance fields. Many objects can come from one class.

Encapsulation protects state with private fields and validating methods. Abstraction hides complexity behind a simple interface or abstract class. One is about data protection, the other about reducing what callers must know.

Make fields private, expose behaviour through public methods that validate input, and return copies or immutable views of mutable internals.

Overloading: same name, different parameter lists, resolved by the compiler (compile-time polymorphism). Overriding: a subclass replaces an inherited instance method with the same signature, resolved at runtime by the object’s class. See the full comparison in the overloading-vs-overriding article.

Not for classes: a class extends exactly one class. A class can implement any number of interfaces, and since Java 8 interfaces can carry default methods, so a class that inherits two conflicting defaults must override the method and choose (A.super.hello()). This page’s sibling article shows the exact compiler error.

IS-A is inheritance (extends/implements): the child is a kind of the parent. HAS-A is composition: one class holds a reference to another. Prefer composition unless a true substitutable subtype is intended.

A parent-typed reference calls an overridden method and the JVM runs the version belonging to the actual object, decided at runtime through dynamic dispatch.

No. Static methods are hidden, not overridden, and the version called depends on the reference type. Private methods are not inherited, so a subclass method with the same name is an unrelated method.

No. Constructors belong to their class. A subclass constructor must call a superclass constructor with super(...), explicitly or implicitly. See the constructors article.

A class declared abstract cannot be instantiated and may contain abstract methods. It can have constructors, which run when a concrete subclass is created. The Account constructor above does exactly that.

An abstract class can hold instance state and constructors and a class can extend only one. An interface defines a contract (with default, static and private methods since Java 8/9), has no instance state, and a class can implement many. See the dedicated 12-row comparison article.

Immutability is the strongest encapsulation: no code can change the value, so strings are safe as map keys, thread-safe and cacheable. See the String interview programs article for worked answers.

Final class: cannot be extended. Final method: cannot be overridden. Final variable: cannot be reassigned (the object it refers to can still change). The three-keyword comparison is in the final-vs-finally-vs-finalize article.

When the relationship is HAS-A, when you want to swap behaviour at runtime, or when subclassing would expose methods that break the parent’s invariants (for example, extending ArrayList to build a domain class). The collections interview guide shows why this matters for real JDK classes.

The four core OOP concepts in Java are encapsulation, inheritance, polymorphism and abstraction. Related ideas that interviewers also ask about are class vs object, IS-A vs HAS-A, interfaces and abstract classes.

Use one domain, such as a bank account: private balance with validated deposit and withdraw methods (encapsulation), SavingsAccount extending Account (inheritance), one loop calling monthEndInterest on different account types (polymorphism), and a Statement interface callers depend on (abstraction). All of it is in the runnable BankOop.java on this page.

Encapsulation hides data by making fields private and exposing validating methods. Abstraction hides complexity by exposing an interface or abstract class. Encapsulation protects state; abstraction simplifies use.

No. Java has primitive types (int, double, boolean and others) that are not objects, and static members that belong to classes rather than objects. Everything else you write lives inside a class.

Not with classes. A class extends one class, but it can implement multiple interfaces. Conflicting default methods must be resolved explicitly in the implementing class.