Interfaces hufanya kazi vipi katika Go?

Question

Accepted Answer

**Interface** ya Go hufafanua seti ya saini za methods — mkataba wa tabia. Muhimu zaidi, interfaces hutoshelezwa **kwa kisiri** (implicitly): aina yoyote yenye methods hizo hutosheleza interface kiotomatiki, **bila tangazo dhahiri la "implements"**. Mbinu hii ya kimuundo, ya duck-typing ni bainifu na yenye nguvu.

## Kufafanua na kutekeleza interface kwa kisiri

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

Hakuna neno muhimu `implements` — ikiwa aina ina methods zote za interface, hutosheleza interface kiotomatiki. Hii hutenganisha interface na utekelezaji wake (mtekelezaji haitaji hata kujua interface ipo).

## Polymorphism kupitia interfaces

```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 huwezesha polymorphism — andika msimbo dhidi ya tabia, na aina yoyote inayotosheleza hufanya kazi.

## Empty interface na `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`) hushikilia thamani yoyote — hutumika wakati aina haijulikani mapema (ingawa generics sasa mara nyingi huibadilisha).

## Interfaces za maktaba ya kawaida utakazozitumia daima

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

Sehemu kubwa ya maktaba ya kawaida imejengwa juu ya interfaces ndogo (`io.Reader`/`io.Writer`, `error`, `Stringer`) — kuzitekeleza hufanya aina zako zifanye kazi na mfumo wote wa ekolojia.

## Idiomu: pokea interfaces, rudisha 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."
```

## Kwa nini ni muhimu

Interfaces ni kiini cha muundo wa Go na mbinu yake ya udhahania na polymorphism — na **utoshelezaji wao wa kisiri** (hakuna neno muhimu `implements`; uainishaji wa kimuundo) ni mojawapo ya vipengele bainifu na vyenye nguvu zaidi katika lugha.

Utenganishaji huu unamaanisha aina na interfaces hubadilika kwa kujitegemea, unaweza kufafanua interfaces *baada ya* aina zinazozitosheleza, na aina yoyote inayotosheleza hujiunganisha na msimbo wa msingi-wa-interface kiotomatiki — ikiwezesha miundo inayonyumbulika, isiyofungamana sana na upimaji rahisi (badilisha utekelezaji bandia).

Kuelewa utekelezaji wa kisiri, polymorphism kupitia interfaces, empty interface/`any`, idiomu ya interface ndogo ("pokea interfaces, rudisha structs"), na interfaces zilizoenea za maktaba ya kawaida (`error`, `io.Reader`/`Writer`, `Stringer`) ni muhimu kwa Go ya kiidiomatiki.

Ni mada ya mara kwa mara ya mahojiano hasa kwa sababu modeli ya kisiri, ya kimuundo inatofautiana kimsingi na interfaces dhahiri za Java/C#.

Kufafanua na kutekeleza interface kwa kisiri

Polymorphism kupitia interfaces

Empty interface na any

Interfaces za maktaba ya kawaida utakazozitumia daima

Idiomu: pokea interfaces, rudisha structs

Kwa nini ni muhimu

Empty interface na `any`