Inheritance மற்றும் polymorphism எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Inheritance** ஒரு வகுப்பை அடிப்படை வகுப்பிலிருந்து பெறச் செய்து, அதன் உறுப்பினர்களை மீண்டும் பயன்படுத்தவும் விரிவுபடுத்தவும் அனுமதிக்கிறது. **Polymorphism** பெறப்பட்ட பொருட்களை அடிப்படை வகையின் மூலம் நடத்த அனுமதிக்கிறது, சரியான переопределённая முறை 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# **single 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` முறை **runtime** இல் பொருளின் உண்மையான வகையின் அடிப்படையில் dispatched ஆகிறது — அதாவது அதே அழைப்பு (`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** ஒரு பகுதியளவு அடிப்படை (abstract முறைகளுடன் subclasses செயல்படுத்த வேண்டும் மற்றும் பகிரப்பட்ட குறியீடு); `sealed` மேலும் inheritance ஐ தடுக்கிறது.

## ஏன் இது முக்கியமானது

Inheritance மற்றும் polymorphism C# இல் மূல OOP பদ்ধதிகள், object-oriented design இல் அடிப்படை மற்றும் .NET framework உடன் பணிபுரிய (இது அவற்றை விரிவாக பயன்படுத்துகிறது), எனவே அவற்றைப் புரிந்துகொள்வது அপরिहार्य. **Inheritance** "is-a" সম্পর்ක (ஒரு Dog என்பது ஒரு Animal) வழியாக குறியீடு पुनः பயன்பாட்டை வழங்குகிறது, இருந்தாலும் C# केवल single inheritance அனுமதிக்கிறது. **Polymorphism** — `virtual`/`override` மற்றும் runtime முறை dispatch வழியே — குறிப்பாக முக்கியமானது: இது வெவ்வேறு பெறப்பட்ட வகைகளை அடிப்படை வகையின் மூலம் சீரான முறையில் நடத்த அனுமதிக்கிறது, சரியான வகை-specific நடத்தை தானாகவே இயங்குகிறது, நমनீய, விரிவுபடுத்தக்கூடிய designs ஐ செயல்படுத்துகிறது (வெவ்வேறு shapes இன் collection ஐ செயல்படுத்தவும், ஒவ்வொன்றும் அதன் சொந்த பகுதி கணக்கிடவும்).

`virtual`/`override` பদ್ধதி (அடிப்படை ஒரு முறை переопрedefine-ஸ் செய்ய குறிப்பிடுகிறது, பெறப்பட்ட வகுப்புகள் அதை переопрedefine செய்கிறது, மற்றும் runtime உண்மையான வகையின் version இல் dispatches), **abstract classes** (பகுதியளவு அடிப்படை subclasses செயல்படுத்த வேண்டும் மற்றும் பகிரப்பட்ட குறியீடு), மற்றும் `sealed` (inheritance ஐ தடுத்தல்) பற்றிய புரிதல் வகுப்பு முறைகளை வடிவமைப்பதற்கும் .NET framework மற்றும் libraries எவ்வாறு கட்டமைக்கப்பட்டுள்ளன என்பதைப் புரிந்துகொள்வதற்கும் அপরिহार्य.

Inheritance மற்றும் polymorphism object-oriented C# மற்றும் framework ஆ விடுப்பதை அடிப்படையாகக் கொண்டுள்ளன, மற்றும் runtime polymorphism விரிவுபடுத்தக்கூடிய, கட்டுப்பாட்ட குறியீட்டின் முக்கிய enabler ஆகும், இவற்றில் தேர்ச்சி பெறுதல் — குறிப்பாக polymorphism கண்ணியமான virtual/override dispatch — முக்கியமாக, C# இல் object-oriented design க்கான அடிக்கடி பயன்படுத்தப்படும் அறிவு, மற்றும் OOP fundamentals ஐ புரிந்துகொள்வதை தெரிய வைக்கும் பொதுவான interview topic ஆகும்.