**Course Title:** Mastering C#: From Fundamentals to Advanced Programming **Section Title:** Object-Oriented Programming in C# **Topic:** Understanding encapsulation, inheritance, and polymorphism **Introduction** In object-oriented programming, encapsulation, inheritance, and polymorphism are three fundamental concepts that enable us to write more maintainable, flexible, and reusable code. In this topic, we will delve into each of these concepts and explore how they can be applied in C# programming. **Encapsulation** Encapsulation is the practice of hiding the internal details of an object from the outside world and only exposing the necessary information through public methods. This helps to protect the object's data from external interference and misuse. In C#, encapsulation is achieved through the use of access modifiers such as public, private, and protected. For example, consider a simple BankAccount class: ```csharp public class BankAccount { private decimal balance; public BankAccount(decimal initialBalance) { balance = initialBalance; } public void Deposit(decimal amount) { balance += amount; } public void Withdraw(decimal amount) { if (balance >= amount) { balance -= amount; } } public decimal GetBalance() { return balance; } } ``` In this example, the `balance` field is private, meaning it can only be accessed within the `BankAccount` class. The `Deposit` and `Withdraw` methods modify the `balance` field, while the `GetBalance` method returns the current balance. This encapsulation helps to ensure that the `balance` field is not modified accidentally or maliciously. **Inheritance** Inheritance is the mechanism by which one class can inherit the properties and behavior of another class. The child class inherits all the fields and methods of the parent class and can also add new fields and methods or override the ones inherited from the parent class. In C#, inheritance is achieved through the use of the `:` keyword. For example, consider a simple `Vehicle` class and a `Car` class that inherits from `Vehicle`: ```csharp public class Vehicle { public string Brand { get; set; } public string Model { get; set; } public virtual void Move() { Console.WriteLine("Vehicle is moving"); } } public class Car : Vehicle { public int NumWheels { get; set; } public override void Move() { Console.WriteLine("Car is moving"); } } ``` In this example, the `Car` class inherits the `Brand`, `Model`, and `Move` method from the `Vehicle` class. The `Car` class also adds a new field `NumWheels` and overrides the `Move` method. **Polymorphism** Polymorphism is the ability of an object to take on multiple forms. In C#, polymorphism is achieved through method overriding or method overloading. Method overriding is when a child class overrides a method of the parent class with the same name, return type, and parameter list. For example: ```csharp public class Animal { public virtual void Sound() { Console.WriteLine("Animal makes a sound"); } } public class Dog : Animal { public override void Sound() { Console.WriteLine("Dog barks"); } } public class Cat : Animal { public override void Sound() { Console.WriteLine("Cat meows"); } } ``` In this example, the `Dog` and `Cat` classes override the `Sound` method of the `Animal` class. Method overloading is when multiple methods with the same name but different parameter lists are defined in a class. For example: ```csharp public class Calculator { public int Add(int a, int b) { return a + b; } public double Add(double a, double b) { return a + b; } public int Add(int a, int b, int c) { return a + b + c; } } ``` In this example, the `Calculator` class has three `Add` methods with different parameter lists. **Conclusion** In this topic, we covered the concepts of encapsulation, inheritance, and polymorphism in C# programming. Encapsulation helps to protect the internal details of an object, inheritance enables code reuse, and polymorphism allows objects to take on multiple forms. **Practice Exercise** Create a `Shape` class with a method `Area()` that calculates the area of the shape. Then, create `Circle`, `Rectangle`, and `Triangle` classes that inherit from the `Shape` class and override the `Area()` method. **Additional Resources** * [Microsoft Docs: Encapsulation](https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/encapsulation) * [Microsoft Docs: Inheritance](https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/inheritance) * [Microsoft Docs: Polymorphism](https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/polymorphism) **Leave a Comment/Ask for Help** If you have any questions or need help with the practice exercise, please leave a comment below.