Si funksionojnë trashëgimia dhe super()?

Question

Accepted Answer

**Trashëgimia** lejon një klasë të rrjedh nga një tjetër, duke riherzuar dhe zgjeruar sjelljen e saj. **`super()`** thërret metodat e klasës prind. Python suporton **trashëgiminë e shumëfishtë**, e zgjidhur nga **MRO** (Method Resolution Order).

## Trashëgimia dhe super() bazike

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call the parent's __init__ (reuse its logic)
        self.breed = breed
    def speak(self):                 # OVERRIDE the parent method
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (set by Animal via super())
d.speak()   # "Woof" (Dog's override)
```

`super()` lejon një nënklasë të nxisë sjelljen e klasës prind — thelbësore në `__init__` për të ekzekutuar konfigurimin e prindit dhe për të zgjeruar (jo vetëm zëvendësuar) metodat e mbivendosura.

## Zgjerimi vs mbivendosja e plotë

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # call parent, then ADD to it
        return f"{base} ... Meow"
```

## Trashëgimia e shumëfishtë dhe MRO

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                       # inherits from BOTH B and C
    pass

D().greet()       # "B" — found via the MRO
D.__mro__         # (D, B, C, A, object) — the search order
```

Me trashëgiminë e shumëfishtë, Python kërkon metoda në një rend të linearizuar specifik — **MRO**, i llogaritur nga algoritmi C3. `D.__mro__` e tregon atë; `super()` e ndjek atë. MRO siguron që çdo klasë vizitohet një herë dhe prindërit vijnë pas fëmijëve, duke zgjidhur "diamond problem" në mënyrë të parashikueshme.

## super() ndjek MRO (jo vetëm prindin literal)

```python
# in cooperative multiple inheritance, super() goes to the NEXT class in the MRO,
# not necessarily the "parent" — enabling mixins to chain correctly
```

## Pse është e rëndësishme

Trashëgimia dhe `super()` janë mjete bazë OOP për riherzimin dhe zgjerimin e sjelljes, të përdorur në të gjithë kornizat Python (p.sh. nënklasimi i modeleve Django, hierarkitë e përjashtimeve).

Kuptuesi i `super()` (thjerrja e logjikës prind, veçanërisht në `__init__`) dhe **MRO** është veçanërisht e rëndësishme në Python sepse suporton **trashëgiminë e shumëfishtë** — MRO është ajo që e bën rezolucionin e metodave dhe zinxhirët `super()` të parashikueshëm në hierarkitë komplekse dhe miksime.

Dija e mënyrës se si funksionon MRO (dhe se `super()` e ndjek atë) parandalon konfuzionin në modelet me formë diamanti ose të bazuara në miksime që janë të zakonshme në bazat e kodit Python reale.