inheritance और polymorphism कैसे काम करते हैं?

Question

Accepted Answer

**Inheritance** एक class को एक base class से derive करने देता है, उसके members को reuse और extend करते हुए। **Polymorphism** आपको derived objects को एक base type के through treat करने देता है, जहाँ सही overridden method runtime पर call होती है (`virtual`/`override` के माध्यम से)। ये C# में core OOP mechanisms हैं।

## 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"
```

एक derived class (`Dog : Animal`) base के members को inherit करती है और अपने जोड़ सकती है। C# **single inheritance** का समर्थन करता है (एक base class)। `base.Method()` base implementation को call करता है।

## 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` method जो derived classes में overridden है, object के actual type के आधार पर **runtime** पर dispatch होती है — इसलिए एक ही call (`a.MakeSound()`) प्रति type अलग चीज़ें करता है। यह flexible, extensible code सक्षम करता है (कई types को uniformly handle करना)।

## 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** एक partial base define करती हैं (abstract methods के साथ जिन्हें subclasses को implement करना होता है प्लस shared code); `sealed` आगे की inheritance को रोकता है।

## यह क्यों महत्वपूर्ण है

Inheritance और polymorphism C# में core OOP mechanisms हैं, object-oriented design और .NET framework के साथ काम करने (जो उनका व्यापक उपयोग करता है) के लिए मूलभूत हैं, इसलिए उन्हें समझना आवश्यक है। **Inheritance** "is-a" संबंधों के माध्यम से code reuse प्रदान करता है (एक Dog एक Animal है), हालांकि C# केवल single inheritance की अनुमति देता है। **Polymorphism** — `virtual`/`override` और runtime method dispatch के माध्यम से — विशेष रूप से महत्वपूर्ण है: यह आपको अलग derived types को एक base type के through uniformly treat करने देता है जबकि सही type-specific behavior automatically चलता है, flexible, extensible designs सक्षम करते हुए (अलग shapes के एक collection को process करना, प्रत्येक अपना area compute करता हुआ)।

`virtual`/`override` mechanism (base एक method को overridable mark करता है, derived classes उसे override करती हैं, और runtime actual type के version पर dispatch करता है), **abstract classes** (partial bases उन methods के साथ जिन्हें subclasses को implement करना होता है प्लस shared code), और `sealed` (inheritance को रोकना) को समझना class hierarchies design करने और यह समझने के लिए आवश्यक है कि .NET framework व libraries कैसे संरचित हैं।

चूंकि inheritance और polymorphism object-oriented C# और framework को रेखांकित करते हैं, और चूंकि runtime polymorphism extensible, maintainable code का एक प्रमुख सक्षमकर्ता है, इनमें महारत हासिल करना — विशेष रूप से virtual/override dispatch जो polymorphism को काम करने योग्य बनाता है — C# में object-oriented design के लिए महत्वपूर्ण, बार-बार-लागू होने वाला ज्ञान है, और एक सामान्य interview विषय है जो OOP fundamentals की समझ को प्रकट करता है।