Pillars Of OOP/Overview Of OOP

public class Account
{
    private double balance;
    
    public double GetBalance()
    {
        return balance;
    }
}

// Imagine main as outside world
public static void Main()
{
    Account obj = new Account();
    double currentBalance = obj.GetBalance();

    // The following thing is not possible since that data member is private
    obj.balance = 20000000000;
}

Benefits/Advantages Of Using Abstraction

The advantage of Abstraction is, it reduces the complexity of end users since to the end user we have shown only things that are necessary to him and not shown the unnecessary things. Imagine what would have happened when we told the bike rider things happening inside the engine (i.e. irrelevant information) when he changed the gear. So it would have increased the complexity of bike riders.

Implementation In Programming Language

Imagine a car. Now let's think in terms of a car rider or a person who is riding a car. So to drive a car what a car rider should know and what not.

Necessary things

• Brakes
• Gear
• Steering

Unnecessary things

• Exhaust System
• What happens when he changes the Gear of the car?
• Silencer

Here I have written the code snippet in C# to explain the above-mentioned things.

class Car  
{  
    public string Brakes { get; set; }  
    // Gear is exposed using the public access modifier.  
    public string Gear { get; set; }  
    public string Steering { get; set; }  
  
    private void Exhaust_System()  
    {  
        // Implementation  
    }  
    
    // Hidden using the private access modifier  
    private void What_happen_we_he_change_the_Gear_of_car()  
    {  
        // Implementation  
    }  
    
    private void Silencer()  
    {  
        // Implementation  
    }  
}  

Note. Abstraction and abstract class are two different things so they are not much related. Do not confuse by comparing those two. Consider them as independent.

3. What Is Inheritance?

The process of creating a new class by extending the existing class is called inheritance or the process of inheriting the features of the base class is called as inheritance.

The existing class is called the base class and the new class which is created from it is called the derived class.

Real Life Example Of Inheritance

We inherit some of our features (maybe body color, nose shape, height of body, etc) from Mom and Dad.

Benefits/Advantages Of Using Inheritance

The most important advantage of inheritance is code re-usability. In Inheritance the derived class possesses all attributes/properties and functions of the base class, this is where code re-usability comes into the picture. So no need to write the same function and attributes of the base class in the derived class.

Note. Private members of the base class also get inherited in the derived class but they are not accessible in the derived class.

Implementation Of Inheritance In Programming Language

// Suppose initially I wrote a base class Shape as
class Shape  
{  
    public int width;  
    public int height;  
    
    public void SetWidth(int w)  
    {  
        width = w;  
    }  
    
    public void SetHeight(int h)  
    {  
        height = h;  
    }  
}  
  
// Derived class Rectangle  
class Rectangle : Shape  
{  
    public int GetArea()  
    {  
        return width * height;  
    }  
}  

Like rectangles, we may have parallelograms, and rhombus so there is no need to declare width and height each time, just inherit those classes (parallelogram, rhombus) from the Shape class. This is how code reusability comes into the picture.

class Tester  
{  
    static void Main()  
    {  
        // Derived class object  
        Rectangle obj = new Rectangle();  
        obj.SetWidth(5);  
        obj.SetHeight(10);  
        Console.WriteLine("Area of rectangle is {0}", obj.GetArea());  
        Console.Read();  
    }  
}  

What Is Polymorphism?

Poly means many and Morph means forms. Polymorphism is the process in which an object or function takes different forms.

Real-Life Example Of Polymorphism

A real-life example of Polymorphism is a mobile phone. It is a single object but it can be used for making calls, listening to music, sending mail, taking pictures, etc (different forms).

Implementation Of Polymorphism In Programming Language

We can implement polymorphism using method overloading, method overriding, etc.

// Implementation of polymorphism using method overloading
class Base  
{  
    public int Add(int num1, int num2)  
    {  
        return (num1 + num2);  
    }  
    
    public int Add(double num1, double num2)  
    {  
        return (int)(num1 + num2);  
    }   
}  

class Program  
{  
    public static void Main()  
    {  
        Base obj = new Base();  
        Console.WriteLine("Addition of two integer numbers is " + obj.Add(4, 5));  
        Console.WriteLine("Addition of two float numbers is " + obj.Add(6.78, 5.23));  
    }  
}

So what we observe is function Add takes two forms. The first form is for adding integer numbers and the second form is for adding float numbers.

Advantages/Benefits Of Using Polymorphism

The main advantage of polymorphism is, that it makes the life of the end-user easy since instead of having two methods (as shown in the above example) AddInt for adding an integer and AddFloat for adding the float we have only one method Add. So end user have to remember only the Add method and not AddInt and AddFloat.