Object-Oriented Programming Basics

Defining Classes and Objects

A class acts as a blueprint or a template from which objects are created. It defines the structure and behavior that all instances of that class will possess. When you define a class, you are essentially creating a custom data type that bundles data fields, known as state, with methods that operate on that state, known as behavior. The reasoning behind this is to create a self-contained unit of logic that represents a specific concept. By separating the definition (the class) from the realization (the object), you can instantiate multiple independent entities that share the same characteristics but hold unique data. This separation is fundamental because it allows developers to reason about individual objects without worrying about the internal complexities of others, promoting a modular structure that makes complex software systems significantly easier to navigate and maintain over time as requirements evolve.

public class Vehicle {
    String model; // The state of the object
    
    public Vehicle(String model) {
        this.model = model; // Constructor initializes the object
    }

    public void honk() {
        System.out.println(model + " says Beep!"); // Behavior of the object
    }

    public static void main(String[] args) {
        Vehicle myCar = new Vehicle("Sedan"); // Instance creation
        myCar.honk();
    }
}

Encapsulation and Data Hiding

Encapsulation is the practice of bundling data and the methods that operate on that data within a single unit and restricting access to the internal state of the object. This is achieved through the use of access modifiers like private, protected, and public. By marking fields as private and providing public getter and setter methods, you control how the object's state is modified. This is vital because it prevents external code from putting an object into an invalid or inconsistent state. If you allow direct modification, you lose the ability to enforce validation rules. By centralizing modifications within the class, you can change the internal implementation of an object without affecting the external code that relies on it. This creates a firewall around your logic, ensuring that your class remains a robust, reliable, and predictable component of the larger application.

public class BankAccount {
    private double balance; // Hidden internal state

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

    public double getBalance() {
        return balance; // Controlled access to data
    }
}

Inheritance for Code Reusability

Inheritance is the mechanism by which one class, the subclass, acquires the properties and behaviors of another class, the superclass. This allows you to create a hierarchical relationship, capturing 'is-a' relationships effectively. The reasoning for using inheritance is primarily to eliminate redundancy. Instead of rewriting shared logic in every class, you define common functionality in a base class and let subclasses inherit it. This creates a DRY (Don't Repeat Yourself) architecture. Furthermore, it allows for polymorphism, where a subclass can be treated as an instance of its parent. However, inheritance should be used carefully; it creates a tight coupling between the parent and the child. When you use inheritance, you are making a commitment to the interface of the base class. It is best suited for scenarios where there is a clear, stable taxonomy of objects that share significant underlying structure.

class Animal {
    void eat() { System.out.println("Eating..."); }
}

class Dog extends Animal {
    // Dog inherits eat() from Animal
    void bark() { System.out.println("Barking!"); }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat(); // Inherited method
        d.bark();
    }
}

Polymorphism and Method Overriding

Polymorphism allows objects to be treated as instances of their parent class while executing their own specific implementations of shared methods. This is most clearly seen through method overriding, where a subclass provides a specific implementation for a method already defined in its superclass. The reasoning behind this is to enable flexible and extensible software. Because the caller only interacts with the superclass type, it doesn't need to know the exact concrete class of the object at runtime. This allows you to introduce new subclasses without modifying the client code, adhering to the Open/Closed Principle. Polymorphism essentially shifts the responsibility of deciding 'what to do' from the caller to the object itself. It makes systems more adaptable because you can swap or expand the variety of objects participating in an interaction without changing the surrounding logic that orchestrates that interaction.

abstract class Shape {
    abstract void draw(); // Common interface
}

class Circle extends Shape {
    void draw() { System.out.println("Drawing Circle"); }
}

class Square extends Shape {
    void draw() { System.out.println("Drawing Square"); }
}

// Usage: Shape s = new Circle(); s.draw();

Abstraction and Interfaces

Abstraction involves hiding complex implementation details and showing only the essential features of an object. In design, this is often achieved through interfaces, which define a contract that implementing classes must follow. An interface lists the methods that a class must provide without specifying how those methods should be implemented. The reasoning for this is to decouple the 'what' from the 'how'. By programming to interfaces rather than concrete implementations, you ensure that your code is not tethered to specific underlying logic, which makes it significantly easier to swap components, perform testing with mocks, or integrate third-party modules later. Abstraction provides the ultimate level of flexibility, allowing you to build systems composed of interchangeable parts that communicate through well-defined, stable contracts while keeping the inner mechanics of each part isolated and private.

interface PaymentProcessor {
    void process(double amount); // The contract
}

class CreditCardPayment implements PaymentProcessor {
    public void process(double amount) {
        // Specific implementation details
        System.out.println("Processing " + amount + " via Credit Card.");
    }
}

Interview questions

All java interview questions →

Check yourself

Take the full java quiz →