What are the main principles of Object-Oriented Programming?

Encapsulation: Protecting State Integrity

Encapsulation is the practice of bundling data and the methods that operate on that data within a single unit, usually a class, while restricting direct access to the internal state. By marking fields as 'private', you prevent external objects from placing the object into an invalid state. This control is crucial because it allows you to change internal implementation details—like switching an underlying data structure—without breaking code that relies on your class. Instead of exposing raw fields, you provide 'getter' and 'setter' methods. These methods act as gatekeepers, allowing you to validate inputs or trigger side effects whenever data changes. This principle effectively transforms your objects into 'black boxes' where the internal complexity is hidden from the consumer, ensuring that the object is always responsible for its own valid state, which significantly reduces the surface area for bugs throughout the lifecycle of your application.

public class BankAccount {
    private double balance; // Encapsulated: direct access forbidden

    public void deposit(double amount) {
        if (amount > 0) {
            this.balance += amount; // Internal validation logic
        }
    }

    public double getBalance() {
        return balance;
    }
}

Abstraction: Hiding Implementation Complexity

Abstraction involves identifying the essential characteristics of an object while ignoring irrelevant details. In Java, this is primarily achieved through abstract classes and interfaces. When you define an interface, you are creating a contract that promises certain capabilities without dictating how those capabilities are fulfilled. This is powerful because it allows the user of your code to interact with high-level concepts rather than low-level implementation logic. By programming to an interface rather than a concrete implementation, you decouple the client from the service. If you decide to rewrite the underlying algorithm for performance, the client code remains completely unaffected. This layer of separation allows developers to work in parallel; one team builds the interface contract while another implements the logic, provided they both adhere to the documented specifications. It turns a massive, monolithic system into a series of interconnected, interchangeable modules that are vastly easier to reason about.

public interface PaymentProcessor {
    // Contract: Implementations must know how to process
    void process(double amount);
}

public class CreditCardProcessor implements PaymentProcessor {
    public void process(double amount) {
        // Low-level API logic hidden behind the contract
        System.out.println("Processing " + amount + " via Credit Card");
    }
}

Inheritance: Defining Hierarchical Relationships

Inheritance allows a class to derive properties and behaviors from a parent class, facilitating code reuse and logical grouping. You should view inheritance as an 'is-a' relationship. When you create a subclass, it automatically gains access to the protected and public members of the superclass, which prevents the duplication of shared logic. However, the true value of inheritance is not just saving keystrokes; it is the establishment of a hierarchical taxonomy. By defining a common base class, you create a shared vocabulary for your objects. This structure is essential when you have multiple specialized classes that all share core traits but require specific unique behaviors. By moving common functionality upward, you centralize maintenance; if a core requirement changes, you update it in the base class rather than auditing every individual subclass, thereby ensuring consistency across your entire data model throughout the software's growth and eventual evolution.

public class Notification {
    protected String recipient; // Inherited by subclasses
    public void send() { System.out.println("Sending to " + recipient); }
}

public class EmailNotification extends Notification {
    public EmailNotification(String recipient) { this.recipient = recipient; }
}

Polymorphism: Designing for Flexibility

Polymorphism, literally meaning 'many forms', allows objects of different classes to be treated as instances of a common superclass or interface. This is typically achieved through method overriding, where a subclass provides a specific implementation of a method already defined in its parent. Polymorphism is the key to creating extensible systems; you can write a method that accepts a base class type, and it will work perfectly with any future subclass you create without requiring a single line of change to your existing method code. This is known as the Open-Closed Principle: your code is open for extension but closed for modification. By relying on polymorphic behavior, you prevent the 'if-else' or 'switch' statement bloat that usually occurs when developers try to handle different object types manually. The JVM determines which method to execute at runtime based on the actual object instance, creating a highly dynamic and flexible architecture.

public abstract class Shape {
    public abstract double calculateArea(); // Polymorphic contract
}

public class Circle extends Shape {
    public double calculateArea() { return 3.14 * 5 * 5; }
}

public class Square extends Shape {
    public double calculateArea() { return 10 * 10; }
}

Composition: Favoring Aggregation Over Inheritance

While inheritance defines 'is-a' relationships, composition defines 'has-a' relationships, where an object contains references to other objects to perform its work. Many developers fall into the trap of using inheritance for every code reuse scenario, which often results in rigid, fragile hierarchies that are difficult to refactor. Composition is generally preferred because it offers more flexibility. You can swap out the contained object at runtime or inject different behaviors into your class through constructor arguments. By composing objects, you avoid the 'fragile base class' problem, where changes in a high-level parent accidentally break subclasses far down the chain. Composition creates loosely coupled systems where parts are highly cohesive but independent. It empowers you to build complex behaviors by assembling simple, well-tested components, making the overall system much easier to test in isolation and significantly more modular in the face of changing requirements.

public class Engine { public void start() { /* Logic */ } }

public class Car {
    private Engine engine; // Composition: Car 'has a' engine

    public Car(Engine engine) { this.engine = engine; }

    public void drive() { engine.start(); }
}

Interview questions

All java interview questions →

Check yourself

Take the full java quiz →