ਵਿਰਾਸਤ ਅਤੇ ਪੌਲੀਮੌਰਫਿਜ਼ਮ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**Inheritance** ਇੱਕ ਕਲਾਸ ਨੂੰ ਇੱਕ ਬੇਸ ਕਲਾਸ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਦਿੰਦੀ ਹੈ, ਇਸਦੇ ਮੈਂਬਰਜ਼ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਦੇ ਹੋਏ ਅਤੇ ਵਿਸਤਾਰ ਕਰਦੇ ਹੋਏ। **Polymorphism** ਤੁਹਾਨੂੰ ਡੈਰਾਈਵਡ ਆਬਜੈਕਟਜ਼ ਨੂੰ ਇੱਕ ਬੇਸ ਟਾਈਪ ਦੁਆਰਾ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਦਿੰਦਾ ਹੈ, ਸਠੀਕ ਓਵਰਰਾਈਡ ਕੀਤਾ ਗਿਆ ਮੈਥਡ ਰਨਟਾਈਮ ਉੱਤੇ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (`virtual`/`override` ਦੁਆਰਾ)। ਇਹ C# ਵਿੱਚ ਮੂਲ OOP ਵਿਧੀਆਂ ਹਨ।

## Inheritance

```csharp
public class Animal
{
    public string Name { get; set; }
    public virtual string MakeSound() => "some sound";   // virtual — can be overridden
}

public class Dog : Animal     // Dog inherits from Animal (single inheritance)
{
    public override string MakeSound() => "Woof";        // OVERRIDE the base method
    public void Fetch() => Console.WriteLine("fetching");
}

var dog = new Dog { Name = "Rex" };
dog.Name;          // inherited from Animal
dog.MakeSound();    // "Woof"
```

ਇੱਕ ਡੈਰਾਈਵਡ ਕਲਾਸ (`Dog : Animal`) ਬੇਸ ਕਲਾਸ ਦੇ ਮੈਂਬਰਜ਼ ਨੂੰ ਮਿਰਾਸ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ ਅਤੇ ਆਪਣੇ ਆਪ ਨੂੰ ਜੋੜ ਸਕਦੀ ਹੈ। C# **ਸਿੰਗਲ ਇਨਹੈਰਿਟੈਂਸ** ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ (ਇੱਕ ਬੇਸ ਕਲਾਸ)। `base.Method()` ਬੇਸ ਇਮਪਲੀਮੈਂਟੇਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ।

## Polymorphism — virtual / override

```csharp
// treat different derived types through the base type; the ACTUAL type's method runs
List<Animal> animals = new() { new Dog(), new Cat() };
foreach (Animal a in animals)
    Console.WriteLine(a.MakeSound());   // "Woof", "Meow" — runtime dispatch
```

**Polymorphism**: ਇੱਕ `virtual` ਮੈਥਡ ਜੋ ਡੈਰਾਈਵਡ ਕਲਾਸਾਂ ਵਿੱਚ ਓਵਰਰਾਈਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਉਹ **ਰਨਟਾਈਮ** ਉੱਤੇ ਆਬਜੈਕਟ ਦੀ ਅਸਲ ਕਿਸਮ ਦੇ ਆਧਾਰ ਉੱਤੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ — ਇਸ ਲਈ ਇੱਕੋ ਕਾਲ (`a.MakeSound()`) ਪ੍ਰਤਿ ਕਿਸਮ ਵੱਖ-ਵੱਖ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਲਚਕਦਾਰ, ਵਿਸਤ੍ਰਿਤ ਕੋਡ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ (ਬਹੁਤ ਸਾਰੀ ਕਿਸਮਾਂ ਨੂੰ ਇਕਸਾਰ ਢੰਗ ਨਾਲ ਹਲ ਕਰਨਾ)।

## Abstract classes ਅਤੇ sealed

```csharp
public abstract class Shape
{
    public abstract double Area();        // abstract — derived MUST implement, no body
    public string Describe() => $"Area: {Area()}";   // concrete shared method
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
// var s = new Shape();   // ❌ can't instantiate an abstract class

public sealed class Final { }   // sealed — cannot be inherited from
```

**Abstract classes** ਇੱਕ ਅੰਸ਼ਕ ਬੇਸ (ਅਮੂਰਤ ਮੈਥਡਾਂ ਦੇ ਨਾਲ ਜੋ ਸਬ-ਕਲਾਸਾਂ ਨੂੰ ਲਾਗੂ ਕਰਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ ਅਤੇ ਸਾਂਝੇ ਕੋਡ) ਪ੍ਰਬੰਧਿਤ ਕਰਦੀਆਂ ਹਨ; `sealed` ਅਤਿਰਿਕਤ ਵਿਰਾਸਤ ਨੂੰ ਰੋਕਦਾ ਹੈ।

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰੱਖਦਾ ਹੈ

Inheritance ਅਤੇ polymorphism C# ਵਿੱਚ ਮੂਲ OOP ਵਿਧੀਆਂ ਹਨ, ਆਬਜੈਕਟ-ਓਨਾ ਖੰਡ ਡਿਜ਼ਾਈਨ ਲਈ ਬੁਨਿਆਦੀ ਅਤੇ .NET ਫ਼ਰੇਮਵਰਕ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ (ਜੋ ਉਹਨਾਂ ਦੀ ਬਹੁਤ ਵਰਤੋਂ ਕਰਦਾ ਹੈ), ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ। **Inheritance** "is-a" ਸਬੰਧਾਂ ਦੁਆਰਾ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ (ਇੱਕ Dog ਇੱਕ Animal ਹੈ), ਹਾਲਾਂਕਿ C# ਸਿਰਫ਼ ਸਿੰਗਲ ਇਨਹੈਰਿਟੈਂਸ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। **Polymorphism** — `virtual`/`override` ਅਤੇ ਰਨਟਾਈਮ ਮੈਥਡ ਡਿਸਪੈਚ ਦੁਆਰਾ — ਵਿਸ਼ੇਸ਼ ਤੌਰ ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਇਹ ਤੁਹਾਨੂੰ ਵੱਖ-ਵੱਖ ਡੈਰਾਈਵਡ ਕਿਸਮਾਂ ਨੂੰ ਇੱਕ ਬੇਸ ਟਾਈਪ ਦੁਆਰਾ ਇਕਸਾਰ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਸਠੀਕ ਕਿਸਮ-ਖਾਸ ਵਿਵਹਾਰ ਆਪਣਆਪ ਚਲਦਾ ਹੈ, ਲਚਕਦਾਰ, ਵਿਸਤ੍ਰਿਤ ਡਿਜ਼ਾਈਨ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ (ਵੱਖ-ਵੱਖ ਆਕਾਰਾਂ ਦਾ ਇੱਕ ਸੰਗ੍ਰਹਿ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ, ਹਰ ਇੱਕ ਇਸ ਦੇ ਆਪਣੇ ਖੇਤਰ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ)।

`virtual`/`override` ਵਿਧੀ ਨੂੰ ਸਮਝਣਾ (ਬੇਸ ਇੱਕ ਮੈਥਡ ਨੂੰ ਓਵਰਰਾਈਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਇਸ ਤਰ੍ਹਾਂ ਚਿੰਨਾਂਕਤ ਕਰਦਾ ਹੈ, ਡੈਰਾਈਵਡ ਕਲਾਸਾਂ ਇਸ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਰਨਟਾਈਮ ਅਸਲ ਟਾਈਪ ਦੇ ਸੰਸਕਰਣ ਵਿਚਲੇ ਭੇਜਦਾ ਹੈ), **abstract classes** (ਅੰਸ਼ਕ ਬੇਸ ਜਿਸ ਵਿੱਚ ਮੈਥਡ ਸਬ-ਕਲਾਸਾਂ ਨੂੰ ਲਾਗੂ ਕਰਣੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਸਾਂਝਾ ਕੋਡ), ਅਤੇ `sealed` (ਵਿਰਾਸਤ ਨੂੰ ਰੋਕਣਾ) ਕਲਾਸ ਮਤਲਬ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਅਤੇ ਇਹ ਸਮਝਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ .NET ਫ਼ਰੇਮਵਰਕ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਕਿਵੇਂ ਢਾਂਚਾਗਤ ਹਨ।

ਕਿਉਂਕਿ inheritance ਅਤੇ polymorphism ਆਬਜੈਕਟ-ਓਨਾ ਖੰਡ C# ਅਤੇ ਫ਼ਰੇਮਵਰਕ ਦੇ ਆਪ ਨੂੰ ਅੰਡਪਿੰਨ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਰਨਟਾਈਮ polymorphism ਵਿਸਤ੍ਰਿਤ, ਸਾਂਭਾ ਰੱਖਣਯੋਗ ਕੋਡ ਦਾ ਇੱਕ ਮੂਲ ਸਮਰਥ ਹੈ, ਆਪਣ ਨੂੰ ਮਾਸਟਰ ਕਰਨਾ — ਖਾਸ ਕਰਕੇ virtual/override dispatch ਜੋ polymorphism ਨੂੰ ਕੰਮ ਕਰ ਦੇਵਦਾ ਹੈ — C# ਵਿੱਚ ਆਬਜੈਕਟ-ਓਨਾ ਖੰਡ ਡਿਜ਼ਾਈਨ ਲਈ ਮਹੱਤਵਪੂਰਨ, ਬਾਰ-ਬਾਰ-ਪ੍ਰਯੁਕਤ ਗਿਆਨ ਹੈ, ਅਤੇ ਇੱਕ ਆਮ ਇੰਟਰਵਿਊ ਵਿਸ਼ਾ ਹੈ ਜੋ OOP ਬੁਨਿਆਦ ਦੀ ਸਮਝ ਨੂੰ ਪ੍ਰਕਟ ਕਰਦਾ ਹੈ।