1. What is the need for OOP?

As software projects grew larger and more complex, procedural programming became increasingly difficult to manage. It didn't model real-world entities effectively and often led to significant code duplication.

OOP was introduced to address these challenges by organizing programs around objects that bundle both data and behavior together. This approach makes code easier to maintain, reuse, and extend, helping developers manage complexity more effectively.

2. What are some major Object-Oriented Programming languages?

The most widely used OOP languages include Java, C++, Python, C#, Ruby, Kotlin, Swift, and JavaScript. Each supports core OOP principles like classes, inheritance, and polymorphism, though their implementation details and syntax vary.

3. What are some other programming paradigms besides OOP?

Apart from OOP, several other paradigms exist:

• Procedural programming (like C) — focuses on functions and procedures
• Functional programming (like Haskell, Scala) — emphasizes immutability and pure functions
• Logic programming (like Prolog) — uses rules and facts for reasoning
• Event-driven programming — used in GUIs and web development where code executes in response to specific events

4. What are the main features of OOP?

The four pillars of OOP are:

• Encapsulation — bundling data and methods into one unit while controlling access
• Abstraction — hiding unnecessary implementation details from users
• Inheritance — enabling one class to derive properties and methods from another
• Polymorphism — allowing methods to behave differently based on context or object type

5. Explain the difference between a class and an object

A class is a blueprint or template that defines the structure and behavior of objects. It specifies what attributes and methods objects of that type will have.

An object is an instance of a class — it contains actual data and can perform the actions defined in the class.

Example:

class Car {
  String color;
  void start() { 
    System.out.println("Car started"); 
  }
}

// Creating an object
Car myCar = new Car();

Here, Car is the class, and myCar is an object of that class.

6. What is encapsulation?

Encapsulation is one of the fundamental principles of OOP. It refers to wrapping data (variables) and methods (functions) together into a single unit — the class — while restricting direct access to some of the object's components.

This helps protect the internal state of an object and prevents unauthorized or unintended modifications.

Example (Java):

public class Person {
  private String name; // hidden from outside

  public void setName(String n) {
    name = n;
  }

  public String getName() {
    return name;
  }
}

The name variable is private and can only be accessed through public getter and setter methods.

7. What are getters and setters?

Getters and setters are public methods used to access and update private variables of a class. They're essential for implementing encapsulation properly.

• Getter — provides read-only access to a private variable
• Setter — controls how data is written, allowing validation before assignment

public class Student {
  private int age;

  public int getAge() { return age; }
  
  public void setAge(int a) {
    if (a > 0) age = a;
  }
}

8. What is the difference between public, private, and protected access modifiers?

9. What is abstraction?

Abstraction focuses on hiding complex implementation details and showing only the essential features of an object. It allows programmers to focus on what an object does rather than how it does it.

Example: When you use a smartphone to make a call, you don't need to understand the internal workings of the cellular network — you just need to know how to dial a number.

10. How is abstraction different from encapsulation?

Abstraction hides complexity by showing only relevant details. It's about simplifying the interface.

Encapsulation hides data and protects it from unauthorized access. It's about data security and controlled access.

Think of it this way: Abstraction is "what you see," encapsulation is "what you can't touch."

11. How do abstract classes differ from interfaces?

12. What is inheritance? How does it promote code reusability?

Inheritance allows one class (child/subclass) to inherit fields and methods from another class (parent/superclass). It promotes reusability because common code can be written once in the parent class and automatically shared by all child classes.

Example:

class Vehicle {
  void start() {
    System.out.println("Vehicle started");
  }
}

class Car extends Vehicle {
  void drive() {
    System.out.println("Car driving");
  }
}

Here, Car inherits the start() method from Vehicle, avoiding code duplication.

13. What are the various types of inheritance?

• Single Inheritance — A class inherits from one parent class
• Multiple Inheritance — A class inherits from multiple parent classes (supported in C++ via classes, in Java via interfaces)
• Multilevel Inheritance — A class inherits from a derived class, forming a chain
• Hierarchical Inheritance — Multiple classes inherit from a single parent class
• Hybrid Inheritance — Combination of two or more types of inheritance

14. What is the role of the 'super' keyword in inheritance?

The super keyword is used to:

• Call the parent class constructor
• Access parent class methods that have been overridden
• Access parent class variables that are hidden by child class variables

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

class Dog extends Animal {
  void sound() {
    super.sound(); // calls parent method
    System.out.println("Dog barks");
  }
}

15. What is polymorphism?

Polymorphism means "many forms." It's an OOP concept that allows a single method name, function, or operator to behave differently depending on the object or context.

Example:

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

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

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

// Runtime polymorphism
Shape s = new Circle();
s.draw(); // Output: Drawing Circle

16. What is the difference between method overloading and method overriding?

17. What is dynamic method dispatch?

Dynamic method dispatch is the process by which a call to an overridden method is resolved at runtime rather than compile-time. This is the foundation of runtime polymorphism in Java.

Animal a = new Dog();
a.sound(); // Calls Dog's sound() at runtime

The JVM determines which method to call based on the actual object type (Dog), not the reference type (Animal).

18. What is a singleton class? How do you implement it?

A singleton class ensures only one instance of the class exists throughout the application. This pattern is useful for managing shared resources like database connections or configuration settings.

Implementation (Java):

class Singleton {
  private static Singleton instance;
  
  private Singleton() {} // private constructor
  
  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}

19. What is the difference between composition and aggregation?

20. What is the difference between Composition and Inheritance?

21. What is exception handling?

Exception handling is the process of responding to and recovering from exceptions (unexpected or abnormal conditions) during program execution. It ensures programs can handle errors gracefully without crashing.

In OOP, exception handling is typically implemented using try, catch, and finally blocks.

22. How do you handle exceptions in OOP?

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
} finally {
    System.out.println("Execution completed");
}

• try block — wraps code that might throw an exception
• catch block — contains code to handle the exception
• finally block — contains code that executes regardless of whether an exception occurred

23. What is the difference between checked and unchecked exceptions?

24. How does OOP compare to procedural programming?

25. What is the difference between shallow copy and deep copy?

26. What is garbage collection in OOP?

Garbage collection is the automatic process of identifying and freeing memory occupied by objects that are no longer referenced in the program. It prevents memory leaks and simplifies memory management.

Languages like Java, Python, and C# have built-in garbage collectors that run in the background. In contrast, C and C++ require manual memory management using malloc/free or new/delete.

27. What is the difference between mutable and immutable objects?