struct embedding (composition) कैसे काम करता है?

Question

Accepted Answer

Go में **कोई inheritance नहीं** है — इसके बजाय यह struct embedding के माध्यम से **composition** का उपयोग करता है। एक struct (या interface) को दूसरे के अंदर embed करके, बाहरी type को भीतरी type के fields और methods सीधे मिल जाते हैं। यह code reuse के लिए Go का उत्तर है, जो "is-a" inheritance पर "has-a" composition को प्राथमिकता देता है।

## एक struct को embed करना

```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 (सिर्फ़ type नाम लिखना, कोई field नाम नहीं) embedded type के fields और methods को बाहरी struct में **promote** करता है — इसलिए `d.Name` और `d.Eat()` ऐसे काम करते हैं मानो वे `Dog` के हों। यह inheritance जैसा दिखता है लेकिन है composition: `Dog` के *पास एक* `Animal` है।

## promoted methods को override करना

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

बाहरी type promoted method को "override" (shadow) करने के लिए उसी नाम का एक method परिभाषित कर सकता है; आप अभी भी embedded संस्करण तक स्पष्ट रूप से पहुँच सकते हैं।

## interfaces को embed करना (बहुत आम)

```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 छोटे interfaces को बड़े interfaces में compose करता है — पूरी standard library में उपयोग होता है।

## composition over inheritance — 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
```

## यह क्यों महत्वपूर्ण है

Struct embedding **code reuse और composition** के लिए Go का विशिष्ट तंत्र है, जो अधिकांश OOP भाषाओं में पाए जाने वाले inheritance की जगह लेता है।

इसे समझना आवश्यक है क्योंकि Go इसी तरह reuse प्राप्त करता है (embedded fields/methods को promote करना ताकि बाहरी type composition के माध्यम से व्यवहार "inherit" करे) जबकि जानबूझकर inheritance की प्रसिद्ध समस्याओं (fragile base classes, गहरे कठोर hierarchies, tight coupling) से बचता है।

यह व्यापक रूप से समर्थित सिद्धांत **"composition over inheritance"** को मूर्त रूप देता है। Embedding लगातार दिखता है — reuse के लिए structs को embed करना, बड़े contracts बनाने के लिए interfaces को embed करना (जैसे `io.ReadWriter`), और mixin-शैली व्यवहार के लिए embed करना।

यह पहचानना कि Go में कोई inheritance नहीं है और embedding इसका compositional विकल्प है — साथ ही method-promotion और shadowing नियम — idiomatic Go को पढ़ने और design करने के लिए बुनियादी है, और एक आम interview विषय है क्योंकि यह class-based भाषाओं से कितना भिन्न है।