Apakah masalah berlian dalam warisan berbilang?

Question

Accepted Answer

**Masalah berlian** timbul apabila kelas mewarisi daripada dua kelas yang berkongsi nenek moyang bersama, menciptakan keambiguan: jika kedua-dua kelas tengah mengatasi kaedah (atau memegang medan), versi mana yang diperoleh kelas bawah?

## Berlian

```text
        A  (defines greet())
       / \
      B   C   (each may override greet())
       \ /
        D   ← inherits from B and C: which greet()?
```

## Dalam Python (yang membenarkan warisan berbilang)

```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):                  # multiple inheritance
    pass

print(D().greet())             # "B"  — resolved by MRO, not ambiguous
print(D.__mro__)               # D → B → C → A → object  (C3 linearization)
```

Python menyelesaikannya secara deterministik melalui **Tertib Resolusi Kaedah (MRO)** menggunakan linearisasi C3, dan `super()` bekerjasama dengan perintah itu.

## Cara bahasa menanganinya

| Bahasa | Pendekatan |
|---|---|
| C++ | Membenarkannya; keambiguan adalah ralat kompilasi melainkan anda layak atau menggunakan `virtual` warisan untuk berkongsi satu asas |
| Java/C# | **Melarang** warisan berbilang kelas; membenarkan warisan berbilang *antara muka* (tiada keadaan, jadi tiada berlian data) |
| Python | Membenarkannya; menyelesai melalui MRO (C3) |
| Scala | **Traits** dengan tertib linearisasi yang ditakrifkan |

## Jebakan

Walaupun dengan MRO, warisan berbilang bagi *keadaan* menjadi keliru dengan cepat — permulaan asas berganda, rantai `super()` yang mengejutkan. Antara muka/traits (tingkah laku, bukan keadaan) mengelak kebanyakan kesakitan.

## Mengapa ini penting

Ia menjelaskan garpu reka bentuk bahasa utama: Java dan C# melarang warisan berbilang kelas secara khusus untuk mengelak keambiguan ini, menawarkan antara muka sebaliknya.

Memahami MRO adalah praktikal dalam Python: `super()` yang kooperatif dan perintah mixin hanya masuk akal sebaik sahaja anda melihat bagaimana berlian itu dilinearkan.

Bahasa	Pendekatan
C++	Membenarkannya; keambiguan adalah ralat kompilasi melainkan anda layak atau menggunakan `virtual` warisan untuk berkongsi satu asas
Java/C#	Melarang warisan berbilang kelas; membenarkan warisan berbilang antara muka (tiada keadaan, jadi tiada berlian data)
Python	Membenarkannya; menyelesai melalui MRO (C3)
Scala	Traits dengan tertib linearisasi yang ditakrifkan