Go میں interfaces کیسے کام کرتے ہیں؟

Question

Accepted Answer

Go **interface** method signatures کا ایک مجموعہ بیان کرتا ہے — رویے کا ایک معاہدہ۔ اہم بات یہ ہے کہ interfaces **طور پر implicit** مطمئن ہیں: کوئی بھی type جس کے پاس یہ methods ہوں خود بخود interface کو مطمئن کرتا ہے، **کوئی explicit "implements" declaration کے بغیر**۔ یہ structural، duck-typing approach منفرد اور طاقتور ہے۔

## Interface کو define اور implicitly implement کرنا

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

کوئی `implements` keyword نہیں ہے — اگر ایک type کے پاس interface کے تمام methods ہوں تو یہ خود بخود interface کو مطمئن کرتا ہے۔ یہ interface کو اس کے implementations سے الگ رکھتا ہے (implementer کو یہ بھی نہیں معلوم ہونا چاہیے کہ interface موجود ہے)۔

## Interfaces کے ذریعے Polymorphism

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

Interfaces polymorphism کو فعال بناتے ہیں — رویے کے خلاف کوڈ لکھیں، اور کوئی بھی matching type کام کرتا ہے۔

## Empty interface اور `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

Empty interface (`interface{}` / `any`) کوئی بھی value رکھ سکتا ہے — استعمال ہوتا ہے جب type پہلے سے معلوم نہ ہو (اگرچہ generics اب اکثر اس کی جگہ لیتے ہیں)۔

## Standard library interfaces جو آپ مسلسل استعمال کریں گے

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

Standard library کا بیشتر حصہ چھوٹے interfaces (`io.Reader`/`io.Writer`, `error`, `Stringer`) پر بنایا گیا ہے — ان کو implement کرنے سے آپ کے types پوری ecosystem کے ساتھ کام کرتے ہیں۔

## Idiom: interfaces قبول کریں، structs واپس کریں

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

## یہ کیوں اہم ہے

Interfaces Go کے ڈیزائن اور abstraction اور polymorphism کے اس کے approach کے لیے مرکزی ہیں — اور ان کی **implicit satisfaction** (کوئی `implements` keyword نہیں؛ structural typing) زبان میں سب سے منفرد اور طاقتور خصوصیات میں سے ایک ہے۔

یہ decoupling کا مطلب ہے کہ types اور interfaces آزادانہ طور پر تیار ہوتے ہیں، آپ interfaces *اس کے بعد* define کر سکتے ہیں جو types ان کو مطمئن کرتے ہیں، اور کوئی بھی matching type خود بخود interface-based کوڈ میں plug ہو جاتا ہے — flexible، loosely-coupled designs اور آسان testing کو فعال بناتے ہوئے (mock implementations میں swap کریں)۔

Implicit implementation، interfaces کے ذریعے polymorphism، empty interface/`any`، small-interface idiom ("accept interfaces, return structs")، اور ubiquitous standard-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) کو سمجھنا idiomatic Go کے لیے ضروری ہے۔

یہ ایک معمول کے interview topic میں سے ہے بالکل اسی لیے کہ implicit، structural model Java/C# کے explicit interfaces سے بنیادی طور پر مختلف ہے۔

Interface کو define اور implicitly implement کرنا

Interfaces کے ذریعے Polymorphism

Empty interface اور any

Standard library interfaces جو آپ مسلسل استعمال کریں گے

Idiom: interfaces قبول کریں، structs واپس کریں

یہ کیوں اہم ہے

Empty interface اور `any`