What is the difference between inheritance, encapsulation and polymorp

Question

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

Rajanikant Hawaldar · 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 c alling 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/

Sachin Singh · Answer

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 Yelve · Answer

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 Bijarniya · Answer

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 Dodiya · Answer

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/

Patel · Answer

https://www.guru99.com/difference-between-abstraction-and-encapsulation.html

Lalit Holkar · Answer

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.

Rajeev Kumar · Answer

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.