Struct embedding (composition) hufanya kazi vipi?

Question

Accepted Answer

Go **haina inheritance** — badala yake hutumia **composition** kupitia struct embedding. Kwa kuingiza struct moja (au interface) ndani ya nyingine, aina ya nje hupata fields na methods za aina ya ndani moja kwa moja. Hii ni jibu la Go kwa matumizi tena ya msimbo, ikipendelea composition ya "ina-kitu" badala ya inheritance ya "ni-kitu."

## Kuingiza 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 (kuandika jina la aina tu, bila jina la field) **hukuza** fields na methods za aina iliyoingizwa hadi struct ya nje — hivyo `d.Name` na `d.Eat()` hufanya kazi kana kwamba ni za `Dog`. Hii huonekana kama inheritance lakini ni composition: `Dog` *ina* `Animal`.

## Kubatilisha methods zilizokuzwa

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

Aina ya nje inaweza kufafanua method yenye jina lile lile ili "kubatilisha" (kuficha) ile iliyokuzwa; bado unaweza kufikia toleo lililoingizwa wazi.

## Kuingiza interfaces (kawaida sana)

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

Kuingiza interface huunganisha interfaces ndogo kuwa kubwa zaidi — hutumika katika maktaba yote ya kawaida.

## Composition kuliko inheritance — falsafa ya 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
```

## Kwa nini ni muhimu

Struct embedding ni mbinu bainifu ya Go ya **matumizi tena ya msimbo na composition**, ikibadilisha inheritance inayopatikana katika lugha nyingi za OOP.

Kuielewa ni muhimu kwa sababu ndiyo namna Go inavyofikia matumizi tena (kukuza fields/methods zilizoingizwa ili aina ya nje "i-rithi" tabia kupitia composition) huku ikiepuka kwa makusudi matatizo yanayojulikana ya inheritance (base classes dhaifu, hierarki za kina, zilizo ngumu, kufungamana sana).

Inajumuisha kanuni inayoungwa mkono sana **"composition kuliko inheritance."** Embedding huonekana mara kwa mara — kuingiza structs kwa matumizi tena, kuingiza interfaces kujenga mikataba mikubwa zaidi (kama `io.ReadWriter`), na kuingiza kwa tabia ya mtindo wa mixin.

Kutambua kwamba Go haina inheritance na kwamba embedding ni mbadala wake wa kicompositional — pamoja na kanuni za ukuzaji-method na ufichaji — ni msingi wa kusoma na kubuni Go ya kiidiomatiki, na ni mada ya kawaida ya mahojiano kwa kuzingatia jinsi inavyotofautiana na lugha zinazotegemea class.