Inheritance — "borrowing from a parent"

Inheritance means one class can reuse the properties and methods of another class, instead of writing everything from scratch.

Think of it like this: a Car and a Bike are both Vehicle s. They both have a speed, both can start, both can stop. Instead of writing that logic twice, you write it once in a Vehicle class, and let Car and Bike "inherit" it.

public class Employee
{
    public string Name { get; set; }
    public decimal BaseSalary { get; set; }

    public void ShowDetails()
    {
        Console.WriteLine($"{Name} earns {BaseSalary}");
    }
}

public class Manager : Employee   // Manager inherits from Employee
{
    public decimal TeamBonus { get; set; }
}

Now Manager automatically gets Name, BaseSalary, and ShowDetails() — you didn't write them again. You just added the extra thing a Manager has (TeamBonus).

Polymorphism — "same call, different behavior"

Polymorphism means you can call the same method name on different objects, and each one behaves in its own way — the calling code doesn't need to know which exact type it's dealing with.

public class Employee
{
    public virtual void ShowDetails()
    {
        Console.WriteLine("I am an employee");
    }
}

public class Manager : Employee
{
    public override void ShowDetails()
    {
        Console.WriteLine("I am a manager, I lead a team");
    }
}

public class Developer : Employee
{
    public override void ShowDetails()
    {
        Console.WriteLine("I am a developer, I write code");
    }
}

Now watch this:

List staff = new List { new Manager(), new Developer() };

foreach (var person in staff)
{
    person.ShowDetails();  // same method call...
}

Output:

I am a manager, I lead a team
I am a developer, I write code

Same line of code — person.ShowDetails() — but it behaves differently depending on whether the actual object is a Manager or a Developer. That's polymorphism — "many forms" of the same action.

The simplest way to remember the difference

Inheritance

Inheritance allows one class to inherit properties and methods from another class.

It helps with:

• Code reuse

• Cleaner structure

• Reducing duplication

class Parent

{

public void Show()

{

Console.WriteLine("Parent class method");

}

}

class Child : Parent

{

public void Display()

{

Console.WriteLine("Child class method");

}

}

Child obj = new Child();

obj.Show(); // Inherited from Parent

obj.Display(); // Child’s own method

• Child : Parent ? Child inherits Parent.

• Child automatically gets access to Parent’s public methods.

Polymorphism

Polymorphism means "many forms."
A method can behave differently depending on how it is used.

In C#, there are two main types:

1. Compile-time Polymorphism (Method Overloading)

2. Run-time Polymorphism (Method Overriding)

Method Overloading (Compile-Time)

Same method name, but different parameters.

class Calculator

{

public int Add(int a, int b)

{

return a + b;

}

public int Add(int a, int b, int c)

{

return a + b + c;

}

}

• The method name is the same (Add)

• Parameters are different

• The compiler decides which one to call

Method Overriding (Run-Time)

A child class changes the behavior of a parent class method.

class Animal

{

public virtual void Sound()

{

Console.WriteLine("Animal makes sound");

}

}

class Dog : Animal

{

public override void Sound()

{

Console.WriteLine("Dog barks");

}

}

Animal obj = new Dog();

obj.Sound();

Output:

Dog barks

• virtual ? Allows the method to be overridden

• override ? Replaces the base method

• The decision happens at runtime