explain & describe it with the help of c# code in easy wording The concept of class encapsulation Inheritance & Access Controls Method Overloading and Method Overriding Using class relations and inheritance together Polymorphism: Introduction Polymorphism: Implementation Abstract and sealed method Interfaces and Multiple Inheritance

Sure, let's break down these concepts one by one:

1. Class Encapsulation: Encapsulation is a process of bundling the data and methods that operate on the data into a single unit called class. In C#, a class can be defined using the class keyword. Here is a simple example:

public class Employee
{
    private string name; // data encapsulated (hidden)

    public string Name // method to access data
    {
        get { return name; }
        set { name = value; }
    }
}

2. Inheritance & Access Controls: Inheritance is a feature that allows a class to inherit properties and methods from another class. The class that is inherited is called the base class, and the class that inherits is called the derived class. Access controls like public, private, and protected determine the accessibility of the properties and methods.

public class Person // base class
{
    public string name;
}

public class Employee : Person // derived class
{
    public int employeeId;
}

3. Method Overloading and Method Overriding: Method overloading is creating methods with the same name but different parameters. Method overriding is redefining a method in a derived class that is already defined in the base class.

public class MyClass
{
    public void Display() // Method Overloading
    {
        // code
    }

    public void Display(int a) // Method Overloading
    {
        // code
    }
}

public class BaseClass
{
    public virtual void Show() // Method Overriding
    {
        // code
    }
}

public class DerivedClass : BaseClass
{
    public override void Show() // Method Overriding
    {
        // code
    }
}

4. Using class relations and inheritance together: Class relations like association, aggregation, and composition can be used along with inheritance to create more complex relationships.

public class Department // base class
{
    public string departmentName;
}

public class Employee : Department // derived class
{
    public string employeeName;
    public Department department; // association relationship
}

5. Polymorphism: Polymorphism allows objects of different classes to be treated as objects of a common superclass. It has two types: compile-time polymorphism (method overloading) and runtime polymorphism (method overriding).

public class Shape // base class
{
    public virtual void Draw() // Method to be overridden
    {
        // code
    }
}

public class Circle : Shape // derived class
{
    public override void Draw() // Overridden method
    {
        // code
    }
}

6. Abstract and sealed methods: Abstract methods are declared in an abstract class and does not have any implementation. Sealed methods are used to restrict the inheritance feature of object-oriented programming. Once a class is defined as a sealed class, this class cannot be inherited.

public abstract class AbstractClass // Abstract class
{
    public abstract void AbstractMethod(); // Abstract method
}

public sealed class SealedClass // Sealed class
{
    public void SealedMethod()
    {
        // code
    }
}

7. Interfaces and Multiple Inheritance: C# does not support multiple inheritance directly because it can lead to a lot of confusion when two base classes implement a method with the same name. However, you can use interfaces to implement multiple inheritance.

interface IFirstInterface // First interface
{
    void myMethod();
}

interface ISecondInterface // Second interface
{
    void myMethod();
}

class MyClass : IFirstInterface, ISecondInterface // Multiple inheritance
{
    void IFirstInterface.myMethod()
    {
        // code
    }

    void ISecondInterface.myMethod()
    {
        // code
    }
}

I hope this helps! Let me know if you have any other questions.