Apa itu masalah diamond dalam pewarisan berganda?

Question

Accepted Answer

**Masalah diamond** muncul ketika sebuah kelas mewarisi dari dua kelas yang berbagi nenek moyang yang sama, menciptakan ambiguitas: jika kedua kelas tengah menimpa sebuah method (atau memegang field), versi mana yang didapat kelas bawah?

## Diamond

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

## Di Python (yang memungkinkan pewarisan berganda)

```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 **Urutan Resolusi Method (MRO)** menggunakan linearisasi C3, dan `super()` bekerja sama dengan urutan tersebut.

## Bagaimana bahasa menanganinya

| Bahasa | Pendekatan |
|---|---|
| C++ | Memungkinkan; ambiguitas adalah kesalahan compile kecuali Anda mengkualifikasi, atau gunakan pewarisan `virtual` untuk berbagi satu base |
| Java/C# | **Melarang** pewarisan kelas berganda; memungkinkan *interface* berganda (tidak ada state, jadi tidak ada diamond data) |
| Python | Memungkinkan; diselesaikan melalui MRO (C3) |
| Scala | **Traits** dengan urutan linearisasi yang ditentukan |

## Jebakan

Bahkan dengan MRO, pewarisan berganda dari *state* menjadi membingungkan dengan cepat — inisialisasi base duplikat, rantai `super()` mengejutkan. Interface/traits (perilaku, bukan state) menghindari sebagian besar masalah.

## Mengapa ini penting

Ini menjelaskan percabangan desain bahasa utama: Java dan C# secara khusus melarang pewarisan kelas berganda untuk menghindari ambiguitas ini, menawarkan interface sebagai gantinya.

Memahami MRO praktis di Python: `super()` kooperatif dan urutan mixin hanya masuk akal setelah Anda melihat bagaimana diamond dilinerisasi.

Bahasa	Pendekatan
C++	Memungkinkan; ambiguitas adalah kesalahan compile kecuali Anda mengkualifikasi, atau gunakan pewarisan `virtual` untuk berbagi satu base
Java/C#	Melarang pewarisan kelas berganda; memungkinkan interface berganda (tidak ada state, jadi tidak ada diamond data)
Python	Memungkinkan; diselesaikan melalui MRO (C3)
Scala	Traits dengan urutan linearisasi yang ditentukan