Bagaimana cara struct embedding (komposisi) bekerja?

Question

Accepted Answer

Go **tidak memiliki inheritance** — sebaliknya ia menggunakan **komposisi** melalui struct embedding. Dengan menyematkan satu struct (atau interface) di dalam struct lainnya, tipe outer mendapatkan akses langsung ke field dan method tipe inner. Ini adalah jawaban Go untuk code reuse, lebih memilih komposisi "has-a" daripada inheritance "is-a".

## Menyematkan struct

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

Embedding (menulis hanya nama tipe, tanpa nama field) **mempromosikan** field dan method tipe embedded ke struct outer — sehingga `d.Name` dan `d.Eat()` bekerja seolah-olah mereka milik `Dog`. Ini terlihat seperti inheritance tetapi adalah komposisi: `Dog` *memiliki* `Animal`.

## Override method yang dipromosikan

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

Tipe outer dapat mendefinisikan method dengan nama yang sama untuk "override" (menyamarkan) yang dipromosikan; Anda masih dapat mengakses versi embedded secara eksplisit.

## Menyematkan interface (sangat umum)

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

Interface embedding mengkomposisi interface kecil menjadi interface yang lebih besar — digunakan di seluruh standard library.

## Komposisi daripada inheritance — filosofi Go

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

## Mengapa ini penting

Struct embedding adalah mekanisme khas Go untuk **code reuse dan komposisi**, menggantikan inheritance yang ditemukan di sebagian besar bahasa OOP.

Memahaminya sangat penting karena ini adalah cara Go mencapai reuse (mempromosikan field/method embedded sehingga tipe outer "mewarisi" behavior melalui komposisi) sambil dengan sengaja menghindari masalah inheritance yang terkenal (fragile base classes, hierarki dalam yang rigid, tight coupling).

Ini mewujudkan prinsip yang luas didukung **"komposisi daripada inheritance."** Embedding muncul terus-menerus — menyematkan struct untuk reuse, menyematkan interface untuk membangun kontrak yang lebih besar (seperti `io.ReadWriter`), dan embedding untuk perilaku gaya mixin.

Mengenali bahwa Go tidak memiliki inheritance dan bahwa embedding adalah alternatif komposisionalnya — ditambah aturan method-promotion dan shadowing — adalah fundamental untuk membaca dan mendesain Go yang idiomatic, dan topik interview umum mengingat perbedaannya dari bahasa berbasis class.