როგორ მუშაობს მემკვიდრეობა და პოლიმორფიზმი?

Question

Accepted Answer

**მემკვიდრეობა** საშუალებას აძლევს კლასს მემკვიდრე კლასი, რომელიც აღემატება ბაზის კლასს, გადამეს და გააფართოვოს მისი წევრები. **პოლიმორფიზმი** საშუალებას აძლევს მემკვიდრე ობიექტებს განიხილოთ ბაზის ტიპის მাშინ, სწორი გადაფარვილი მეთოდი რეჟიმში ეწოდება (via `virtual`/`override`). ეს ძირითადი OOP მექანიზმებია C#-ში.

## მემკვიდრეობა

```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()` ამოძახებს ბაზის განხორციელებას.

## პოლიმორფიზმი — 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
```

**პოლიმორფიზმი**: `virtual` მეთოდი, რომელიც გადაფარულია მემკვიდრე კლასებში, იშლება **რეჟიმში** ობიექტის ფაქტიკური ტიპის საფუძველზე — ამიტომ იგივე ზარი (`a.MakeSound()`) სხვადსხვა თავდა აკეთებს ტიპის მიხედვით. ეს სთავაზობს მოქნილ, ფართოდან კოდს (დამუშავება მრავალი ტიპები ერთგვარი).

## აბსტრაქტული კლასები და 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
```

**აბსტრაქტული კლასები** განსაზღვრავენ ნაწილობრივ ბაზას (აბსტრაქტული მეთოდებით, რომლებიც ქვეკლასებმა უნდა განახორციელონ და გაზიარებული კოდი); `sealed` ხელი შეუშლის შემდგომ მემკვიდრეობას.

## რატომ აქვს მნიშვნელობა

მემკვიდრეობა და პოლიმორფიზმი არის ძირითადი OOP მექანიზმები C#-ში, ფундამენტური ობიექტზე ორიენტირებული დიზაინისთვის და .NET ჩარჩოს (რომელიც ფართოდ იყენებს მათ) გაგებით, ამიტომ მათი გაგება აუცილებელია. **მემკვიდრეობა** უზრუნველყოფს კოდის გამოყენებას "is-a" ურთიერთობის მাშინ (ძაღლი არის ცხოველი), თუმცა C# დაშვებულია მხოლოდ ერთი მემკვიდრეობა. **პოლიმორფიზმი** — `virtual`/`override` და რეჟიმი მეთოდის დისპეტჩის მაშინ — განსაკუთრებით მნიშვნელოვანია: ის საშუალებას აძლევს სხვადსხვა მემკვიდრე ტიპებს ერთეულად განიხილოთ ბაზის ტიპის მაშინ, სწორი ტიპიის სპეციფიკური ქცევა ავტომატურად შესრულებული, ფართოდან დიზაინების (პროცესი სხვადსხვა ფორმების კოლექცია, თითოეული გამოთვლაა თავისი ტერიტორია).

`virtual`/`override` მექანიზმის გაგება (ბაზა მენიშვნელი მეთოდი გადაწერადი, მემკვიდრე კლასები გადაწერენ მას, და რეჟიმი დისპეტჩებს ფაქტიკური ტიპის ვერსიას), **აბსტრაქტული კლასები** (ნაწილობრივი ბაზა მეთოდებით ქვეკლასებმა უნდა განახორციელონ და გაზიარებული კოდი), და `sealed` (მემკვიდრეობის ხელი შეუშლა) აუცილებელია კლასის იერარქიის დიზაინის და .NET ჩარჩოს თუ როგორ არის სტრუქტურირებული ბიბლიოთეკების გაგებისთვის.

მემკვიდრეობა და პოლიმორფიზმი ქვესფეროში ობიექტზე ორიენტირებული C# და ჩარჩო, და ვინაიდან რეჟიმი პოლიმორფიზმი არის ძირითადი ფართოდან, მართავდნენი კოდის მკვლელი, დაუფლება ეს — განსაკუთრებით virtual/override დისპეტჩი, რომელიც პოლიმორფიზმი მუშაობს — მნიშვნელოვანი, ხშირად გამოყენებული ცოდნა ობიექტზე ორიენტირებული დიზაინის C#-ში, და ჩვეულებრივი ინტერვიუ თემა, რომელიც ამჟღავნებს OOP ფუნდამენტალის გაგება.