Jak fungují rozhraní (interfaces) v Go?

Question

Accepted Answer

Go **interface** definuje sadu signatury metod — smlouvu o chování. Zásadně je důležité, že interfaces jsou splňovány **implicitně**: jakýkoliv typ, který má tyto metody, automaticky splňuje interface, **bez jakékoliv explicitní deklarace "implements"**. Tento strukturální přístup s duck-typing je charakteristický a velmi mocný.

## Definování a implicitní implementace interface

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

Neexistuje klíčové slovo `implements` — pokud má typ všechny metody interface, automaticky ho splňuje. To odděluje interface od jeho implementací (implementátor nemusí vůbec vědět, že interface existuje).

## Polymorfismus skrze 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 umožňují polymorfismus — napište kód pro chování a jakýkoliv vyhovující typ funguje.

## Prázdný interface a `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
```

Prázdný interface (`interface{}` / `any`) obsahuje jakoukoliv hodnotu — používá se, když typ není předem znám (přestože generika nyní často toto nahrazují).

## Interface standardní knihovny, které budete používat neustále

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

Velká část standardní knihovny je postavena na malých interfacích (`io.Reader`/`io.Writer`, `error`, `Stringer`) — jejich implementace způsobí, že vaše typy pracují s celým ekosystémem.

## Idiom: přijímejte interfaces, vracejte struktury

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

## Proč to má smysl

Interfaces jsou ústředním prvkem návrhu Go a jeho přístupu k abstrakci a polymorfismu — a jejich **implicitní splnění** (bez klíčového slova `implements`; strukturální typování) je jednou z nejcharakterističtějších a nejsilnějších vlastností jazyka.

Toto oddělení znamená, že se typy a interfaces vyvíjejí nezávisle, můžete definovat interfaces *po* typech, které je splňují, a jakýkoliv vyhovující typ se automaticky zapojí do kódu založeného na interfacích — umožňuje flexibilní, volně propojené návrhy a snadné testování (nahraďte mock implementace).

Porozumění implicitní implementaci, polymorfismu skrze interfaces, prázdnému interface/`any`, idiom s malými interfacemi ("přijímejte interfaces, vracejte struktury") a všudypřítomným interfacím standardní knihovny (`error`, `io.Reader`/`Writer`, `Stringer`) je nezbytné pro idiomatický Go.

Je to částý interviewový námět právě proto, že implicitní, strukturální model se zásadně liší od explicitních interfacích jazyků Java/C#.

Definování a implicitní implementace interface

Polymorfismus skrze interfaces

Prázdný interface a any

Interface standardní knihovny, které budete používat neustále

Idiom: přijímejte interfaces, vracejte struktury

Proč to má smysl

Prázdný interface a `any`