OOP Concepts Interview Questions and Answers

Object-oriented programming rests on four pillars:

• Encapsulation: keep state private and expose behaviour through methods, so invariants cannot be broken from outside.
• Abstraction: model only the essential behaviour, hiding implementation detail behind an interface or abstract type.
• Inheritance: derive a specialised type from a base type to reuse and extend behaviour.
• Polymorphism: call the same method on different types and let the runtime pick the right implementation.

interface Shape { double area(); }
class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    public double area() { return Math.PI * r * r; }
}

Here Circle encapsulates r, implements the abstraction Shape and participates in polymorphism. In practice inheritance is the least important and most abused pillar; composition and interfaces usually age better. The SOLID principles refine these ideas to keep designs maintainable as systems grow.

An interface declares a contract: a set of method signatures with no state that any type can implement. A class can implement many interfaces, which models capability. An abstract class is a partially implemented base class that can hold fields, constructors and concrete methods; a class can extend only one.

interface Flyer { void fly(); }
abstract class Bird {
    protected String name;
    Bird(String name) { this.name = name; }
    abstract void sing();
    void sleep() { System.out.println("sleeping"); }
}

Use an interface when unrelated types must share a capability and when you want multiple inheritance of type. Use an abstract class when related types share code and state, and you want to force subclasses to fill in specific steps. Many designs use both: an abstract class implements a primary interface and provides default behaviour, while callers depend only on the interface. Prefer interfaces at module boundaries and abstract classes internally.

Encapsulation means bundling data with the operations that act on it and restricting direct access to the internals. The class exposes a deliberate public API and keeps fields private, so it can enforce invariants rather than trusting every caller.

class BankAccount {
    private long balance;
    public BankAccount(long initial) {
        if (initial < 0) throw new IllegalArgumentException();
        this.balance = initial;
    }
    public void deposit(long amount) {
        if (amount <= 0) throw new IllegalArgumentException();
        balance += amount;
    }
    public long getBalance() { return balance; }
}

Because balance is private, code cannot set it to a negative value or bypass validation. Encapsulation reduces coupling: you can change the internal representation, add caching or logging, or swap a field for a computed value without breaking callers. It is not the same as adding getters and setters to every field, which leaks implementation just as badly as public fields when the accessors are unthinking.