01.01.24

Author: Devinterview-io

README.md

@@ -1,18 +1,17 @@
-# ⚫ OOP in Tech Interviews 2024: 39 Must-Know Questions & Answers
+# 52 Important OOP Interview Questions
 
-**Object-Oriented Programming** is a paradigm centered on "objects" with data (attributes) and code (methods). Key principles include encapsulation, inheritance, polymorphism, and abstraction. In interviews, OOP questions assess candidate's understanding of design patterns, class relationships, and software organization.
+<div>
+<p align="center">
+<a href="https://devinterview.io/questions/web-and-mobile-development/">
+<img src="https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/github-blog-img%2Fweb-and-mobile-development-github-img.jpg?alt=media&token=1b5eeecc-c9fb-49f5-9e03-50cf2e309555" alt="web-and-mobile-development" width="100%">
+</a>
+</p>
 
-Check out our carefully selected list of **basic** and **advanced** OOP questions and answers to be well-prepared for your tech interviews in 2024.
+#### You can also find all 52 answers here 👉 [Devinterview.io - OOP](https://devinterview.io/questions/web-and-mobile-development/oop-interview-questions)
 
-![OOP Decorative Image](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/blogImg%2Foop.png?alt=media&token=ee035010-99e8-4156-a06b-2915368d7021&_gl=1*52h48a*_ga*OTYzMjY5NTkwLjE2ODg4NDM4Njg.*_ga_CW55HF8NVT*MTY5ODYwNTk1NS4xOTAuMS4xNjk4NjA2NjI0LjU5LjAuMA..)
+<br>
 
-👉🏼 You can also find all answers here: [Devinterview.io - OOP](https://devinterview.io/dev/oop-interview-questions)
-
----
-
-## 🔹 1. What is _Object-Oriented Programming_ (OOP)?
-
-### Answer
+## 1. What is _Object-Oriented Programming (OOP)_?
 
 **Object-Oriented Programming** is a programming paradigm that organizes code into **self-contained objects**. 
 
@@ -146,12 +145,9 @@ In the example:
 - **Inheritance**: Both `Lion` and `Parrot` classes inherit from the `Animal` class.
 - **Polymorphism**: Both `Lion` and `Parrot` provide their own implementation of the `makeSound()` method, even though they are treated as `Animal` objects.
 - **Abstraction**: The `Animal` class contains the abstract method `makeSound()`, ensuring derived classes provide their own implementation.
+<br>
 
----
-
-## 🔹 2. What is the difference between _Procedural_ and _Object-Oriented_ programming?
-
-### Answer
+## 2. What is the difference between _procedural_ and _Object-Oriented_ programming?
 
 **Procedural** and **Object-Oriented Programming** (OOP) are distinct programming paradigms. While procedural programming is linear and task-centric, OOP emphasizes an organic model, where data is encapsulated in objects.
 
@@ -236,201 +232,164 @@ public class Main {
     }
 }
 ```
+<br>
 
----
+## 3. What is _encapsulation_?
 
-## 🔹 3. What is a _Class_?
+**Encapsulation** is an object-oriented programming principle that combines data and methods that act on that data within a single unit, known as an **object**.
 
-### Answer
+### Key Concepts
 
-**Class** in Object-Oriented Programming represents a blueprint for creating objects (instances). It encapsulates attributes (data) and behaviors (methods) under a unified structure.
+- **Information Hiding**: Encapsulation hides internal state and implementation details.
 
-When instantiated, each **object** can carry individual data, adhering to the blueprint provided by its class.
+- **Access ControL**: Data is made available to external code only through defined methods: **getters** - for reading and **setters** - for writing.
 
-### Key Components of a Class
+- **Constraining Behavior**: Access methods can ensure that data adheres to specific rules (e.g., range checks or formatting standards).
 
-- **Attributes**: They store the state of an object and can have varying data types.
 
-- **Methods**: These are functions defined within the class, designed to operate on attributes or perform specific behaviors.
+### Benefits of Encapsulation
 
-### OOP Principles in Classes
+- **Security**: Offers controlled access to object data, reducing the risk of data corruption or unauthorized modifications.
 
-- **Inheritance**: Allows a subclass (child class) to inherit attributes and methods from a superclass (parent class).
+- **Simplicity**: Objects abstract complex systems, presenting a simple interface for interaction.
 
-- **Encapsulation**: Attributes and methods are bundled within a class, limiting direct access to ensure data safety.
-
-- **Polymorphism**: Allows objects of different classes that implement the same interface to be used in a consistent manner.
+- **Flexibility**: Encapsulation promotes loose coupling, making it easier to modify or replace object internals without impacting the external code.
 
-- **Abstraction**: Hides internal details, providing a simplified interface. Achieved in classes by exposing only essential methods.
+### Practical Applications
 
-### Code Example: The Car Class
+- **Class Construction**: Modern programming languages like Java and C# follow an "encapsulation first" approach, utilizing access specifiers like `public`, `private`, and `protected`.
 
-Here is the Python code:
+- **API Design**: As a software developer, encapsulating classes and modules helps create intuitive and focused APIs. It allows hiding internal strategies while exposing the desired functionality.
 
-```python
-class Car:
-    """A class to represent a car."""
-    
-    def __init__(self, make, model, year):
-        """Initialize car attributes."""
-        self.make = make
-        self.model = model
-        self.year = year
-        self.fuel = 0
+- **Testing**: Data hiding helps prevent direct access to object internals during testing, ensuring proper evaluation of object behavior through its public interface.
 
-    def fill_tank(self, gallons):
-        """Add fuel to the tank. Ensure the amount is positive."""
-        if gallons > 0:
-            self.fuel += gallons
-        else:
-            print("Invalid fuel amount.")
+### Code Example: Encapsulation
 
-    def drive(self, distance=1):
-        """Drive the car, consuming fuel based on distance."""
-        if self.fuel >= distance:
-            self.fuel -= distance
-            print(f"Car drove {distance} unit(s). Remaining fuel: {self.fuel} units.")
-        else:
-            print("Insufficient fuel.")
-
-# Create a Car object
-my_car = Car("Honda", "Civic", 2022)
-
-# Access its attributes and methods
-my_car.fill_tank(10)
-
-for _ in range(15):
-    my_car.drive()
-```
+Here is the Java code:
 
+```java
+public class Car {
+    private int fuel;  // private ensures that fuel can't be accessed directly from outside the class
 
----
+    public Car() {
+        this.fuel = 100;  // Initialize with 100 units of fuel
+    }
 
-## 🔹 4. What is an _Object_?
+    // Getter method for fuel
+    public int getFuel() {
+        return fuel;
+    }
 
-### Answer
+    // Setter method for fuel with encapsulation enforcing constraints
+    public void setFuel(int fuel) {
+        if (fuel >= 0 && fuel <= 100) {
+            this.fuel = fuel;
+        } else {
+            System.out.println("Invalid fuel amount.");
+        }
+    }
 
-An **object** represents a specific instance of a **class**. It encapsulates both **data** (attributes) and **behavior** (methods) within a single unit.
+    public void drive() {
+        if (fuel > 0) {
+            fuel--;
+            System.out.println("Vroom!");
+        } else {
+            System.out.println("Out of fuel!");
+        }
+    }
 
-### Core Characteristics
+    public static void main(String[] args) {
+        Car myCar = new Car();
+        myCar.drive();
+        System.out.println("Fuel remaining: " + myCar.getFuel());
+        myCar.setFuel(120);  // This will print "Invalid fuel amount."
+    }
+}
+```
+<br>
 
-- **Identity**: Each object has a unique identity that distinguishes it from others.
-- **State**: Defined by its attributes, an object's state can change throughout its existence.
-- **Behavior**: The methods associated with the object describe its possible actions or operations.
+## 4. What is _polymorphism_? Explain _overriding_ and _overloading_.
 
-### Lifecycle of an Object
+**Polymorphism** in object-oriented programming allows objects of different types to be treated as if they belong to the same type through a **shared interface**. It abstracts method details, promoting code flexibility and reusability.
 
-1. **Creation**: Objects are created from a class through a process called instantiation.
-2. **Manipulation**: They may undergo state changes as attributes are modified, and methods are invoked.
-3. **Destruction**: Terminates the object's existence, often handled automatically by the programming language ("garbage collection") or explicitly through code.
+### Core Concepts
 
-### Code Example: Object Instantiation
+#### Overloading (Compile-time Polymorphism)
 
-Here is the Python code:
+**Multiple methods** in the same class can have the same name but different parameters, allowing them to coexist. The compiler selects the appropriate method based on the method signature.
 
-``` python
-class Dog:
-    def __init__(self, name, breed):
-        self.name = name
-        self.breed = breed
+#### Code Example: Overloading
 
-    def bark(self):
-        print("Woof!")
+Here is the Java code:
 
-myDog = Dog("Buddy", "Golden Retriever")
+```java
+public class Sum {
+    public int add(int a, int b) {
+        return a + b;
+    }
+  
+    public double add(double a, double b) {
+        return a + b;
+    }
+}
 ```
 
----
-
-## 🔹 5. Explain the _Hierarchical Relationship_ between classes.
-
-### Answer
+#### Overriding (Runtime Polymorphism)
 
-In OOP, **classes** are often organized in a **hierarchical** manner through inheritance. This hierarchy establishes relationships where specific classes are built upon more general ones, refining or extending their characteristics and behaviors.
-
-### Key Concepts
+A **subclass** provides a specific implementation of a method that is already defined in its parent class, effectively replacing the parent's version. The method to be called is determined during the program's execution.
 
-- **Base and Derived Classes**: The base (or parent) class provides a foundational set of attributes and methods. Derived (or child) classes inherit from the base class, adapting or expanding upon its defined characteristics.
-
-- **Inheritance Chain**: This represents the sequence of derived classes from a base class. A derived class can itself be a base class for another, leading to multiple layers in the hierarchy.
-
-### Visual Representation
-
-![Class Hierarchy](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/oop%2Fclass-hierarchy%20(1).jpg?alt=media&token=f14cea00-085b-4cb8-b440-860302f0fa16&_gl=1*16lln2r*_ga*OTYzMjY5NTkwLjE2ODg4NDM4Njg.*_ga_CW55HF8NVT*MTY5ODA3NDc5OC4xNzMuMS4xNjk4MDc1MDcxLjU2LjAuMA..)
-
-### Code Example: Class Hierarchy
+#### Code Example: Overriding
 
 Here is the Python code:
 
 ```python
 class Animal:
-    def __init__(self, name, age):
-        self.name = name
-        self.age = age
-
-    def eat(self):
-        print(f"{self.name} is eating.")
-
-class Mammal(Animal):
-    def sleep(self):
-        print(f"{self.name} is sleeping.")
-
-class Bird(Animal):
-    def fly(self):
-        print(f"{self.name} is flying.")
-
-class Lion(Mammal):
-    def __init__(self, name, age, gender):
-        super().__init__(name, age)
-        self.gender = gender
-
-    def roar(self):
-        print(f"{self.name} is roaring.")
-
-class Whale(Mammal):
-    def swim(self):
-        print(f"{self.name} is swimming.")
+    def speak(self):
+        return "Animal speaks"
+  
+class Cat(Animal):
+    def speak(self):
+        return "Cat meows"
 
-class Penguin(Bird):
-    def walk(self):
-        print(f"{self.name} is walking on land.")
+obj_cat = Cat()
+print(obj_cat.speak())  # Output: Cat meows
 ```
 
----
+#### Virtual Methods (in languages like C++)
 
-## 🔹 6. What is the difference between a _Method_ and a _Function_ in the context of _OOP_?
+Methods marked `virtual` in the base class can be overridden in derived classes. They enable **dynamic dispatch**, ensuring the correct method is called, even through base class references.
 
-### Answer
+#### Code Example: Virtual Methods
 
-**Methods** and **functions** are both means to group code for reuse in OOP, but they serve different roles based on where and how they are used.
+Here is the C++ code:
 
-While all methods are functions in a broader sense, not all functions are methods. The distinction lies in their relationship (or lack thereof) to class instances.
+```cpp
+#include <iostream>
+using namespace std;
 
-### Methods: Object-Linked Behavior
+class Animal {
+public:
+    virtual void speak() {
+        cout << "Animal speaks";
+    }
+};
 
-- **What**: Methods are functions that are defined within a **class** and are associated with object behavior. They are designed to manipulate or interact with the class's instance data (attributes).
-  
-- **Invocation**: Methods are invoked on an instance of a class using dot notation, e.g., `my_object.my_method()`.
-  
-- **Access**: Methods inherently have access to the object's data and other methods. In many OOP languages, this is done through a self-reference (like `self` in Python or `this` in Java).
-  
-- **Example**: Consider a `Car` class. The actions `start_engine` and `change_gear` would be methods, tailored to the state and behavior of specific car instances.
+class Cat : public Animal {
+public:
+    void speak() override {
+        cout << "Cat meows";
+    }
+};
+```
 
-### Functions: Class-Agnostic Procedures
+### Dynamic Dispatch and Late Binding
 
-- **What**: In the OOP context, functions can be defined within a class but aren't tied to an instance's behavior or data. Such functions might be static methods in some languages, meaning they relate to the class rather than any specific instance.
-  
-- **Invocation**: Functions, even if part of a class, are typically called without requiring an instance. In some languages, this might require special notation, like using the `@staticmethod` decorator in Python.
-  
-- **Access**: Functions within a class context don't typically access or modify instance-specific data unless passed that data explicitly.
-  
-- **Example**: Inside a `Math` class, a function `square_root` would be a general utility that computes the square root of a number. It doesn't operate on instance data and doesn't need to know about specific `Math` objects.
+Polymorphism often leverages **dynamic dispatch**, a mechanism that determines at runtime which specific method to invoke.
 
----
+This is also known as **late binding**. This feature enables generic code that can handle multiple object types, enriching flexibility and adaptability.
+<br>
 
-## 🔹 7. What is _Inheritance_? Name some _Types of Inheritance_.
-
-### Answer
+## 5. What is _inheritance_? Name some _types of inheritance_.
 
 **Inheritance** is a fundamental concept in object-oriented programming that allows for the creation of **new classes** based on existing ones.
 
@@ -524,302 +483,633 @@ class J extends H { }  // Class J also inherits from class H
 // Java does not directly support hybrid inheritance through classes.
 // However, you can achieve something similar using interfaces, as shown with multiple inheritance.
 ```
+<br>
 
----
+## 6. What is an _abstraction_? Name some _abstraction techniques_.
 
-## 🔹 8. Compare _Inheritance_ vs. _Mixin_ vs. _Composition_.
+**Abstraction** in object-oriented programming (OOP) is the concept of focusing on essential characteristics and hiding unnecessary details.
 
-### Answer
+It enables clear separation between high-level concepts and their specific implementations, promoting **code reusability**, **maintainability**, and **security**.
 
-**Inheritance**, **mixins**, and **composition** are all techniques in object-oriented programming that deal with code reuse and the relationship between objects or classes.
+### Abstraction Techniques
 
-Let's look into the details and compare them:
+#### Abstract Classes
 
-### Inheritance
+- **Definition**: An abstract class is a class that cannot be instantiated on its own. It serves as a foundation for other classes.
+- **Purpose**: Abstract classes allow you to define base behaviors that can be overridden by derived classes, while also allowing you to provide some default implementations. This means that while you define certain methods as abstract (no implementation), others can have actual code.
+- **Use Case**: If you have a set of functionalities where some methods have a default behavior but can be overridden, and others must be defined by any child class, you'd use an abstract class.
 
-- **Definition**: A class (subclass) inherits properties and behaviors from another class (superclass).
-- **Relationship**: "is-a" (e.g., a `Car` is a `Vehicle`).
-- **Pros**: Direct way to reuse code; establishes intuitive relationships.
-- **Cons**: Can lead to complex hierarchies; potential for over-generalization.
+#### Interfaces
 
-### Mixin
+- **Definition**: An interface is a contract or blueprint that classes adhere to. Unlike abstract classes, interfaces have no implementation details; they only declare method and property signatures.
+- **Purpose**: Interfaces ensure a certain set of methods or properties exist in the classes that implement them. They guarantee a specific structure or behavior without dictating how that behavior is achieved.
+- **Use Case**: When you want multiple classes to adhere to a specific contract, ensuring they all have the same methods (but possibly different implementations), you'd use an interface.
 
-- **Definition**: A class that offers methods to other classes without being a standalone entity. Common in languages without multiple inheritance, such as Python.
-- **Relationship**: "kind-of-a" or "can-do-this" (e.g., a `Helicopter` can fly like a `Bird`).
-- **Pros**: Reuses code across classes; avoids deep inheritance issues.
-- **Cons**: Method source can be unclear; potential name clashes.
+### Code Example: Abstraction Techniques
 
-### Composition
+Here is the Java code:
 
-- **Definition**: Building objects by combining simpler ones. Emphasizes a "has-a" relationship.
-- **Relationship**: "has-a" (e.g., a `Car` has an `Engine`).
-- **Pros**: Encourages modular design; components can be easily swapped.
-- **Cons**: May need more design upfront; can require more boilerplate code.
+```java
+// Abstract Class
+abstract class Vehicle {
+    // Abstract method (no body)
+    public abstract String start();
+
+    // Regular method
+    public String stop() {
+        return "Vehicle stopped!";
+    }
+}
 
-Many modern OOP design guidelines, like the **composition over inheritance principle**, suggest that unless there's a clear "is-a" relationship, it's often better to use **composition** as it's more flexible and leads to a more modular and maintainable design.
+// Implementing the abstract class
+class Car extends Vehicle {
+    @Override
+    public String start() {
+        return "Car started!";
+    }
+}
 
----
+// Interface
+interface Drivable {
+    // All methods in an interface are implicitly abstract
+    void drive();
+}
 
-## 🔹 9. Can you inherit _Private Members_ of a _Class_?
+// Implementing both the abstract class and the interface
+class Bike extends Vehicle implements Drivable {
+    @Override
+    public String start() {
+        return "Bike started!";
+    }
 
-### Answer
+    @Override
+    public void drive() {
+        System.out.println("Bike is being driven!");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Car car = new Car();
+        System.out.println(car.start()); // Output: Car started!
+        System.out.println(car.stop());  // Output: Vehicle stopped!
+
+        Bike bike = new Bike();
+        System.out.println(bike.start()); // Output: Bike started!
+        bike.drive();                     // Output: Bike is being driven!
+    }
+}
+```
+<br>
+
+## 7. What is a _class_ in OOP?
+
+**Class** in Object-Oriented Programming represents a blueprint for creating objects (instances). It encapsulates attributes (data) and behaviors (methods) under a unified structure.
 
-While both **public** and **protected** members can be inherited by derived classes in **OOP**, this is **not** the case for **private** members.
+When instantiated, each **object** can carry individual data, adhering to the blueprint provided by its class.
 
-In most OOP languages these members are **not accessible** outside their declaring class.
+### Key Components of a Class
+
+- **Attributes**: They store the state of an object and can have varying data types.
 
----
+- **Methods**: These are functions defined within the class, designed to operate on attributes or perform specific behaviors.
 
-## 🔹 10. Can a _Class_ inherit the _Constructor_ of its _Base Class_?
+### OOP Principles in Classes
 
-### Answer
+- **Inheritance**: Allows a subclass (child class) to inherit attributes and methods from a superclass (parent class).
 
-While traditionally **constructors are not inherited** by derived classes, some languages offer mechanisms to manage constructor behavior, such as **constructor chaining**.
+- **Encapsulation**: Attributes and methods are bundled within a class, limiting direct access to ensure data safety.
 
-### Constructor Inheritance in Different Languages
+- **Polymorphism**: Allows objects of different classes that implement the same interface to be used in a consistent manner.
 
-- **C++**: Constructors aren't inherited, but you can use constructor initializer lists to invoke a base class constructor.
+- **Abstraction**: Hides internal details, providing a simplified interface. Achieved in classes by exposing only essential methods.
+
+### Code Example: The Car Class
+
+Here is the Python code:
+
+```python
+class Car:
+    """A class to represent a car."""
+    
+    def __init__(self, make, model, year):
+        """Initialize car attributes."""
+        self.make = make
+        self.model = model
+        self.year = year
+        self.fuel = 0
+
+    def fill_tank(self, gallons):
+        """Add fuel to the tank. Ensure the amount is positive."""
+        if gallons > 0:
+            self.fuel += gallons
+        else:
+            print("Invalid fuel amount.")
+
+    def drive(self, distance=1):
+        """Drive the car, consuming fuel based on distance."""
+        if self.fuel >= distance:
+            self.fuel -= distance
+            print(f"Car drove {distance} unit(s). Remaining fuel: {self.fuel} units.")
+        else:
+            print("Insufficient fuel.")
+
+# Create a Car object
+my_car = Car("Honda", "Civic", 2022)
+
+# Access its attributes and methods
+my_car.fill_tank(10)
+
+for _ in range(15):
+    my_car.drive()
+```
+
+<br>
+
+## 8. What is an _object_ in OOP?
+
+An **object** represents a specific instance of a **class**. It encapsulates both **data** (attributes) and **behavior** (methods) within a single unit.
+
+### Core Characteristics
+
+- **Identity**: Each object has a unique identity that distinguishes it from others.
+- **State**: Defined by its attributes, an object's state can change throughout its existence.
+- **Behavior**: The methods associated with the object describe its possible actions or operations.
+
+### Lifecycle of an Object
+
+1. **Creation**: Objects are created from a class through a process called instantiation.
+2. **Manipulation**: They may undergo state changes as attributes are modified, and methods are invoked.
+3. **Destruction**: Terminates the object's existence, often handled automatically by the programming language ("garbage collection") or explicitly through code.
+
+### Code Example: Object Instantiation
+
+Here is the Python code:
+
+``` python
+class Dog:
+    def __init__(self, name, breed):
+        self.name = name
+        self.breed = breed
+
+    def bark(self):
+        print("Woof!")
+
+myDog = Dog("Buddy", "Golden Retriever")
+```
+<br>
+
+## 9. How do _access specifiers_ work and what are they typically?
+
+In Object-Oriented Programming (OOP), **access specifiers** define the level of visibility and accessibility of class members.
+
+### Types of Access Specifiers
+
+1. **Private**: Members are only accessible within the defining class, ensuring data encapsulation.
+2. **Protected**: Members are accessible within the defining class and its subclasses.
+3. **Public**: Members are globally accessible to all classes.
+
+### Code Example: Access Specifiers
+
+Here is the Java code:
+
+```java
+public class Car {
+    private String make;  // Accessible only within class
+    protected int year;   // Accessible within class and subclasses
+    double price;         // Default visibility: package-private
+    
+    public void setMake(String make) {
+        this.make = make;
+    }
+
+    public String getMake() {
+        return make;
+    }
+
+    protected void startEngine() {
+       System.out.println("Engine started!");
+    }
+}
+```
+
+### Key Concepts
+
+- **Data Encapsulation**: It ensures data integrity by hiding the class's internal state and **exposing it through methods**. This enables better control over the data and its access.
+
+- **Inheritance and Abstraction**: Access levels regulate visibility in the context of inheritance, allowing classes to interact while preserving encapsulation.
+
+### Common Mistakes
+
+- **Excessive Use of Getter/Setter Pairs**: While they are useful for protecting data, avoid introducing methods that do not provide added functionality.
 
-- **Java**: Constructors aren't inherited, but if a derived class constructor doesn't explicitly invoke a base class constructor, the no-argument base class constructor is called automatically.
+- **Needless Use of Public Members**: If a member does not require global access, consider using more restrictive access levels for better encapsulation.
 
-- **Python**: Making use of the `super()` mechanism ensures appropriate base class constructor invocations across the inheritance hierarchy.
+### Best Practices
 
-- **C#**: Constructors are not inherited, but derived classes can use the `base` keyword to call a constructor from the base class. If a derived class does not explicitly define any constructors, the default constructor of the base class is automatically invoked.
+- **Favor Composition Over Inheritance**: If classes are loosely related, hiding details and components ensures better code maintenance.
 
-- **Swift**: Constructors aren't inherited. However, Swift introduces designated and convenience initializers for class construction and proper initialization across inheritance.
+- **Private by Default**: Encapsulate whenever possible. By default, members should be private, and their visibility be broadened only if necessary.
 
-- **Kotlin**: Constructors aren't inherited, but derived classes need to invoke the base class constructor using the `super` keyword.
+- **Minimal Use of Public Members**: Use them sparingly for elements that genuinely need global access.
 
----
-## 🔹 11. How to prevent a _Class_ to be _Inherited_ further?
+- **Consistent Visibility**: Aim for uniform visibility within a class to avoid confusion.
+<br>
 
-### Answer
+## 10. Name some ways to _overload_ a _method_.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+Let's look at three common techniques to **overload** a method.
 
----
+### 1. Changing Parameter Number
 
-## 🔹 12. What is _Encapsulation_?
+This method involves altering the number of parameters in different method signatures.
 
-### Answer
+Here is an example in Java:
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+```java
+public int calculateSum(int a, int b) { // Two parameters
+    return a + b;
+}
 
----
+public int calculateSum(int a, int b, int c) { // Three parameters
+    return a + b + c;
+}
+```
 
-## 🔹 13. What is _Polymorphism_? Explain _Overriding_ and _Overloading_.
+### 2. Adapting Parameter Order
 
-### Answer
+Another overloading technique involves rearranging the **order of parameters** in methods to create unique signatures.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+Here is an example in Java:
 
----
+```java
+public double calculateArea(double length, double width) { // Length, then width
+    return length * width;
+}
 
-## 🔹 14. Name some ways to _Overload_ a _Method_.
+public double calculateArea(double radius) { // Just radius for a circle
+    return Math.PI * radius * radius;
+}
+```
 
-### Answer
+### 3. Varying Parameter Type
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+You can define methods with different types of parameters to enable **overloading**.
 
----
+Here is an example in Java:
 
-## 🔹 15. What is an _Abstraction_? Name some _Abstraction Techniques_.
+```java
+public void printDetails(String name, int age) {
+    System.out.println("Name: " + name + " , Age: " + age);
+}
+
+public void printDetails(int id) {
+    System.out.println("ID: " + id);
+}
+
+public void printDetails(double salary) {
+    System.out.println("Salary: " + salary);
+}
+```
+<br>
+
+## 11. What is _cohesion_ in OOP?
+
+**Cohesion** in OOP refers to how closely the methods and data within a single class are related to one another. A highly cohesive class is focused on a specific task or responsibility, making it easier to maintain, understand, and ensure reliability.
+
+**High cohesion** is a desired attribute because it means that methods and properties within a class work together in a unified manner. In contrast, **low cohesion** indicates that a class has multiple, often unrelated responsibilities, making it harder to understand and maintain.
 
-### Answer
+### Levels of Cohesion
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+1. **Coincidental**: Methods and properties within the class have no meaningful relationship.
+2. **Logical**: Methods are grouped based on some logic but lack a clear theme.
+3. **Temporal**: Methods are related by when they are executed, e.g., initialization methods.
+4. **Procedural**: Methods are executed in a specific sequence.
+5. **Communicational**: Methods work on the same set of data.
+6. **Sequential**: The output of one method serves as the input for another.
+7. **Functional**: All methods in the class contribute to a single well-defined task.
 
----
+Of these, functional cohesion is the most desirable, as it closely aligns with the **Single Responsibility Principle**.
 
-## 🔹 16. What is an _Abstract Class_?
+### Code Example: Low Cohesion Levels
 
-### Answer
+Here is the Java code:
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+```java
+public class FileUtility {
 
----
+    public String readFile(String fileName) {
+        // Read a file
+        return content;
+    }
 
-## 🔹 17. What is an _Interface_?
+    public void writeToDatabase(String data) {
+        // Write content to a database
+    }
 
-### Answer
+    public void clearCache() {
+        // Clear application cache
+    }
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+    public List<String> parseFile(String content) {
+        // Parse file content
+        return parsedData;
+    }
+}
+```
 
----
+This `FileUtility` class exhibits low cohesion as it mixes file operations, database writing, and cache management.
 
-## 🔹 18. When to use _Interface_ vs. _Base Class_?
+### Recommendations for Improving Cohesion
 
-### Answer
+1. **Single Responsibility Principle (SRP)**: Each class should have only one reason to change. This principle suggests that a class should focus on one task or responsibility.
+2. **Encapsulation**: Encourage data hiding, and expose data only through focused and related methods.
+<br>
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+## 12. What is _coupling_ in OOP?
 
----
+**Coupling** in OOP describes the degree of interdependence between classes or modules. It determines how closely different modules or classes are linked to each other, impacting the system's flexibility, maintainability, and testability.
 
-## 🔹 19. Why can't _Static Methods_ in _C#_ implement an _Interface_?
+**Loose coupling** is generally preferred in software design.
 
-### Answer
+### Types of Coupling
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+1. **Content Coupling**: This is the strongest form of coupling where one module directly accesses or modifies another module's internal data.
 
----
+2. **Common Coupling**: Multiple modules share access to common global data. Any change to this shared resource can affect all the modules that depend on it.
 
-## 🔹 20. Can a _Non-static_ method be overridden as _Static_?
+3. **Control Coupling**: One module controls the flow of another by passing it control information, such as using flags.
 
-### Answer
+4. **External Coupling**: Classes or modules are linked by external factors, such as configuration files or data schemas.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+5. **Stamp (or Data) Coupling**: Modules share data structures and use only parts of them, requiring knowledge about the structure of the data being passed.
 
----
+6. **Message Coupling**: The lowest form of coupling where modules communicate only through standard interfaces, such as method calls or messages.
 
-## 🔹 21. Can you set _Accessibility Modifiers_ for methods within an _Interface_?
+### Relationship with SOLID Principles
 
-### Answer
+- **Single Responsibility Principle (SRP)**: Adhering to SRP typically results in **low coupling** since classes have a singular focus, thereby minimizing dependencies.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+- **Open-Closed Principle (OCP)**: Emphasizing extensibility without modification, OCP reduces the risk of **tight coupling** as extensions are typically made through interfaces or abstract classes.
 
----
+- **Liskov Substitution Principle (LSP)**: When derived classes can replace their base classes without side effects, there's often a **reduction in coupling**, ensuring modules can operate independently of the specific derived class in use.
 
-## 🔹 22. Explain the concepts of _Constructor_ and _Destructor_.
+- **Interface Segregation Principle (ISP)**: By endorsing focused interfaces rather than "one-size-fits-all" ones, ISP naturally leads to **decreased coupling** as classes aren't forced to depend on methods they don't use.
 
-### Answer
+- **Dependency Inversion Principle (DIP)**: By relying on abstractions rather than concrete implementations, DIP promotes **low coupling**, making systems more modular and adaptable.
+<br>
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+## 13. What is a _constructor_ and how is it used?
 
----
+A **constructor** is a special method in **object-oriented programming** used for initializing objects. It ensures that **newly created** objects are set up with appropriate initial state and any required resources.
 
-## 🔹 23. What is a _Static Constructor_?
+### Key Concepts
 
-### Answer
+#### Purpose
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+- A constructor ensures that an object is in a consistent state when created.
+- It initializes and configures the object's attributes or fields.
 
----
+#### Characteristics
 
-## 🔹 24. Why might a _Destructor_ in a _C#_ class not execute?
+- **Matches Object Definitions**: Each class defines one or more contructors for its objects.
+- **Has a Class Name**: Constructors are named after the class, making them easy to identify.
+- **No Return Type**: They don't return a value, not even `void`.
+- **Automatic Invocation**: They are invoked or 'called' when an object is created.
 
-### Answer
+#### Types of Constructors
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+1. **Default Constructors**:
+   - No parameters.
+   - Automatically provided by the language if no constructor is defined.
+  
+2. **Parameterized Constructors**:
+   - Accept parameters for custom initialization.
+   - Often used to provide initial values to internal attributes or fields.
 
----
+3. **Copy Constructors**:
+   - Accept another object of the same type and initialize the current object using values from it.
+   - Commonly used for deep copying in languages like C++.
 
-## 🔹 25. What is the difference between a _Class_ and a _Structure_?
+4. **Static Constructors**:
+   - Used to initialize static member variables or for other class-level actions.
+   - They don't take part in the creation of objects and can be absent in many OOP languages.
 
-### Answer
+#### Code Examples: Constructors
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+Here is the Java code:
 
----
+```java
+class Vehicle {
+    private String vehicleType;
+    private int wheels;
+
+    // Default Constructor
+    public Vehicle() {
+        vehicleType = "Car";
+        wheels = 4;
+    }
 
-## 🔹 26. What is the difference between _Virtual method_ and _Abstract method_?
+    // Parameterized Constructor
+    public Vehicle(String type, int wheelCount) {
+        vehicleType = type;
+        wheels = wheelCount;
+    }
 
-### Answer
+    public void showDetails() {
+        System.out.println("Type of Vehicle: " + vehicleType);
+        System.out.println("Number of Wheels: " + wheels);
+    }
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+    public static void main(String[] args) {
+        // Calling Default Constructor
+        Vehicle car = new Vehicle();
+        car.showDetails();
 
----
+        // Calling Parameterized Constructor
+        Vehicle bike = new Vehicle("Bike", 2);
+        bike.showDetails();
+    }
+}
+```
 
-## 🔹 27. What is the purpose of a _Virtual keyword_?
+Here is a C++ code:
 
-### Answer
+```cpp
+#include <iostream>
+using namespace std;
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+class Person {
+    private:
+        string name;
+        int age;
 
----
+    public:
+        // Parameterized Constructor
+        Person(string n, int a) {
+            name = n;
+            age = a;
+        }
 
-## 🔹 28. What is _Cohesion_ in OOP?
+        void displayInfo() {
+            cout << "Name: " << name << ", Age: " << age << endl;
+        }
+};
 
-### Answer
+int main() {
+    // Calling Parameterized Constructor
+    Person p1 = Person("Alice", 25);
+    p1.displayInfo();
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+    return 0;
+}
+```
 
----
+Here is a C# code:
 
-## 🔹 29. What is _Coupling_ in OOP?
+```csharp
+using System;
 
-### Answer
+class Car {
+    private string model;
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+    // Parameterized Constructor
+    public Car(string m) {
+        model = m;
+    }
 
----
+    static void Main() {
+        // Calling Parameterized Constructor
+        Car c = new Car("Toyota");
+        Console.WriteLine("Car Model: " + c.model);
+    }
+}
+```
+<br>
 
-## 🔹 30. What is the difference between _Cohesion_ and _Coupling_?
+## 14. Describe the concept of _destructor_ or _finalizer_ in OOP.
 
-### Answer
+**Destructors**, or class **finalizers**, are used in **object-oriented programming** to perform cleanup actions before an object is destroyed.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+### Object Destruction
 
----
+Objects can be **explicitly** or **implicitly** destroyed:
 
-## 🔹 31. How do _Association_, _Aggregation_, and _Composition_ differ in OOP?
+- **Explicit**: The programmer calls a destructing function or method. Languages like C++ use a destructor.
+- **Implicit**: The language or environment manages object destruction. Garbage collectors in Java, C#, and Python are examples.
 
-### Answer
+### Destructors
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+A **destructor** is a special method that is automatically called right before an object goes out of scope or is explicitly destroyed. Its primary purpose is to release resources or perform other cleanup tasks, like closing files or releasing memory.
 
----
+#### Use Cases
 
-## 🔹 32. What is _Liskov Substitution Principle_ (LSP)? Provide some examples of _Violation_ and _Adherence_.
+- **Resource Management**: Ensuring timely release of system resources.
+- **Memory Management**: Helpful in non-garbage collected languages to prevent memory leaks.
+- **Logging Exit or Cleanup Actions**: Commonly used to log an object's destruction or clean-up steps.
 
-### Answer
+### Garbage Collection
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+For memory management, garbage collection is a mechanism that specifically targets automatic memory reclamation. In languages like Java and C#, destructors may not be necessary due to reliable garbage collectors.
 
----
+#### Note for Java Developers
 
-## 🔹 33. Whait is _Repository Pattern_? Name some of it's benefits.
+Java introduced the `finalize()` method, which is similar to a destructor. It's often discouraged in favor of using the `AutoCloseable` interface and the `try-with-resources` statement for enhanced resource management.
 
-### Answer
+#### Code Example: C++
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+Here is the C++ code:
 
----
+```cpp
+class Resource {
+public:
+    Resource() { std::cout << "Resource Acquired\n"; }
+    ~Resource() { std::cout << "Resource Destroyed\n"; }
+};
 
-## 🔹 34. How _Monads_ can be useful in _OOP_?
+int main() {
+    Resource r;
+}  // Destructs r here
+```
 
-### Answer
+### Non-Memory Resources
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+Destructors can manage a variety of resources in addition to memory, such as:
 
----
+- **Files**: Ensuring files are closed to avoid data loss.
+- **Network Connections**: Closing sockets to prevent resource leaks.
+- **Database Connections**: Helpful in releasing database locks or sessions.
+- **Hardware Devices**: For devices like cameras or sensors, freeing resources ensures they are available for other applications.
 
-## 🔹 35. What is a _Unit Of Work_?
+#### Code Example: Resource Management
 
-### Answer
+Here is the C++ code:
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+```cpp
+#include <iostream>
+#include <fstream>
 
----
+class FileHandler {
+public:
+    std::ofstream file;
+    FileHandler(std::string fileName) {
+        file.open(fileName);
+        if (file.is_open()) {
+            std::cout << "File Opened\n";
+        }
+    }
+    ~FileHandler() {
+        if (file.is_open()) {
+            file.close();
+            std::cout << "File Closed\n";
+        }
+    }
+};
 
-## 🔹 36. Does _.NET_ support _Multiple Inheritance_?
+int main() {
+    FileHandler fh("sample.txt");
+}  // Destructor called on fh, closes the file
+```
+<br>
 
-### Answer
+## 15. Compare _inheritance_ vs. _mixin_ vs. _composition_.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+**Inheritance**, **mixins**, and **composition** are all techniques in object-oriented programming that deal with code reuse and the relationship between objects or classes.
 
----
+Let's look into the details and compare them:
 
-## 🔹 37. Why use _Getters_ and _Setters_ for simple operations instead of _Public Fields_?
+### Inheritance
 
-### Answer
+- **Definition**: A class (subclass) inherits properties and behaviors from another class (superclass).
+- **Relationship**: "is-a" (e.g., a `Car` is a `Vehicle`).
+- **Pros**: Direct way to reuse code; establishes intuitive relationships.
+- **Cons**: Can lead to complex hierarchies; potential for over-generalization.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+### Mixin
 
----
+- **Definition**: A class that offers methods to other classes without being a standalone entity. Common in languages without multiple inheritance, such as Python.
+- **Relationship**: "kind-of-a" or "can-do-this" (e.g., a `Helicopter` can fly like a `Bird`).
+- **Pros**: Reuses code across classes; avoids deep inheritance issues.
+- **Cons**: Method source can be unclear; potential name clashes.
 
-## 🔹 38. What is _Circular Reference_? How to solve it?
+### Composition
 
-### Answer
+- **Definition**: Building objects by combining simpler ones. Emphasizes a "has-a" relationship.
+- **Relationship**: "has-a" (e.g., a `Car` has an `Engine`).
+- **Pros**: Encourages modular design; components can be easily swapped.
+- **Cons**: May need more design upfront; can require more boilerplate code.
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+Many modern OOP design guidelines, like the **composition over inheritance principle**, suggest that unless there's a clear "is-a" relationship, it's often better to use **composition** as it's more flexible and leads to a more modular and maintainable design.
+<br>
 
----
 
-## 🔹 39. Is it possible to declare a _Private Class_ within a _Namespace_?
 
-### Answer
+#### Explore all 52 answers here 👉 [Devinterview.io - OOP](https://devinterview.io/questions/web-and-mobile-development/oop-interview-questions)
 
-👉🏼 Check out all 39 answers here: [Devinterview.io - OOP](https://devinterview.io/data/oop-interview-questions)
+<br>
 
----
+<a href="https://devinterview.io/questions/web-and-mobile-development/">
+<img src="https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/github-blog-img%2Fweb-and-mobile-development-github-img.jpg?alt=media&token=1b5eeecc-c9fb-49f5-9e03-50cf2e309555" alt="web-and-mobile-development" width="100%">
+</a>
+</p>