Key Concepts of OOPS:

1. Class
2. Object
3. Encapsulation
4. Inheritance
5. Polymorphism
6. Abstraction

The main pillars of OOPS are Encapsulation, Inheritance, Polymorphism, Abstraction.

Let’s discuss about these concepts.

Class:

A class is a user defined data type. It contains attributes and methods, which can be accessed and used by creating an instance of class.
Class is like a blueprint for an object.

Object:

An object is an instance of a class. It represents real world entities.
When a class is created, no memory is allocated but when it is instantiated(i.e., an object is created) memory is allocated.

Access Modifiers:

1. Private — data attributes and methods accessible only inside the class.
2. Public — data attributes and methods accessible to everyone.
3. Protected — data attributes and methods accessible inside the class and to its derived class.

Note: By default, everything inside the class is private(i.e., we cannot access data attributes and methods outside the class).

Encapsulation:

Encapsulation is wrapping up data attributes and methods in a single unit(i.e, class). It is also known as “data hiding”. To hide data, we need to use the private access modifier. The data attributes of a class can be accessed only through member functions of same class in which they are declared.

Constructors:

Special method invoked automatically at time of object creation. Used for initialisation of objects.
Same name as class. Constructor doesn’t have a return type. Only called once(automatically if not defined) at object creation. Memory allocation happens when constructor is called.
There are 4types of constructors:
1. Non-Parameterized
2. Parameterized
3. Copy
4. Move

Non-Parameterized Constructor:
It is also known as default constructor or zero-argument constructor. It is automatically created by compiler if not defined by programmer.

Parameterized Constructor:
Parameterized constructor allows us to pass arguments to constructors.
Note: If a parameterized constructor is defined, the non-parameterized constructor should also be defined as compiler does not create the default constructor.

Copy Constructor:
Special constructor used to copy properties of one object into another. There are 2 types of copies possible in C++.
1. Shallow Copy
2. Deep Copy

• Shallow Copy:
  A shallow copy of an object copies all the member values from one object to another.
• Deep Copy:
  A deep copy, on the other hand, not only copies the member values but also makes copies of any dynamically allocated memory that the members point to.
  Note: A default copy constructor do shallow copy.

Move Constructor:
A move constructor in C++ is a special constructor that transfers (or “moves”) the resources of an value object (temporary object) to a new object, instead of copying them. It helps avoid deep copies and improves performance, especially when working with dynamic memory or large objects.

Inheritance:

The capability of a class to derive properties and characteristics from another class is called Inheritance. Inheritance is used for code reusability.

Derived/Child class — The class that inherit methods and properties from the other class and can also have some additional features.

Base/Parent class — The class that provides common properties and methods which can be inherited by other class.

There are 5 types of inheritance which are
1. Single
2. Multilevel
3. Hierarchical
4. Multiple
5. Hybrid

Mode of Inheritance:

Polymorphism:

Polymorphism is the ability of objects to take on different forms or behave in different ways depending on the context in which they are used.
There are 2 types of polymorphism:
1. Compile-Time polymorphism
2. Runtime polymorphism

Compile-Time Polymorphism:
It is also known as early binding and static polymorphism. In this the compiler decides how the function or operator works depend on the context.
This polymorphism achieved by function overloading or operator overloading.

• Function Overloading:
  Function overloading is when we are defining two or more functions with the same name in the class but only differ in terms of their parameters(either by data type or number of parameters).
• Operator Overloading:
  C++ has the ability to provide the operators with a special meaning for particular data type, this ability is known as operator overloading.
  For example we can use “+” for addition of integers and also for concatenation of strings.

Runtime Polymorphism:
It is also known as late binding and dynamic polymorphism. The function call in runtime polymorphism, resolved at runtime.
This polymorphism achieved by function overriding and virtual functions.

• Function Overriding:
  Function overriding occurs when derived class has one or more functions of base class. The base class is said to be overridden. The base class function must be declared as virtual function for runtime polymorphism.

Abstraction:

Hiding all the unnecessary details and showing only the important parts.
Abstraction can be implemented using Access Specifiers and Classes.

Lets break this problem from the beginning.

What is Inheritance?

It is a concept where one class(child) inherits the methods and properties from the other class(parent).

Derived/Child class: The class that inherit methods and properties from the other class and can also have some additional features.

Base/Parent class: The class that provides common properties and methods which can be inherited by other class.

There are 5 types of inheritance which are
1. Single
2. Multilevel
3. Hierarchical
4. Multiple
5. Hybrid

Talking about multiple inheritance, a class will inherit the properties and methods from more than one class.

Now let’s understand this by taking an example.

Here Parent1 and Parent2 are inheriting the same method from the Base class and Child class is inherting same method from both Parent1 and Parent2.

Lets talk this with respect to programming language C++ and Java.

1. C++
   C++ supports multiple inheritance.

Example Code:

#include<bits/stdc++.h>
using namespace std;

class Base{
  public:
    void greet(){
        cout<<"Hello from Base!!"<<endl;
    }
};

class Parent1 : public Base{
  public:
};

class Parent2 : public Base{
  public:  
};

class Child : public Parent1,Parent2{
};

int main(){
    Child c = Child();
    c.greet();
}

Output:

main.cpp: In function ‘int main()’:
main.cpp:24:7: error: request for member ‘greet’ is ambiguous
   24 |     c.greet();
      |       ^~~~~
main.cpp:6:10: note: candidates are: ‘void Base::greet()’
    6 |     void greet(){
      |          ^~~~~
main.cpp:6:10: note:                 ‘void Base::greet()’

Here this ambiguity arises because the child class has multiple paths to access the members or methods inherited from the common ancestor, these leading to confusion during method resoultion and member access.

Solution:

In C++, we can solve this issue by using Virtual Inheritance.
Virtual Inheritance ensures only one instance of a common base class is inherited by all derived classes, preventing ambiguity and redundancy.

#include<bits/stdc++.h>
using namespace std;

class Base{
  public:
    void greet(){
        cout<<"Hello from Base!!"<<endl;
    }
};

class Parent1 : virtual public Base{
  public:
};

class Parent2 : virtual public Base{
  public:  
};

class Child : public Parent1,Parent2{
};

int main(){
    Child c = Child();
    c.greet();
}

Output:

Hello from Base!!

2. Java
Java does not supports multiple inheritance.

Example code:

import java.io.*;

class Base{
    void greet(){
        System.out.println("Hello from Base!!");
    }
}

class Parent1 extends Base{
    
}

class Parent2 extends Base{
    
}

class Child extends Parent1, Parent2{
    
}

public class Main{
    public static void main(String[] args){
        Child c = new Child();
        c.greet();
    }
}

Output:

Main.java:15: error: '{' expected
class Child extends Parent1, Parent2{
                           ^
1 error

Here this error is caused by the multiple inheritance as child class confused from which parent class the greet method should be inherited.

Solution:
In Java, we can solve this issue using interfaces.
Interface supports multiple inheritance. The purpose of Interface is to describe what should be done.

import java.io.*;

interface Base{
    default void greet(){
        System.out.println("Hello from Base!!");
    }
}

interface Parent1 extends Base{
    
}

interface Parent2 extends Base{
    
}

class child implements Parent1, Parent2{
    
}

public class Main{
    public static void main(String[] args){
        child c = new child();
        c.greet();
    }
}

Output:

Hello from Base!!

By using default void greet() { ... } in the Base interface, we are creating a single, definitive implementation at the very top of the hierarchy.
When Parent1 and Parent2 extend Base , they inherit the actual code for it.
When the Child class implements both Parent1 and Parent2, the Java compiler needs to decide which greet() method to use.
Path 1: Child -> Parent1 -> Base.greet()
Path 2: Child -> Parent2 -> Base.greet()

Both paths leads to the exact same method, there is no ambiguity. The compiler knows which code to use. It’s the one and only default method defined in Base .

The Problem: Waiting Around (Synchronous Code)

Imagine you order food (Task 1), and then you want to get a drink (Task 2).
If the restaurant worked “synchronously” (like old-style JavaScript for some tasks):

1. You order food.
2. You must stand at the counter, doing nothing, until your food is ready.
3. Only after you get your food, can you go order and get your drink.
   This is inefficient! You’re stuck waiting.

JavaScript, by default, is mostly synchronous for its main operations. If a task takes a long time (like fetching data from a server), your entire webpage would freeze. We don’t want that!

Solution 1: Callbacks (Callback Hell)

This is like telling the waiter: “Here’s my food order. When it’s ready, call me back on this number (the callback function), and then I will decide what to do next (like order a drink).”
This works, but if you have many dependent tasks, it gets messy: “When the food is ready, call me back. Then, when you call back, I will order a drink. When the drink is ready, call me back again. Then I will ask for the bill…” This leads to nested functions, often called “Callback Hell,” which is hard to read and manage.

Solution 2: Promises

Think of a Promise like a restaurant buzzer or a receipt for your order.

1. You order food (initiate an asynchronous operation).
2. The restaurant gives you a buzzer (a Promise object). This buzzer doesn’t have your food yet, but it’s a promise that you will get your food eventually, or they will tell you if there is a problem.
3. You can go do other things (your JavaScript continues running other code) while holding onto this buzzer.

A Promise has three states:

• Pending: You’ve ordered, but the food isn’t ready yet (the operation hasn’t completed).
• Fulfilled: Your buzzer goes off! Your food is ready (the operation completed successfully, and you have the result).
• Rejected: The waiter comes and says, “Sorry, we’re out of that item” (the operation failed, and you have an error).

How to use Promises:

You attach actions to the promise using .then() for success and .catch() for failure.

Solution 3: Async and Await

async and await are special keywords that make working with Promises look more like synchronous code, making it easier to read and write.

• async keyword: You put async in front of a function declaration. This tells JavaScript two things:
  1. This function will automatically return a Promise.
  2. You can use the await keyword inside this function.
• await keyword: You can only use await inside an async function. When you put await in front of a Promise:
  1. It pauses the execution of the async function at that line.
  2. It waits for the Promise to settle (either fulfill or reject).
  3. If the Promise fulfills, await gives you the resolved value.
  4. If the Promise rejects, await throws an error (just like regular synchronous code would), which you can catch with a try...catch block.

Key Takeaways:

1. Promises: Represent an operation that hasn’t completed yet but will at some point. They help you manage asynchronous tasks without freezing your application or using messy callbacks. Use .then() for success, .catch() for failure.
2. async Functions: Declare a function that handles asynchronous operations. They always return a Promise.
3. await Operator: Used inside async functions to pause execution until a Promise settles. It makes asynchronous code look cleaner and more like synchronous code. You use try...catch for error handling with await.

Think of async/await as a very polite way of saying "I will wait for this to finish before I do the next step in this specific function, but other parts of my program can keep running."

• Analogy: You get in line. You order your coffee. You wait right there at the counter until your coffee is made. Only after you receive your coffee can the next person in line order and wait.
• In JavaScript: Code executes line by line, one at a time. Each operation must complete before the next one can start. If an operation takes a long time (e.g., fetching data from a server, reading a large file), the entire program (and in a browser, the user interface) will freeze and become unresponsive until that operation finishes. This is called blocking.

Asynchronous(Async):

• Analogy: You get in line. You order your coffee. They give you a buzzer. You can then go sit down, read a book, or chat with a friend. When your coffee is ready, the buzzer goes off, and you go pick it up. You didn’t have to stand there waiting; you could do other things in the meantime.
• In JavaScript: When an asynchronous operation is started (e.g., fetching data, setting a timer), the program doesn’t wait for it to complete. It moves on to the next line of code immediately. The long-running task happens in the “background” (managed by the browser’s Web APIs or Node.js’s C++ APIs and the event loop). When the task is finished, a callback function, Promise, or async/await mechanism is used to handle the result. This is non-blocking.

Why Asynchronous is crucial in JavaScript:

JavaScript in browsers (and typically in Node.js) runs on a single thread. If everything were synchronous, any long-running operation (like fetching data for a webpage) would freeze the entire browser tab, making for a terrible user experience. Asynchronous operations allow the browser to remain responsive, handling user interactions like clicks and scrolls, while other tasks (like data fetching) are happening in the background.

Mechanisms for Handling Asynchronous Operations in JavaScript:

1. Callbacks: The original way. You pass a function as an argument to another function, and that passed-in function (the callback) gets executed when the async operation completes. Can lead to “callback hell” (deeply nested callbacks).
2. Promises: An object representing the eventual completion (or failure) of an asynchronous operation. They provide a cleaner way to handle async results with .then() for success and .catch() for errors, allowing for better chaining.
3. Async/Await: Syntactic sugar built on top of Promises. It makes asynchronous code look and behave a bit more like synchronous code, making it easier to read and write. The async keyword declares an asynchronous function, and await pauses the execution of that function until a Promise settles.

Note:

Async function always returns a promise.