Kepiye interface bisa gumana ing Go?

Question

Accepted Answer

A Go **interface** nuduhake set saka method signatures — sawijining kontrak perilaku. Sing penting, interfaces kepenuhi **nang implisit**: saben tipe sing nduwe metode-metode kasebut otomatis numuhi interface, tanpa **deklarasi "implements" eksplisit**. Pendekatan struktural, duck-typing iki khas lan kuwat.

## Nggawe lan ngleksani interface nang implisit

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

Tora ana keyword `implements` — yen tipe duweni kabeh metode interface, tipe kasebut numuhi interface kanthi otomatis. Iki nyebut interface lan implementasine (implementer ora perlu ngerti interface kasebut ana).

## Polimorfisme lumantar interface

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

Interface ngaktibake polimorfisme — tulis kode sakawan perilaku, lan saben tipe sing cocok bisa dianggo.

## Empty interface lan `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`) bisa nyimpen saben nilai — dienggo nalika tipe ora ketahuan sadurunge (sanajan generics saiki asring ngganti iki).

## Interface standar library sing bakal sering dialani

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

Luwih akeh standar library dibangun ing interface cilik (`io.Reader`/`io.Writer`, `error`, `Stringer`) — ngleksani interface-interface iki nggawe tipe-tipe mu bisa dianggo karo kabeh ekosistem.

## Idiom: tanggap interface, bali 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."
```

## Apa pentinge

Interface pusat saka desain Go lan pendekatan abstraksi lan polimorfisme — lan **kepenuhi implisit** (ora ana keyword `implements`; structural typing) iku salah sawijining fitur paling khas lan kuwat ing basa iki.

Dekopling iki warta yen tipe lan interface bisa berkembang kanthi mandiri, kowe bisa nggawe interface *sabanjure* tipe sing numuhi, lan saben tipe sing cocok bisa plug otomatis ing kode sing wasis interface — ngaktibake desain sing leluasa, loosely-coupled, lan gampang diuji (ganti implementasi mock).
">Mangerteni kepenuhi implisit, polimorfisme lumantar interface, empty interface/`any`, idiom interface-cilik ("tanggap interface, bali structs"), lan ubiquitous standar-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) iku penting kanggo idiomatic Go.

Iki topik interview sing asring muncul jalaran model implicit, struktural beda banget karo explicit interfaces saka Java/C#.

Nggawe lan ngleksani interface nang implisit

Polimorfisme lumantar interface

Empty interface lan any

Interface standar library sing bakal sering dialani

Idiom: tanggap interface, bali structs

Apa pentinge

Empty interface lan `any`