Piye cara embedding struct (composition) bisa gawé?

Question

Accepted Answer

Go **ora duwe inheritance** — sing digunakake yaiku **composition** liwat embedding struct. Kanthi embed siji struct (utawa interface) ing struktur liyane, tipe saka njaba bakal entuk fields lan methods saka tipe sing jero langsung. Iki jawabe Go kanggo ngulang-ngulang code, luwih seneng "has-a" composition tinimbang "is-a" inheritance.

## Embedding 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 (nulis mung jeneng tipe, ora ana jeneng field) **promote** fields lan methods saka tipe sing embed menyang struct saka njaba — dadi `d.Name` lan `d.Eat()` bisa gawé parang dadi milik `Dog`. Iki katon kaya inheritance nanging yaiku composition: `Dog` *duwe* `Animal`.

## Override promoted methods

```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 saka njaba bisa nulis method karo jeneng sing padha kanggo "shadow" metode sing promote; isih iso kanggo nyambung versi embed kanthi jelas.

## Embedding interfaces (umum tenan)

```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)
```

Embedding interface nggabung interface cilik dadi interface sing luwih gedhe — digunakake ing saindro standard library.

## Composition over 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
```

## Kenapakno penting

Embedding struct yaiku cara Go sing khas kanggo **ngulang code lan composition**, ngganti inheritance sing ana ing umume bahasa OOP.

Mangerteni iki penting amarga iki carane Go entuk ngulang (promote fields/methods sing embed supaya tipe saka njaba "wrisan" tingkah liwat composition) lan kanthi sengaja ngilangake masalah sing kaya inheritance ngiket (base class sing rapuh, hirarki cukup miri, tight coupling).

Iki ngetutake prinsip sing katampa akeh **"composition over inheritance."** Embedding munculna terus — embedding struct kanggo ngulang, embedding interface kanggo bangun kontrak sing luwih gedhe (kaya `io.ReadWriter`), lan embedding kanggo tingkah gaya mixin.

Mangerteni yen Go ora duwe inheritance lan yen embedding yaiku alternatif composisionale — plus rules kanggo promote lan shadow method — penting kanggo maca lan nglaku Go, lan topik interview sing umum amarga beda karo bahasa sing adhedhasar class.