Inheritance અને polymorphism કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**Inheritance** એક વર્ગને બેઝ વર્ગમાંથી વ્યુત્પન્ન કરવા દે છે, તેના સભ્યોને પુનઃ વાપરતા અને તેમને વિસ્તૃત કરતા. **Polymorphism** તમને વ્યુત્પન્ન ઑબ્જેક્ટ્સને બેઝ પ્રકાર દ્વારા પ્રક્રિયા કરવા દે છે, જેમાં સાચું overridden method runtime પર કહેવાય છે (`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# **એકલ inheritance** (એક બેઝ વર્ગ) સમર્થન કરે છે. `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` method જે વ્યુત્પન્ન વર્ગોમાં overridden હોય તે ઑબ્જેક્ટના વાસ્તવિક પ્રકાર પર આધારે **runtime** પર dispatched થાય છે — તેથી સમાન કૉલ (`a.MakeSound()`) પ્રકાર દીઠ અલગ વસ્તુ કરે છે. આ લવચીક, વિસ્તૃત કોડ સક્ષમ કરે છે (ઘણાં પ્રકારો સમાનરૂપે પ્રક્રિયા કરો).

## Abstract વર્ગો અને 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 વર્ગો** આંશિક બેઝ વ્યાખ્યાયિત કરે છે (abstract methods સાથે જે સબક્લાસોને અમલ કરવું જોઈએ અને શેર કરેલા કોડ સાથે); `sealed` આગળ inheritance ને અટકાવે છે.

## શા માટે તે મહત્વપૂર્ણ છે

Inheritance અને polymorphism C# માં મુખ્ય OOP મિકેનિઝમ છે, object-oriented ડિઝાઇન માટે અને .NET framework સાથે કામ કરવા માટે મૌલિક છે (જે તેમનો વ્યાપક ઉપયોગ કરે છે), તેથી તેમને સમજવું આવશ્યક છે. **Inheritance** "is-a" સંબંધો દ્વારા કોડ પુનઃ વાપરણ પ્રદાન કરે છે (ડોગ એક પશુ છે), જો કે C# માત્ર એકલ inheritance ને મંજૂરી આપે છે. **Polymorphism** — `virtual`/`override` અને runtime method dispatch દ્વારા — ખાસ મહત્વપૂર્ણ છે: તે તમને વિવિધ વ્યુત્પન્ન પ્રકારોને એક બેઝ પ્રકાર દ્વારા સમાનરૂપે પ્રક્રિયા કરવા દે છે જ્યારે સાચો type-specific આચરણ આપોઆપ ચલે છે, લવચીક, વિસ્તૃત ડિઝાઇન સક્ષમ કરે છે (વિવિધ આકારોનો સંગ્રહ પ્રક્રિયા કરો, દરેક તેનો પોતાનો ક્ષેત્રફળ ગણતર કરે છે).

`virtual`/`override` મિકેનિઝમ (બેઝ method ને overridable ચિહ્નિત કરે છે, વ્યુત્પન્ન વર્ગો તેને override કરે છે, અને runtime વાસ્તવિક પ્રકારની આવૃત્તિ માટે dispatches) સમજવું, **abstract વર્ગો** (આંશિક બેઝ જેમાં methods છે જે સબક્લાસોને અમલ કરવું જોઈએ અને શેર કરેલા કોડ સાથે), અને `sealed` (inheritance અટકાવવું) વર્ગ પરંપરાઓ ડિઝાઇન કરવા માટે અને .NET framework અને libraries કેવી રીતે માળખું છે તે સમજવા માટે આવશ્યક છે.

जહીરાત inheritance અને polymorphism object-oriented C# અને framework પોતે અંતર્ગત છે, અને जહીરાત runtime polymorphism વિસ્તૃત, જાળવણીયોગ્ય કોડના મુખ્ય સક્ષમકર્તા છે, આ માસ્ટર કરવું — ખાસ virtual/override dispatch જે polymorphism કાર્યરત બનાવે છે — C# માં object-oriented ડિઝાઇન માટે મહત્વપૂર્ણ, વારંવાર લાગુ કરવામાં આવતું જ્ઞાન છે, અને સામાન્ય interview વિષય જે OOP basics ની સમજ જણાય છે.