Struct embedding (composition) nasıl çalışır?

Question

Accepted Answer

Go'da **kalıtım yoktur** — bunun yerine **composition** struct embedding yoluyla kullanılır. Bir struct'ı (veya interface'i) başka bir struct'ın içine yerleştirerek, dış tip iç tip'in alanlarını ve yöntemlerini doğrudan kazanır. Bu, Go'nun kod yeniden kullanımına verdiği cevap olup, "is-a" kalıtımı yerine "has-a" composition'ını tercih eder.

## Struct embedding

```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 (sadece tür adı yazma, alan adı yok) iç tip'in alanlarını ve yöntemlerini dış struct'a **tanıtır** — böylece `d.Name` ve `d.Eat()` sanki `Dog`'a ait gibi çalışır. Bu kalıtıma benziyor olsa da composition'dur: `Dog` *bir* `Animal` *içerir*.

## Tanıtılan yöntemleri geçersiz kılma

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

Dış tip, tanıtılan yöntemi "geçersiz kılmak" (gölgelemek) için aynı ada sahip bir yöntem tanımlayabilir; yine de embedded sürüme açıkça erişebilirsiniz.

## Interface embedding (çok yaygın)

```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 küçük interface'leri daha büyük olanlar içine oluşturur — standart kütüphanenin tamamında kullanılır.

## Composition kalıtımı yerine — Go felsefesi

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

## Neden önemli

Struct embedding, Go'nun **kod yeniden kullanımı ve composition** için ayırt edici mekanizmasıdır ve çoğu OOP dilinde bulunan kalıtımın yerini alır.
/*Bunu anlamak çok önemlidir çünkü Go, kalıtımın iyi bilinen sorunlarından (kırılgan temel sınıflar, derin katı hiyerarşiler, sıkı bağ) kaçınırken, tanıtılan alanlar/yöntemleri kullanarak kod yeniden kullanımını (dış tip'in composition aracılığıyla davranış "miras aldığı" şekilde) nasıl başardığıdır.

Bu, yaygın olarak kabul edilen **"composition kalıtımı yerine"** ilkesini somutlaştırır. Embedding her yerde görünür — struct embedding kodu yeniden kullanmak için, interface embedding daha büyük sözleşmeler oluşturmak için (mesela `io.ReadWriter` gibi) ve mixin benzeri davranış için embedding yapılır.

Go'da kalıtım olmadığını ve embedding'in onun compositional alternatifi olduğunu tanımak — ayrıca method-promotion ve shadowing kuralları — idiomatic Go'yu okumak ve tasarlamak için temel niteliktedir ve sınıf tabanlı dillerden farklı olması nedeniyle yaygın bir mülakat konusudur.