Struct embedding (composition) کیسے کام کرتی ہے؟

Question

Accepted Answer

Go میں **کوئی inheritance نہیں ہے** — اس کی بجائے یہ **composition** استعمال کرتا ہے struct embedding کے ذریعے۔ ایک struct (یا interface) کو دوسرے کے اندر embed کرکے، بیرونی type کو اندرونی type کے fields اور methods براہ راست ملتے ہیں۔ یہ Go کا code reuse کا جواب ہے، جو "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 کا نام نہیں) بیرونی struct کو embedded type کے **fields اور methods کو 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 اسی نام کا method define کر سکتا ہے تاکہ promoted کو "override" (shadow) کرے؛ آپ ابھی بھی embedded version کو explicitly رسائی حاصل کر سکتے ہیں۔

## 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 کو بڑے میں compose کرتا ہے — standard library میں ہر جگہ استعمال ہوتا ہے۔

## Composition over inheritance — Go کی philosophy

```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 Go کا distinctive mechanism ہے **code reuse اور composition** کے لیے، جو زیادہ تر OOP languages میں inheritance کو بدل دیتا ہے۔

اس کو سمجھنا ضروری ہے کیونکہ یہ وہ ہے جس سے Go reuse حاصل کرتا ہے (embedded fields/methods کو promote کرتے ہوئے تاکہ outer type composition کے ذریعے رویہ "inherit" کرے) اور جان بوجھ کر inheritance کے معروف مسائل سے بچتا ہے (fragile base classes، گہری سخت hierarchies، مضبوط coupling)۔

یہ وسیع پیمانے پر قبول شدہ principle **"composition over inheritance"** کو ظاہر کرتا ہے۔ Embedding ہمہ وقت نظر آتا ہے — reuse کے لیے structs کو embed کرنا، بڑے contracts بنانے کے لیے interfaces کو embed کرنا (جیسے `io.ReadWriter`)، اور mixin-style رویے کے لیے embed کرنا۔

یہ سمجھنا کہ Go میں کوئی inheritance نہیں ہے اور embedding اس کا compositional متبادل ہے — ساتھ ہی method-promotion اور shadowing rules — idiomatic Go کو پڑھنے اور ڈیزائن کرنے کے لیے بنیادی ہے، اور class-based languages سے اس کے فرق کی وجہ سے ایک عام interview topic ہے۔