Object-Oriented Programming Refresher • luminary.blog

What is Object-Oriented Programming?

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of “objects” - data structures that contain data (attributes) and code (methods). OOP organizes software design around objects rather than functions and logic.

Key Benefits of OOP

Code Reusability: Inherit and extend existing code
Modularity: Break complex problems into smaller, manageable pieces
Maintainability: Easier to modify and extend code
Abstraction: Hide complex implementation details
Real-world modeling: Map real-world entities to code objects

Core OOP Concepts

1. Classes and Objects

Class

A class is a blueprint or template for creating objects. It defines the structure and behavior that objects will have.

1
class Car:
2
    # Class variable (shared by all instances)
3
    wheels = 4
4

5
    # Constructor method
6
    def __init__(self, make, model, year):
7
        # Instance variables (unique to each object)
8
        self.make = make
9
        self.model = model
10
        self.year = year
11
        self.is_running = False
12

13
    # Instance method
14
    def start_engine(self):
15
        self.is_running = True
16
        return f"{self.make} {self.model} engine started!"
17

18
    def stop_engine(self):
19
        self.is_running = False
20
        return f"{self.make} {self.model} engine stopped!"
21

22
    # String representation
23
    def __str__(self):
24
        return f"{self.year} {self.make} {self.model}"

Object

An object is an instance of a class - a concrete realization of the class blueprint.

1
# Creating objects (instances)
2
car1 = Car("Toyota", "Camry", 2023)
3
car2 = Car("Honda", "Civic", 2022)
4

5
# Accessing attributes
6
print(car1.make)        # Toyota
7
print(car1.wheels)      # 4 (class variable)
8

9
# Calling methods
10
print(car1.start_engine())  # Toyota Camry engine started!
11
print(car1)                 # 2023 Toyota Camry

Java Example

1
public class Car {
2
    // Class variable
3
    public static final int WHEELS = 4;
4

5
    // Instance variables
6
    private String make;
7
    private String model;
8
    private int year;
9
    private boolean isRunning;
10

11
    // Constructor
12
    public Car(String make, String model, int year) {
13
        this.make = make;
14
        this.model = model;
15
        this.year = year;
16
        this.isRunning = false;
17
    }
18

19
    // Methods
20
    public String startEngine() {
21
        this.isRunning = true;
22
        return this.make + " " + this.model + " engine started!";
23
    }
24

25
    public String getMake() {
26
        return this.make;
27
    }
28

29
    @Override
30
    public String toString() {
31
        return this.year + " " + this.make + " " + this.model;
32
    }
33
}

The Four Pillars of OOP

1. Encapsulation

Encapsulation is the bundling of data and methods that operate on that data within a single unit (class), and restricting access to internal implementation details.

Python Example

1
class BankAccount:
2
    def __init__(self, account_number, initial_balance=0):
3
        self.account_number = account_number
4
        self.__balance = initial_balance  # Private attribute (name mangling)
5
        self._transaction_history = []    # Protected attribute (convention)
6

7
    # Public method to access private data
8
    def get_balance(self):
9
        return self.__balance
10

11
    # Public method to modify private data
12
    def deposit(self, amount):
13
        if amount > 0:
14
            self.__balance += amount
15
            self._add_transaction(f"Deposited ${amount}")
16
            return True
17
        return False
18

19
    def withdraw(self, amount):
20
        if 0 < amount <= self.__balance:
21
            self.__balance -= amount
22
            self._add_transaction(f"Withdrew ${amount}")
23
            return True
24
        return False
25

26
    # Private method (internal implementation)
27
    def _add_transaction(self, description):
28
        from datetime import datetime
29
        self._transaction_history.append({
30
            'date': datetime.now(),
31
            'description': description,
32
            'balance': self.__balance
33
        })
34

35
    # Property decorator for controlled access
36
    @property
37
    def balance(self):
38
        return self.__balance
39

40
    @balance.setter
41
    def balance(self, value):
42
        if value >= 0:
43
            self.__balance = value
44

45
# Usage
46
account = BankAccount("123456", 1000)
47
print(account.get_balance())    # 1000
48
account.deposit(500)
49
print(account.balance)          # 1500 (using property)
50

51
# This won't work - private attribute
52
# print(account.__balance)      # AttributeError

Java Example

1
public class BankAccount {
2
    private String accountNumber;
3
    private double balance;
4
    private List<String> transactionHistory;
5

6
    public BankAccount(String accountNumber, double initialBalance) {
7
        this.accountNumber = accountNumber;
8
        this.balance = initialBalance;
9
        this.transactionHistory = new ArrayList<>();
10
    }
11

12
    // Getter (accessor)
13
    public double getBalance() {
14
        return this.balance;
15
    }
16

17
    // Setter (mutator) with validation
18
    public void setBalance(double balance) {
19
        if (balance >= 0) {
20
            this.balance = balance;
21
        }
22
    }
23

24
    public boolean deposit(double amount) {
25
        if (amount > 0) {
26
            this.balance += amount;
27
            addTransaction("Deposited $" + amount);
28
            return true;
29
        }
30
        return false;
31
    }
32

33
    private void addTransaction(String description) {
34
        this.transactionHistory.add(description);
35
    }
36
}

Benefits of Encapsulation:

Data Protection: Prevent unauthorized access to internal data
Validation: Control how data is modified
Flexibility: Change internal implementation without affecting external code
Debugging: Easier to track data changes

2. Inheritance

Inheritance allows a class (child/derived) to inherit properties and methods from another class (parent/base), promoting code reuse and establishing hierarchical relationships.

Python Example

1
# Base class (Parent)
2
class Animal:
3
    def __init__(self, name, species):
4
        self.name = name
5
        self.species = species
6
        self.is_alive = True
7

8
    def eat(self, food):
9
        return f"{self.name} is eating {food}"
10

11
    def sleep(self):
12
        return f"{self.name} is sleeping"
13

14
    def make_sound(self):
15
        return "Some generic animal sound"
16

17
# Derived class (Child)
18
class Dog(Animal):
19
    def __init__(self, name, breed):
20
        super().__init__(name, "Canine")  # Call parent constructor
21
        self.breed = breed
22

23
    # Method overriding
24
    def make_sound(self):
25
        return f"{self.name} says Woof!"
26

27
    # Additional method specific to Dog
28
    def fetch(self, item):
29
        return f"{self.name} fetched the {item}!"
30

31
class Cat(Animal):
32
    def __init__(self, name, breed):
33
        super().__init__(name, "Feline")
34
        self.breed = breed
35

36
    def make_sound(self):
37
        return f"{self.name} says Meow!"
38

39
    def climb(self):
40
        return f"{self.name} climbed up the tree!"
41

42
# Usage
43
dog = Dog("Buddy", "Golden Retriever")
44
cat = Cat("Whiskers", "Persian")
45

46
print(dog.eat("dog food"))      # Inherited method
47
print(dog.make_sound())         # Overridden method
48
print(dog.fetch("ball"))        # Dog-specific method
49

50
print(cat.make_sound())         # Overridden method
51
print(cat.climb())              # Cat-specific method

Multiple Inheritance Example

1
class Flyable:
2
    def fly(self):
3
        return "Flying through the air!"
4

5
class Swimmable:
6
    def swim(self):
7
        return "Swimming in water!"
8

9
class Duck(Animal, Flyable, Swimmable):
10
    def __init__(self, name):
11
        super().__init__(name, "Bird")
12

13
    def make_sound(self):
14
        return f"{self.name} says Quack!"
15

16
# Usage
17
duck = Duck("Donald")
18
print(duck.fly())       # From Flyable
19
print(duck.swim())      # From Swimmable
20
print(duck.eat("bread")) # From Animal

Java Example (Single Inheritance)

1
// Base class
2
public class Animal {
3
    protected String name;
4
    protected String species;
5
    protected boolean isAlive;
6

7
    public Animal(String name, String species) {
8
        this.name = name;
9
        this.species = species;
10
        this.isAlive = true;
11
    }
12

13
    public String eat(String food) {
14
        return this.name + " is eating " + food;
15
    }
16

17
    public String makeSound() {
18
        return "Some generic animal sound";
19
    }
20
}
21

22
// Derived class
23
public class Dog extends Animal {
24
    private String breed;
25

26
    public Dog(String name, String breed) {
27
        super(name, "Canine");  // Call parent constructor
28
        this.breed = breed;
29
    }
30

31
    @Override
32
    public String makeSound() {
33
        return this.name + " says Woof!";
34
    }
35

36
    public String fetch(String item) {
37
        return this.name + " fetched the " + item + "!";
38
    }
39
}

Types of Inheritance:

Single Inheritance: One parent class
Multiple Inheritance: Multiple parent classes (Python supports, Java doesn’t)
Multilevel Inheritance: Child class becomes parent to another class
Hierarchical Inheritance: Multiple child classes from one parent

3. Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common base class, while still maintaining their own specific behavior.

Runtime Polymorphism (Method Overriding)

1
class Shape:
2
    def area(self):
3
        raise NotImplementedError("Subclass must implement area()")
4

5
    def perimeter(self):
6
        raise NotImplementedError("Subclass must implement perimeter()")
7

8
class Rectangle(Shape):
9
    def __init__(self, width, height):
10
        self.width = width
11
        self.height = height
12

13
    def area(self):
14
        return self.width * self.height
15

16
    def perimeter(self):
17
        return 2 * (self.width + self.height)
18

19
class Circle(Shape):
20
    def __init__(self, radius):
21
        self.radius = radius
22

23
    def area(self):
24
        return 3.14159 * self.radius ** 2
25

26
    def perimeter(self):
27
        return 2 * 3.14159 * self.radius
28

29
class Triangle(Shape):
30
    def __init__(self, base, height, side1, side2):
31
        self.base = base
32
        self.height = height
33
        self.side1 = side1
34
        self.side2 = side2
35

36
    def area(self):
37
        return 0.5 * self.base * self.height
38

39
    def perimeter(self):
40
        return self.base + self.side1 + self.side2
41

42
# Polymorphic function
43
def print_shape_info(shape):
44
    print(f"Shape: {type(shape).__name__}")
45
    print(f"Area: {shape.area()}")
46
    print(f"Perimeter: {shape.perimeter()}")
47
    print("-" * 20)
48

49
# Usage - same function works with different object types
50
shapes = [
51
    Rectangle(5, 3),
52
    Circle(4),
53
    Triangle(6, 4, 5, 5)
54
]
55

56
for shape in shapes:
57
    print_shape_info(shape)  # Polymorphic behavior

Compile-time Polymorphism (Method Overloading)

1
class Calculator:
2
    def add(self, a, b=None, c=None):
3
        """Method overloading simulation using default parameters"""
4
        if c is not None:
5
            return a + b + c
6
        elif b is not None:
7
            return a + b
8
        else:
9
            return a
10

11
    # Using multiple dispatch (requires functools.singledispatch)
12
    from functools import singledispatch
13

14
    @singledispatch
15
    @staticmethod
16
    def multiply(x):
17
        raise NotImplementedError("Unsupported type")
18

19
    @multiply.register
20
    @staticmethod
21
    def _(x: int, y: int):
22
        return x * y
23

24
    @multiply.register
25
    @staticmethod
26
    def _(x: float, y: float):
27
        return x * y
28

29
    @multiply.register
30
    @staticmethod
31
    def _(x: str, y: int):
32
        return x * y
33

34
# Usage
35
calc = Calculator()
36
print(calc.add(1, 2))      # 3
37
print(calc.add(1, 2, 3))   # 6

Java Polymorphism Example

1
// Base class
2
abstract class Shape {
3
    public abstract double area();
4
    public abstract double perimeter();
5
}
6

7
class Rectangle extends Shape {
8
    private double width, height;
9

10
    public Rectangle(double width, double height) {
11
        this.width = width;
12
        this.height = height;
13
    }
14

15
    @Override
16
    public double area() {
17
        return width * height;
18
    }
19

20
    @Override
21
    public double perimeter() {
22
        return 2 * (width + height);
23
    }
24
}
25

26
class Circle extends Shape {
27
    private double radius;
28

29
    public Circle(double radius) {
30
        this.radius = radius;
31
    }
32

33
    @Override
34
    public double area() {
35
        return Math.PI * radius * radius;
36
    }
37

38
    @Override
39
    public double perimeter() {
40
        return 2 * Math.PI * radius;
41
    }
42
}
43

44
// Polymorphic usage
45
public class ShapeDemo {
46
    public static void printShapeInfo(Shape shape) {
47
        System.out.println("Area: " + shape.area());
48
        System.out.println("Perimeter: " + shape.perimeter());
49
    }
50

51
    public static void main(String[] args) {
52
        Shape[] shapes = {
53
            new Rectangle(5, 3),
54
            new Circle(4)
55
        };
56

57
        for (Shape shape : shapes) {
58
            printShapeInfo(shape);  // Polymorphic behavior
59
        }
60
    }
61
}

4. Abstraction

Abstraction hides complex implementation details and shows only the essential features of an object. It focuses on what an object does rather than how it does it.

Abstract Base Classes

1
from abc import ABC, abstractmethod
2

3
class Vehicle(ABC):
4
    def __init__(self, make, model):
5
        self.make = make
6
        self.model = model
7

8
    @abstractmethod
9
    def start_engine(self):
10
        pass
11

12
    @abstractmethod
13
    def stop_engine(self):
14
        pass
15

16
    @abstractmethod
17
    def get_fuel_efficiency(self):
18
        pass
19

20
    # Concrete method (shared implementation)
21
    def get_info(self):
22
        return f"{self.make} {self.model}"
23

24
class Car(Vehicle):
25
    def __init__(self, make, model, fuel_type):
26
        super().__init__(make, model)
27
        self.fuel_type = fuel_type
28
        self.engine_running = False
29

30
    def start_engine(self):
31
        self.engine_running = True
32
        return f"{self.get_info()} engine started"
33

34
    def stop_engine(self):
35
        self.engine_running = False
36
        return f"{self.get_info()} engine stopped"
37

38
    def get_fuel_efficiency(self):
39
        return "25 MPG"  # Simplified
40

41
class ElectricCar(Vehicle):
42
    def __init__(self, make, model, battery_capacity):
43
        super().__init__(make, model)
44
        self.battery_capacity = battery_capacity
45
        self.motor_running = False
46

47
    def start_engine(self):
48
        self.motor_running = True
49
        return f"{self.get_info()} motor started silently"
50

51
    def stop_engine(self):
52
        self.motor_running = False
53
        return f"{self.get_info()} motor stopped"
54

55
    def get_fuel_efficiency(self):
56
        return "100 MPGe"  # Miles per gallon equivalent
57

58
# Usage
59
vehicles = [
60
    Car("Toyota", "Camry", "Gasoline"),
61
    ElectricCar("Tesla", "Model 3", "75 kWh")
62
]
63

64
for vehicle in vehicles:
65
    print(vehicle.start_engine())
66
    print(f"Efficiency: {vehicle.get_fuel_efficiency()}")
67
    print(vehicle.stop_engine())
68
    print("-" * 30)

Interface-like Abstraction

1
class Drawable:
2
    """Interface-like class defining drawing contract"""
3

4
    def draw(self):
5
        raise NotImplementedError("Must implement draw()")
6

7
    def resize(self, factor):
8
        raise NotImplementedError("Must implement resize()")
9

10
class Circle(Drawable):
11
    def __init__(self, radius):
12
        self.radius = radius
13

14
    def draw(self):
15
        return f"Drawing circle with radius {self.radius}"
16

17
    def resize(self, factor):
18
        self.radius *= factor
19
        return f"Circle resized, new radius: {self.radius}"
20

21
class Square(Drawable):
22
    def __init__(self, side):
23
        self.side = side
24

25
    def draw(self):
26
        return f"Drawing square with side {self.side}"
27

28
    def resize(self, factor):
29
        self.side *= factor
30
        return f"Square resized, new side: {self.side}"
31

32
def render_shapes(shapes):
33
    """Function that works with any Drawable object"""
34
    for shape in shapes:
35
        print(shape.draw())
36
        print(shape.resize(1.5))

Java Interface Example

1
// Interface
2
interface Drawable {
3
    void draw();
4
    void resize(double factor);
5
}
6

7
// Implementation
8
class Circle implements Drawable {
9
    private double radius;
10

11
    public Circle(double radius) {
12
        this.radius = radius;
13
    }
14

15
    @Override
16
    public void draw() {
17
        System.out.println("Drawing circle with radius " + radius);
18
    }
19

20
    @Override
21
    public void resize(double factor) {
22
        this.radius *= factor;
23
        System.out.println("Circle resized, new radius: " + radius);
24
    }
25
}

Advanced OOP Concepts

Composition vs Inheritance

Composition (“Has-a” relationship)

1
class Engine:
2
    def __init__(self, horsepower, fuel_type):
3
        self.horsepower = horsepower
4
        self.fuel_type = fuel_type
5
        self.running = False
6

7
    def start(self):
8
        self.running = True
9
        return f"{self.horsepower}HP {self.fuel_type} engine started"
10

11
    def stop(self):
12
        self.running = False
13
        return f"Engine stopped"
14

15
class Transmission:
16
    def __init__(self, type_name, gears):
17
        self.type = type_name
18
        self.gears = gears
19
        self.current_gear = 1
20

21
    def shift_up(self):
22
        if self.current_gear < self.gears:
23
            self.current_gear += 1
24
        return f"Shifted to gear {self.current_gear}"
25

26
class Car:
27
    def __init__(self, make, model, engine, transmission):
28
        self.make = make
29
        self.model = model
30
        self.engine = engine          # Composition
31
        self.transmission = transmission  # Composition
32

33
    def start(self):
34
        return self.engine.start()
35

36
    def accelerate(self):
37
        if self.engine.running:
38
            return self.transmission.shift_up()
39
        return "Start the engine first!"
40

41
# Usage
42
engine = Engine(200, "Gasoline")
43
transmission = Transmission("Manual", 6)
44
car = Car("Honda", "Civic", engine, transmission)
45

46
print(car.start())      # Delegates to engine
47
print(car.accelerate()) # Uses transmission

When to use Composition vs Inheritance:

Inheritance: “Is-a” relationship (Dog IS-A Animal)
Composition: “Has-a” relationship (Car HAS-A Engine)
Prefer composition for flexibility and loose coupling

Design Patterns in OOP

1. Singleton Pattern

1
class DatabaseConnection:
2
    _instance = None
3
    _connection = None
4

5
    def __new__(cls):
6
        if cls._instance is None:
7
            cls._instance = super().__new__(cls)
8
        return cls._instance
9

10
    def __init__(self):
11
        if self._connection is None:
12
            self._connection = self._create_connection()
13

14
    def _create_connection(self):
15
        # Simulate database connection
16
        return "Connected to database"
17

18
    def get_connection(self):
19
        return self._connection
20

21
# Usage
22
db1 = DatabaseConnection()
23
db2 = DatabaseConnection()
24
print(db1 is db2)  # True - same instance

2. Factory Pattern

1
class AnimalFactory:
2
    @staticmethod
3
    def create_animal(animal_type, name):
4
        if animal_type.lower() == "dog":
5
            return Dog(name, "Mixed")
6
        elif animal_type.lower() == "cat":
7
            return Cat(name, "Mixed")
8
        elif animal_type.lower() == "duck":
9
            return Duck(name)
10
        else:
11
            raise ValueError(f"Unknown animal type: {animal_type}")
12

13
# Usage
14
animals = [
15
    AnimalFactory.create_animal("dog", "Buddy"),
16
    AnimalFactory.create_animal("cat", "Whiskers"),
17
    AnimalFactory.create_animal("duck", "Donald")
18
]
19

20
for animal in animals:
21
    print(animal.make_sound())

3. Observer Pattern

1
class Subject:
2
    def __init__(self):
3
        self._observers = []
4
        self._state = None
5

6
    def attach(self, observer):
7
        self._observers.append(observer)
8

9
    def detach(self, observer):
10
        self._observers.remove(observer)
11

12
    def notify(self):
13
        for observer in self._observers:
14
            observer.update(self)
15

16
    def set_state(self, state):
17
        self._state = state
18
        self.notify()
19

20
    def get_state(self):
21
        return self._state
22

23
class Observer:
24
    def update(self, subject):
25
        raise NotImplementedError
26

27
class EmailNotifier(Observer):
28
    def update(self, subject):
29
        print(f"Email sent: State changed to {subject.get_state()}")
30

31
class SMSNotifier(Observer):
32
    def update(self, subject):
33
        print(f"SMS sent: State changed to {subject.get_state()}")
34

35
# Usage
36
subject = Subject()
37
email_notifier = EmailNotifier()
38
sms_notifier = SMSNotifier()
39

40
subject.attach(email_notifier)
41
subject.attach(sms_notifier)
42

43
subject.set_state("Order Shipped")  # Both notifiers will be updated

4. Strategy Pattern

1
class PaymentStrategy:
2
    def pay(self, amount):
3
        raise NotImplementedError
4

5
class CreditCardPayment(PaymentStrategy):
6
    def __init__(self, card_number):
7
        self.card_number = card_number
8

9
    def pay(self, amount):
10
        return f"Paid ${amount} using Credit Card ending in {self.card_number[-4:]}"
11

12
class PayPalPayment(PaymentStrategy):
13
    def __init__(self, email):
14
        self.email = email
15

16
    def pay(self, amount):
17
        return f"Paid ${amount} using PayPal account {self.email}"
18

19
class BitcoinPayment(PaymentStrategy):
20
    def __init__(self, wallet_address):
21
        self.wallet_address = wallet_address
22

23
    def pay(self, amount):
24
        return f"Paid ${amount} using Bitcoin wallet {self.wallet_address[:8]}..."
25

26
class ShoppingCart:
27
    def __init__(self):
28
        self.items = []
29
        self.payment_strategy = None
30

31
    def add_item(self, item, price):
32
        self.items.append((item, price))
33

34
    def set_payment_strategy(self, strategy):
35
        self.payment_strategy = strategy
36

37
    def checkout(self):
38
        total = sum(price for item, price in self.items)
39
        if self.payment_strategy:
40
            return self.payment_strategy.pay(total)
41
        return "No payment method selected"
42

43
# Usage
44
cart = ShoppingCart()
45
cart.add_item("Laptop", 999.99)
46
cart.add_item("Mouse", 29.99)
47

48
# Use different payment strategies
49
cart.set_payment_strategy(CreditCardPayment("1234567890123456"))
50
print(cart.checkout())
51

52
cart.set_payment_strategy(PayPalPayment("user@example.com"))
53
print(cart.checkout())

Class Relationships

1. Association

Objects are related but independent.

1
class Student:
2
    def __init__(self, name):
3
        self.name = name
4
        self.courses = []
5

6
    def enroll(self, course):
7
        self.courses.append(course)
8
        course.add_student(self)
9

10
class Course:
11
    def __init__(self, name):
12
        self.name = name
13
        self.students = []
14

15
    def add_student(self, student):
16
        self.students.append(student)

2. Aggregation

“Has-a” relationship where child can exist without parent.

1
class Department:
2
    def __init__(self, name):
3
        self.name = name
4
        self.employees = []
5

6
    def add_employee(self, employee):
7
        self.employees.append(employee)
8

9
class Employee:
10
    def __init__(self, name):
11
        self.name = name
12
    # Employee can exist without Department

3. Composition

“Has-a” relationship where child cannot exist without parent.

1
class House:
2
    def __init__(self):
3
        self.rooms = [Room("Living Room"), Room("Bedroom")]
4

5
    def __del__(self):
6
        # When house is destroyed, rooms are destroyed too
7
        del self.rooms
8

9
class Room:
10
    def __init__(self, name):
11
        self.name = name
12
    # Room cannot exist without House

SOLID Principles

For more more details and TypeScript examples, check SOLID Principles with Examples article.

1. Single Responsibility Principle (SRP)

A class should have only one reason to change.

1
# Bad: Multiple responsibilities
2
class User:
3
    def __init__(self, name, email):
4
        self.name = name
5
        self.email = email
6

7
    def save_to_database(self):
8
        # Database logic
9
        pass
10

11
    def send_email(self):
12
        # Email logic
13
        pass
14

15
# Good: Single responsibility
16
class User:
17
    def __init__(self, name, email):
18
        self.name = name
19
        self.email = email
20

21
class UserRepository:
22
    def save(self, user):
23
        # Database logic
24
        pass
25

26
class EmailService:
27
    def send_email(self, user, message):
28
        # Email logic
29
        pass

2. Open/Closed Principle (OCP)

Classes should be open for extension but closed for modification.

1
class AreaCalculator:
2
    def calculate(self, shapes):
3
        total_area = 0
4
        for shape in shapes:
5
            total_area += shape.area()  # Extensible without modification
6
        return total_area
7

8
# Adding new shapes doesn't require modifying AreaCalculator
9
class Pentagon(Shape):
10
    def __init__(self, side):
11
        self.side = side
12

13
    def area(self):
14
        return 1.72 * self.side ** 2

3. Liskov Substitution Principle (LSP)

Objects of a superclass should be replaceable with objects of its subclasses.

1
class Bird:
2
    def fly(self):
3
        return "Flying"
4

5
class Sparrow(Bird):
6
    def fly(self):
7
        return "Sparrow flying"
8

9
class Penguin(Bird):
10
    def fly(self):
11
        raise Exception("Penguins can't fly")  # Violates LSP
12

13
# Better design
14
class Bird:
15
    def move(self):
16
        raise NotImplementedError
17

18
class FlyingBird(Bird):
19
    def fly(self):
20
        return "Flying"
21

22
    def move(self):
23
        return self.fly()
24

25
class Penguin(Bird):
26
    def swim(self):
27
        return "Swimming"
28

29
    def move(self):
30
        return self.swim()

4. Interface Segregation Principle (ISP)

Clients should not be forced to depend on interfaces they don’t use.

1
# Bad: Fat interface
2
class Worker:
3
    def work(self):
4
        pass
5

6
    def eat(self):
7
        pass
8

9
class Robot(Worker):
10
    def work(self):
11
        return "Robot working"
12

13
    def eat(self):
14
        pass  # Robots don't eat - violates ISP
15

16
# Good: Segregated interfaces
17
class Workable:
18
    def work(self):
19
        pass
20

21
class Eatable:
22
    def eat(self):
23
        pass
24

25
class Human(Workable, Eatable):
26
    def work(self):
27
        return "Human working"
28

29
    def eat(self):
30
        return "Human eating"
31

32
class Robot(Workable):
33
    def work(self):
34
        return "Robot working"

5. Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules. Both should depend on abstractions.

1
# Bad: High-level depends on low-level
2
class EmailService:
3
    def send(self, message):
4
        # Send email
5
        pass
6

7
class NotificationManager:
8
    def __init__(self):
9
        self.email_service = EmailService()  # Tight coupling
10

11
    def send_notification(self, message):
12
        self.email_service.send(message)
13

14
# Good: Both depend on abstraction
15
class NotificationService:
16
    def send(self, message):
17
        raise NotImplementedError
18

19
class EmailService(NotificationService):
20
    def send(self, message):
21
        return f"Email sent: {message}"
22

23
class SMSService(NotificationService):
24
    def send(self, message):
25
        return f"SMS sent: {message}"
26

27
class NotificationManager:
28
    def __init__(self, notification_service):
29
        self.notification_service = notification_service  # Dependency injection
30

31
    def send_notification(self, message):
32
        return self.notification_service.send(message)
33

34
# Usage
35
email_manager = NotificationManager(EmailService())
36
sms_manager = NotificationManager(SMSService())

OOP Interview Questions and Answers

Q1: What is the difference between a class and an object?

A1: A class is a blueprint or template that defines the structure and behavior of objects, including attributes and methods. An object is a concrete instance of a class - an actual realization created from the class blueprint with specific values. For example, Car is a class, while my_car = Car("Toyota", "Camry", 2023) creates an object instance.

Q2: Explain the four pillars of OOP.

A2: The four pillars are:

Encapsulation: Bundling data and methods together while hiding internal implementation details
Inheritance: Allowing a class to inherit properties and methods from another class for code reuse
Polymorphism: Enabling objects of different classes to be treated uniformly while maintaining their specific behaviors
Abstraction: Hiding complex implementation details and exposing only essential features

Q3: What is the difference between method overloading and method overriding?

A3: Method overloading (compile-time polymorphism) is having multiple methods with the same name but different parameters in the same class. Method overriding (runtime polymorphism) is when a subclass provides a specific implementation for a method already defined in its parent class. Overloading happens within one class; overriding happens across inheritance hierarchy.

Q4: When should you use composition over inheritance?

A4: Use composition when you have a “has-a” relationship rather than an “is-a” relationship. Composition provides better flexibility, loose coupling, and easier testing. For example, a Car “has-a” Engine (composition) rather than a Car “is-a” Engine (inheritance). Prefer composition when you need to change behavior at runtime or avoid tight coupling between classes.

Q5: What is an abstract class and when would you use it?

A5: An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without implementation). It serves as a base class that defines a contract for subclasses. Use abstract classes when you want to provide common functionality to related classes while forcing them to implement specific methods. For example, a Vehicle abstract class can define common attributes while forcing Car and Motorcycle subclasses to implement their own start_engine() method.

Q6: Explain the Single Responsibility Principle.

A6: The Single Responsibility Principle states that a class should have only one reason to change - it should have only one job or responsibility. For example, a User class should only handle user data, not database operations or email sending. Separate concerns into different classes like UserRepository for database operations and EmailService for sending emails. This makes code more maintainable and testable.

Q7: What is the difference between private, protected, and public access modifiers?

A7:

Public: Accessible from anywhere (all classes)
Protected: Accessible within the class and its subclasses
Private: Accessible only within the class itself

In Python, these are conventions: _protected (single underscore) and __private (double underscore with name mangling). In Java, they are enforced keywords.

Q8: What is a design pattern? Name three common ones.

A8: A design pattern is a reusable solution to a commonly occurring problem in software design. Three common patterns are:

Singleton: Ensures only one instance of a class exists
Factory: Creates objects without specifying exact class to create
Observer: Allows objects to notify other objects about state changes

Q9: Explain polymorphism with a real-world example.

A9: Polymorphism allows objects of different types to be treated uniformly. Real-world example: A payment system that accepts different payment methods (CreditCard, PayPal, Bitcoin). All implement a pay() method, but each executes it differently. The checkout system can call payment_method.pay(amount) without knowing the specific payment type - the correct implementation is called automatically based on the object type.

Q10: What is the Liskov Substitution Principle?

A10: The Liskov Substitution Principle states that objects of a superclass should be replaceable with objects of its subclasses without breaking the application. Subclasses must honor the contract of the parent class. For example, if you have a Bird class with a fly() method, creating a Penguin subclass that throws an error in fly() violates LSP because penguins can’t fly. Better design: separate FlyingBird and FlightlessBird classes.

Q11: What is the difference between aggregation and composition?

A11: Both represent “has-a” relationships, but differ in ownership:

Aggregation: Child can exist independently of parent (e.g., Department has Employees; employees can exist without the department)
Composition: Child cannot exist without parent (e.g., House has Rooms; rooms don’t exist without the house)

Composition implies stronger ownership and lifecycle dependency.

Q12: Explain the Open/Closed Principle with an example.

A12: The Open/Closed Principle states that classes should be open for extension but closed for modification. Example: An AreaCalculator class that calculates total area of shapes should not need modification when adding new shape types. Instead, new shapes inherit from a Shape base class and implement their own area() method. The calculator works with any shape without code changes.

Q13: What is multiple inheritance and what problems can it cause?

A13: Multiple inheritance allows a class to inherit from multiple parent classes. It can cause the “diamond problem” - when two parent classes have a method with the same name, which one should the child inherit? Python supports multiple inheritance and uses Method Resolution Order (MRO) to resolve conflicts. Java avoids this by not supporting multiple inheritance for classes (but allows multiple interface implementation).

Q14: What is dependency injection and why is it useful?

A14: Dependency injection is passing dependencies to a class from outside rather than creating them internally. Instead of class A { b = new B() }, use class A { constructor(b) { this.b = b } }. Benefits include:

Loose coupling between classes
Easier testing (can inject mock objects)
Better flexibility (can swap implementations)
Follows Dependency Inversion Principle

Q15: Explain the difference between static and instance methods.

A15:

Instance methods: Operate on instance data, require an object to be called, access instance variables via self (Python) or this (Java)
Static methods: Belong to the class itself, don’t require an instance, can’t access instance variables, used for utility functions related to the class

Example: Car.get_wheel_count() (static) vs my_car.start_engine() (instance).

Q16: What is the Interface Segregation Principle?

A16: The Interface Segregation Principle states that clients should not be forced to depend on interfaces they don’t use. Instead of one large interface, create multiple smaller, specific interfaces. Example: Don’t create a Worker interface with work() and eat() methods that forces Robot class to implement eat(). Instead, create separate Workable and Eatable interfaces.

Q17: What is the difference between association and dependency?

A17:

Association: A structural relationship where objects are connected and can exist independently (e.g., Student and Course - both can exist independently but are related)
Dependency: A weaker relationship where one class temporarily uses another (e.g., a method parameter or local variable)

Association is “knows-a” or “has-a”, dependency is “uses-a” temporarily.

Q18: Explain the Strategy Pattern and when to use it.

A18: The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Use it when you have multiple ways of performing an operation and want to switch between them at runtime. Example: A ShoppingCart that can accept different payment strategies (CreditCard, PayPal, Bitcoin) without changing cart logic. The payment method can be set dynamically: cart.set_payment_strategy(PayPalPayment()).

Q19: What is tight coupling vs loose coupling?

A19:

Tight coupling: Classes are highly dependent on each other; changes in one class require changes in another
Loose coupling: Classes have minimal dependencies; changes in one class don’t affect others

Loose coupling is achieved through interfaces, dependency injection, and abstraction. Example: Instead of class A { b = new ConcreteB() } (tight), use class A { constructor(interface_b) } (loose).

Q20: What is the difference between an abstract class and an interface?

A20: Abstract Class:

Can have both abstract and concrete methods
Can have instance variables and constructors
Supports single inheritance (in most languages)
Use for “is-a” relationships with shared implementation

Interface:

Only method signatures (traditionally; modern languages allow default methods)
No instance variables (only constants)
Supports multiple implementation
Use for “can-do” capabilities and contracts

Example: Animal (abstract class with shared code) vs Flyable (interface defining flying capability).

← RAG vs MCP: Complementary AI Approaches

Containers and Orchestration Refersher →