What is the difference between inheritance, encapsulation and polymorp

Naresh Beniwal

4y1.4kC#

What is the difference between inheritance, encapsulation and polymorphism in C#?

8 Replies

Know the answer? Post it — somebody with the same question will find it here.

Rajanikant Hawaldar4y ago
Accepted answer
Hi Naresh,
If you understand what inhertrance, enacapsulatiom and ployimorpism does that is enough to know the difference of every pillor of oops because each pillor do its task and they are not same that is the difference please go through below simple understanding ways...

Inheritance is about reusing of code(method, property etc) from other classes please, refer below code.
//Base class or Parent class.
class Shape
{
    public double Width;
    public double Height;
    public void ShowDim()
    {
        Console.WriteLine("Width and height are " +
        Width + " and " + Height);
    }
}
// Triangle is derived from Shape.
//Drived class or Child class.
class Triangle : Shape
{
    public string Style; // style of triangle
    // Return area of triangle.
    public double Area()
    {
        return Width * Height / 2;
    }
    // Display a triangle's style.
    public void ShowStyle()
    {
        Console.WriteLine("Triangle is " + Style);
    }
}
https://www.c-sharpcorner.com/UploadFile/9582c9/inheritance-with-example-in-C-Sharp/
Encapsulation is about hiding methods, properties etc which is not usefull / which does not make sense to use in other classes
using system;
public class WriteDepartment {
    private string departname;
    public string Departname {
        set {
            departname = value;
            Console.WriteLine("The Department is :{0}", departname);
        }
    }
}
public class WriteDepartmain {
    public static int Main(string[] args) {
        WriteDepartment d = new WriteDepartment();
        d.departname = "COMPUTERSCIENCE";
        return 0;
    }
}
https://www.c-sharpcorner.com/article/encapsulation-in-C-Sharp/
https://www.c-sharpcorner.com/blogs/what-is-an-encapsulation

Polymopism is calling child class method through base class reference variable is called polymorpism(runtime).

It is also known as Early Binding. Method overloading is an example of Static Polymorphism. In overloading, the method / function has a same name but different signatures. It is also known as Compile Time Polymorphism because the decision of which method is to be called is made at compile time. Overloading is the concept in which method names are the same with a different set of parameters.

// Below is an exaple of overloading method
public class TestData
{
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
    public int Add(int a, int b)
    {
        return a + b;
    }
}
class Program
{
    static void Main(string[] args)
    {
        TestData dataClass = new TestData();
        int add2 = dataClass.Add(45, 34, 67);
        int add1 = dataClass.Add(23, 34);
    }
}
Dynamic / runtime polymorphism is also known as late binding. Here, the method name and the method signature (number of parameters and parameter type must be the same and may have a different implementation). Method overriding is an example of dynamic polymorphism.

// Below is an example of method overidding
using System;
public class Animal{
    public virtual void eat(){
        Console.WriteLine("eating...");
    }
}
public class Dog: Animal
{
    public override void eat()
    {
        Console.WriteLine("eating bread...");
    }

}
public class TestPolymorphism
{
    public static void Main()
    {
        Animal a= new Dog(); // calling child class method through base class reference
        // variable is called ploymorpism(runtime).
        a.eat();
    }
}
https://www.c-sharpcorner.com/UploadFile/ff2f08/understanding-polymorphism-in-C-Sharp/
Rajeev Kumar3y ago
Inheritance, polymorphism, and encapsulation comprise the three central characteristics of object-oriented (OO) programming. Inheritance allows you to create class hierarchies, where a base class gives its behavior and attributes to a derived class. You are then free to modify or extend its functionality. Polymorphism ensures that the proper method will be executed based on the calling object’s type. Encapsulation allows you to control access to your object’s state, while making it easier to maintain or change your implementation at a later date.
Patel4y ago
https://www.guru99.com/difference-between-abstraction-and-encapsulation.html

Lalit Holkar4y ago

There is a alot of diffrence in the Inheritance Encapsulation and the polymorphism few are below.

Inheritance

Encapsulation

Polymorphism

1. it is a technique to access base class functionality to the child class

2. It Help us in code Reusablity.

3. example you get everything which your father own.

1.In encapulation we encapsulate the data and function into one unit .

2. its provide us the accessibility Related stuff

3. example access modifiers like private public etc.

1.Polymorphism mean one thing many form

2. with the help of polymorphism we can provide additional functionality to the function ex. function overloading.

3. example change the earlier implementation of the function.

Sachin Singh4y ago
1. Inheriting the behavior is called as Inheritance
('is a' relationship) ex:- Manager is an employee (Manager:Employee)

2. Hiding the complex behavior is called as encapsulation. (using access specifiers in methods/properties etc)

3. Changing the behaviour at compile/run time is called as polymorphism
(Area(a) has different behavior than Area(a,b) )
Vishal Yelve4y ago
Hi Naresh,

Please refer below links

Encapsulation vs. Inheritance

https://www.developer.com/design/encapsulation-vs-inheritance/#:~:text=Inheritance%20dictates%20that%20a%20child,private)%20data%20of%20another%20class.

Inheritance vs Polymorphism

https://www.geeksforgeeks.org/difference-between-inheritance-and-polymorphism/#:~:text=1.-,Inheritance%20is%20one%20in%20which%20a%20new%20class%20is%20created,is%20basically%20applied%20to%20classes.
Alkesh Bijarniya4y ago
Hi Naresh

Please refer the following article it will help you to understand inheritance,encapsulation and ploymorphsim with real time example

https://www.c-sharpcorner.com/UploadFile/mkagrahari/introduction-to-object-oriented-programming-concepts-in-C-Sharp/

For ploymorphsim you can read the folloiwng article
https://www.tutlane.com/tutorial/csharp/csharp-polymorphism
Uday Dodiya4y ago
Please Refer Followings

https://www.nerd.vision/post/polymorphism-encapsulation-data-abstraction-and-inheritance-in-object-oriented-programming

https://www.geeksforgeeks.org/understanding-encapsulation-inheritance-polymorphism-abstraction-in-oops/