Object-Oriented Programming (OOP) Interview Questions Guide

Object-Oriented Programming (OOP) is a fundamental programming paradigm widely used in software development. If you're preparing for an interview focused on OOP concepts, this guide provides an in-depth exploration of commonly asked questions, along with explanations and examples.

Basic OOP Concepts

1. What is Object-Oriented Programming (OOP)?

OOP is a programming paradigm based on the concept of "objects," which can contain data (fields) and code (methods). It facilitates modularity, reusability, and scalability.

Key principles of OOP include:

• Encapsulation: Bundling data and methods operating on that data within a single unit (class).

• Inheritance: Mechanism to derive new classes from existing ones.

• Polymorphism: Ability to present the same interface for different data types.

• Abstraction: Hiding implementation details and showing only the functionality.

---

2. What is the difference between a class and an object?

• Class: A blueprint for creating objects. It defines properties and behaviors.

• Object: An instance of a class. It represents a specific implementation of the class blueprint.

Example in Python:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def start(self):
        print(f"{self.brand} {self.model} is starting.")

my_car = Car("Toyota", "Corolla")  # Object creation
my_car.start()  # Output: Toyota Corolla is starting.

---

3. Explain the concept of encapsulation.

Encapsulation restricts direct access to some of an object’s components, which helps prevent accidental interference and misuse.

Example in Python:

class Account:
    def __init__(self):
        self.__balance = 0  # Private variable

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

account = Account()
account.deposit(1000)
print(account.get_balance())  # Output: 1000

---

4. What is inheritance?

Inheritance allows a class (child) to acquire the properties and methods of another class (parent).

Example in Python:

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # Output: Dog barks

---

5. Define polymorphism with an example.

Polymorphism allows methods in different classes to have the same name but behave differently.

Example:

class Bird:
    def sound(self):
        print("Bird chirps")

class Cat:
    def sound(self):
        print("Cat meows")

def make_sound(animal):
    animal.sound()

bird = Bird()
cat = Cat()
make_sound(bird)  # Output: Bird chirps
make_sound(cat)   # Output: Cat meows

---

Advanced OOP Concepts

6. What is abstraction? How is it achieved?

Abstraction hides implementation details and shows only the necessary functionality. It is achieved through:

• Abstract classes

• Interfaces

Example in Python using abstract classes:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

circle = Circle(5)
print(circle.area())  # Output: 78.5

---

7. What are access modifiers? List their types.

Access modifiers define the scope of class members. Common types include:

• Public: Accessible from anywhere.

• Protected: Accessible within the class and its subclasses (denoted by a single underscore _ in Python).

• Private: Accessible only within the class (denoted by double underscores __).

---

8. What is method overloading and method overriding?

• Method Overloading: Methods with the same name but different parameters. (Not natively supported in Python but achievable using default arguments.)

• Method Overriding: Redefining a parent class method in the child class.

Example of overriding:

class Parent:
    def greet(self):
        print("Hello from Parent")

class Child(Parent):
    def greet(self):
        print("Hello from Child")

child = Child()
child.greet()  # Output: Hello from Child

---

9. Explain the concept of multiple inheritance.

Multiple inheritance allows a class to inherit from more than one base class.

Example:

class A:
    def feature_a(self):
        print("Feature A")

class B:
    def feature_b(self):
        print("Feature B")

class C(A, B):
    pass

obj = C()
obj.feature_a()  # Output: Feature A
obj.feature_b()  # Output: Feature B

---

Behavioral and Practical Questions

10. How do you handle the "diamond problem" in multiple inheritance?

The diamond problem occurs when a class inherits from two classes that have a common parent. Python’s Method Resolution Order (MRO) resolves this using the C3 linearization algorithm.

Example:

class A:
    def greet(self):
        print("Hello from A")

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

d = D()
d.greet()  # Output: Hello from A (resolved using MRO)

---

11. Can you explain the difference between an interface and an abstract class?

• Abstract Class: Can have concrete methods (with implementation).

• Interface: Typically contains only method declarations (purely abstract methods).

---

Tools and Patterns Related to OOP

12. What are design patterns?

Design patterns are reusable solutions to common software design problems. Common patterns include:

• Creational: Singleton, Factory

• Structural: Adapter, Composite

• Behavioral: Observer, Strategy

13. Explain the Singleton Design Pattern.

Singleton ensures a class has only one instance and provides a global access point to it.

Example:

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)  # Output: True

---

Conclusion

Mastering OOP concepts is essential for software developers. Understanding the nuances and being able to apply them in real-world scenarios not only helps in interviews but also in building scalable and maintainable systems.