Hogyan működnek az interfészek a Go-ban?

Question

Accepted Answer

A Go **interfész** metódusaláírások egy halmazát definiálja — a viselkedés szerződése. Kulcsfontosságú, hogy az interfészeket **implicit módon** teljesítik: bármely típus, amely rendelkezik ezekkel a metódusokkal, automatikusan teljesíti az interfészt, **anélkül hogy explicit "implements" deklaráció szükséges lenne**. Ez a strukturális, kacsa-tipizálási megközelítés megkülönböztetett és hatékony.

## Interfész definiálása és implicit megvalósítása

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

Nincs `implements` kulcsszó — ha egy típus rendelkezik az interfész összes metódusával, automatikusan teljesíti az interfészt. Ez leválasztja az interfészt a megvalósításaitól (a megvalósítónak nem kell tudnia az interfészről).

## Polimorfizmus interfészeken keresztül

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

Az interfészek lehetővé teszik a polimorfizmust — írj kódot a viselkedés alapján, és bármely megfelelő típus működni fog.

## Az üres interfész és az `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
```

Az üres interfész (`interface{}` / `any`) bármilyen értéket tartalmazhat — akkor használjuk, amikor a típus előre nem ismert (bár a generikusok most gyakran helyettesítik ezt).

## Standard könyvtári interfészek, amelyeket folyamatosan használni fogsz

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

A standard könyvtár nagy része kis interfészekre épül (`io.Reader`/`io.Writer`, `error`, `Stringer`) — megvalósítva őket, a típusaid az egész ökoszisztémával működnek.

## Az idiómá: interfészek elfogadása, strukturák visszaadása

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

## Miért számít

Az interfészek központi szerepet játszanak a Go dizájnjában és az absztrakció és polimorfizmus megközelítésében — és az **implicit teljesítésük** (nincs `implements` kulcsszó; strukturális tipizálás) az egyik legmegkülönböztetettebb és legerősebb jellemző a nyelvben.

Ez a leválasztás azt jelenti, hogy a típusok és interfészek függetlenül fejlődnek, az interfészeket *után* is definiálhatod azoknak a típusoknak, amelyek teljesítik azokat, és bármely megfelelő típus automatikusan beépül az interfész-alapú kódba — lehetővé téve a rugalmas, lazán összekapcsolt tervezést és az egyszerű tesztelést (cseréld be a mock megvalósításokat).

A implicit megvalósítás, az interfészeken keresztüli polimorfizmus, az üres interfész/`any`, a kis-interfész idiómá ("interfészek elfogadása, strukturák visszaadása"), és az ubicikális standard könyvtári interfészek (`error`, `io.Reader`/`Writer`, `Stringer`) megértése elengedhetetlen az idiomatikus Go-hoz.

Ezért előjövetkezik gyakran az interjúkban, mert az implicit, strukturális modell alapvetően eltér a Java/C# explicit interfészeitől.

Interfész definiálása és implicit megvalósítása

Polimorfizmus interfészeken keresztül

Az üres interfész és az any

Standard könyvtári interfészek, amelyeket folyamatosan használni fogsz

Az idiómá: interfészek elfogadása, strukturák visszaadása

Miért számít

Az üres interfész és az `any`