Conas a oibríonn leabú strucht (comhdhéanamh)?

Question

Accepted Answer

Níl **oidhreachta** ag Go — ina ionad sin úsáideann sé **comhdhéanamh** trí leabú strucht. Trí strucht (nó comhéadan) amháin a leabú taobh istigh de strucht eile, faigheann an cineál seachtrach réimsí agus modhanna an chineáil istigh go díreach. Is é seo freagra Go ar athúsáid chóid, ag tabhairt fearr do chomhdhéanamh "has-a" os cionn oidhreachta "is-a".

## Strucht a leabú

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

Leabú (dreach a scríobh ar an enw cineáil, gan ainm réimse) **thúchtaithe** réimsí agus modhanna an chineáil leabaithe go dtí an strucht seachtrach — ionas go n-oibríonn `d.Name` agus `d.Eat()` go bhfuil siad ina mbaineann do `Dog`. Féachann sé sin cosúil le hoidhreachta ach is comhdhéanamh a bhíonn ann: tá `Dog` *ag an* `Animal`.

## Modhanna thúchtaithe a fhorscáil

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

Is féidir leis an gcineál seachtrach modh a shainiú leis an ainm céanna a chur "i bhfoluain" (foluain) ar an gceann thúchtaithe; is féidir leat an leagan leabaithe a bhaint amach go soiléir fós.

## Comhéadain a leabú (an-coitianta)

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

Cumhneachán leabú comhéadain bheag i gcomhéadain níos mó — úsáidte ar fud an leabharlann caighdeánach.

## Comhdhéanamh os cionn oidhreachta — fealsuneacht 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
```

## Cén fáth a bhíonn sé tábhachtach

Is é leabú strucht méanacán Go ar leith do **athúsáid chóid agus comhdhéanamh**, ag socrú in ionad an oidhreachta a fhaightear i mór-chuid teangacha OOP.

Tá sé riachtanach a thuiscint toisc gur é an chaoi ar a bhhaineann Go athúsáid a bhaint amach (réimsí agus modhanna leabaithe á dtúchtú ionas go bhfuigheann an cineál seachtrach iompar tríd an comhdhéanamh) agus ar an bhféinmhian a sheachaint oidhreachta dhílúthaithe (struchtúir bhonn bhriste, ordlathachtaí doimhne agus righin, cuplúchán dlúth).

Taispeáint a dhéanann sé an phrionsabal tuairiscithe go fán **"comhdhéanamh os cionn oidhreachta."** Leabú a fhéachann go minic — leabú struchtúir do athúsáid, comhéadain a leabú chun conarthaí níos mó a thógáil (cosúil le `io.ReadWriter`), agus leabú do dhruim-stíl iompar.

Aithint a bhaint go bhfuil oidhreachta as Go agus gur leabú is comhdhéanamh a bhíonn ann — agus na rialacha maidir le modhanna-túchtú agus foluain — is bunúsach do léamh agus dearadh Go idiomatic, agus is ábhar coitianta agallamh é toisc an difríochta ó theangacha ar bhunús ranganna.