Kako sučelja funkcioniraju u Go-u?

Question

Accepted Answer

Go **sučelje** (interface) definiše skup signature metoda — ugovor ponašanja. Ključno je što se sučelja zadovoljavaju **implicitno**: svaki tip koji ima te metode automatski zadovoljava sučelje, **bez eksplicitne "implements" deklaracije**. Ovaj strukturni pristup, sličan duck-typing-u, je različit i moćan.

## Definisanje i implicitna implementacija sučelja

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

Nema `implements` ključne reči — ako tip ima sve metode sučelja, automatski ga zadovoljava. Ovo razdvaja sučelje od njegovih implementacija (implementer čak ne mora znati da sučelje postoji).

## Polimorfizam kroz sučelja

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

Sučelja omogućavaju polimorfizam — napišite kod prema ponašanju, i svaki odgovarajući tip funkcionira.

## Prazno sučelje i `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
```

Prazno sučelje (`interface{}` / `any`) sadrži bilo koju vrednost — koristi se kada tip nije poznat unapred (mada generici sada često zamenjuju ovo).

## Sučelja standardne biblioteke koja ćete neprestano koristiti

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

Veliki deo standardne biblioteke je izgrađen na malim sučeljima (`io.Reader`/`io.Writer`, `error`, `Stringer`) — njihova implementacija čini da vaši tipovi rade sa čitavim ekosistemom.

## Idiom: prihvatite sučelja, vraćajte strukture

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

## Zašto je to važno

Sučelja su centralna za Go-ov dizajn i njegov pristup abstrakciji i polimorfizmu — i njihova **implicitna zadovoljenost** (nema `implements` ključne reči; strukturno tipiziranje) je jedna od najprekrasnijih i najmoćnijih karakteristika u jeziku.

Ovo razdvajanje znači da se tipovi i sučelja razvijaju nezavisno, možete definisati sučelja *nakon* tipova koji ih zadovoljavaju, i svaki odgovarajući tip automatski se uključuje u kod zasnovan na sučeljima — omogućavajući fleksibilne, slabo povezane dizajne i lako testiranje (zamenite sa mock implementacijama).

Razumevanje implicitne implementacije, polimorfizma preko sučelja, praznog sučelja/`any`, idioma sa malim sučeljima ("prihvatite sučelja, vraćajte strukture"), i sveprisutnih sučelja standardne biblioteke (`error`, `io.Reader`/`Writer`, `Stringer`) je neophodno za idiomatski Go.

To je česta tema intervjua upravo zato što se implicitni, strukturni model fundamentalno razlikuje od eksplicitnih sučelja iz Java/C# jezika.

Definisanje i implicitna implementacija sučelja

Polimorfizam kroz sučelja

Prazno sučelje i any

Sučelja standardne biblioteke koja ćete neprestano koristiti

Idiom: prihvatite sučelja, vraćajte strukture

Zašto je to važno

Prazno sučelje i `any`