Skip to main content

Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects" that contain both data (attributes) and code (methods). It's designed to increase the flexibility and maintainability of programs.

Core Principles​

The Four Pillars​

1. Encapsulation​

Bundling data and methods that operate on that data within a single unit (class).

public class BankAccount {
    // Private data (encapsulated)
    private double balance;
    private String accountNumber;

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

    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }

    public double getBalance() {
        return balance;
    }
}

2. Inheritance​

Creating new classes from existing ones, inheriting their properties and methods.

// Base class
class Animal {
    protected String name;

    public void eat() {
        System.out.println(name + " is eating");
    }

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Derived class
class Dog extends Animal {
    public Dog(String name) {
        this.name = name;
    }

    public void bark() {
        System.out.println(name + " is barking");
    }
}

// Usage
Dog myDog = new Dog("Buddy");
myDog.eat();    // Inherited from Animal
myDog.bark();   // Dog's own method

3. Polymorphism​

The ability of objects to take many forms.

// Method Overriding (Runtime Polymorphism)
class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

// Usage
Shape shape1 = new Circle();
Shape shape2 = new Rectangle();

shape1.draw();  // "Drawing a circle"
shape2.draw();  // "Drawing a rectangle"

4. Abstraction​

Hiding implementation details and showing only essential features.

// Abstract class
abstract class Vehicle {
    protected String brand;

    // Abstract method (no implementation)
    public abstract void start();

    // Concrete method
    public void displayBrand() {
        System.out.println("Brand: " + brand);
    }
}

class Car extends Vehicle {
    public Car(String brand) {
        this.brand = brand;
    }

    @Override
    public void start() {
        System.out.println("Car engine starting...");
    }
}

Class Relationships​

Complete Example: Library System​

// Base class
class LibraryItem {
    protected String title;
    protected String id;
    protected boolean isCheckedOut;

    public LibraryItem(String title, String id) {
        this.title = title;
        this.id = id;
        this.isCheckedOut = false;
    }

    public void checkOut() {
        if (!isCheckedOut) {
            isCheckedOut = true;
            System.out.println(title + " checked out");
        }
    }

    public void returnItem() {
        isCheckedOut = false;
        System.out.println(title + " returned");
    }

    public abstract void displayInfo();
}

// Derived classes
class Book extends LibraryItem {
    private String author;
    private int pages;

    public Book(String title, String id, String author, int pages) {
        super(title, id);
        this.author = author;
        this.pages = pages;
    }

    @Override
    public void displayInfo() {
        System.out.println("Book: " + title);
        System.out.println("Author: " + author);
        System.out.println("Pages: " + pages);
    }
}

class DVD extends LibraryItem {
    private String director;
    private int duration;

    public DVD(String title, String id, String director, int duration) {
        super(title, id);
        this.director = director;
        this.duration = duration;
    }

    @Override
    public void displayInfo() {
        System.out.println("DVD: " + title);
        System.out.println("Director: " + director);
        System.out.println("Duration: " + duration + " minutes");
    }
}

// Usage
public class Library {
    public static void main(String[] args) {
        LibraryItem[] items = {
            new Book("1984", "B001", "George Orwell", 328),
            new DVD("Inception", "D001", "Christopher Nolan", 148)
        };

        for (LibraryItem item : items) {
            item.displayInfo();
            item.checkOut();
            System.out.println();
        }
    }
}

Design Patterns​

OOP enables powerful design patterns:

Advantages​

✅ Modularity​

  • Code organized into classes
  • Easy to understand structure
  • Clear responsibilities

✅ Reusability​

  • Inheritance promotes code reuse
  • Polymorphism enables flexible code
  • Composition creates building blocks

✅ Maintainability​

  • Changes localized to classes
  • Encapsulation prevents unwanted modifications
  • Clear interfaces

✅ Scalability​

  • Easy to add new features
  • Extend existing classes
  • Build on proven foundations

Disadvantages​

❌ Complexity​

  • Can be overkill for simple programs
  • Steep learning curve
  • Many concepts to master

❌ Performance Overhead​

  • Object creation cost
  • Method call overhead
  • Memory usage for objects

❌ Design Challenges​

  • Requires good upfront design
  • Can lead to over-engineering
  • Inheritance hierarchies can become complex

OOP in Different Languages​

Java​

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.println("I'm " + name + ", " + age + " years old");
    }
}

Python​

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"I'm {self.name}, {self.age} years old")

C++​

class Person {
private:
    std::string name;
    int age;

public:
    Person(std::string n, int a) : name(n), age(a) {}

    void introduce() {
        std::cout << "I'm " << name << ", " << age << " years old\n";
    }
};

Best Practices​

1. Favor Composition Over Inheritance​

// Good: Composition
class Car {
    private Engine engine;  // Has-a relationship

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

// Avoid: Deep inheritance
class Vehicle { }
class LandVehicle extends Vehicle { }
class Car extends LandVehicle { }  // Too deep

2. Program to Interfaces​

// Good
interface PaymentProcessor {
    void processPayment(double amount);
}

class CreditCardProcessor implements PaymentProcessor {
    public void processPayment(double amount) {
        // Implementation
    }
}

// Use the interface
PaymentProcessor processor = new CreditCardProcessor();

3. SOLID Principles​

  • Single Responsibility
  • Open/Closed
  • Liskov Substitution
  • Interface Segregation
  • Dependency Inversion

When to Use OOP​

✅ Perfect For:​

  • Enterprise Applications: Complex business logic
  • GUI Applications: Natural object mapping
  • Game Development: Entities as objects
  • Large Teams: Clear code organization
  • Long-term Projects: Maintainability matters

❌ Less Suitable For:​

  • Simple Scripts: Overhead not justified
  • Data Processing Pipelines: Functional might be better
  • High-Performance Computing: Overhead can matter
  • Concurrent Systems: Shared state can be problematic

Conclusion​

OOP is one of the most popular paradigms in modern software development. It provides a natural way to model real-world entities and their relationships, making it ideal for complex applications.

Master OOP to build scalable, maintainable software! 🎯