Как работают интерфейсы в Go?

Question

Accepted Answer

**Интерфейс** в Go определяет набор сигнатур методов — контракт поведения. Критически важно, что интерфейсы удовлетворяются **неявно**: любой тип, который имеет эти методы, автоматически удовлетворяет интерфейс, **без явного объявления "implements"**. Этот структурный подход, похожий на duck-typing, отличается и очень мощный.

## Определение и неявная реализация интерфейса

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

Нет ключевого слова `implements` — если тип имеет все методы интерфейса, он автоматически удовлетворяет интерфейс. Это развязывает интерфейс от его реализаций (реализующий тип даже не должен знать об существовании интерфейса).

## Полиморфизм через интерфейсы

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

Интерфейсы включают полиморфизм — напишите код для поведения, и любой соответствующий тип работает.

## Пустой интерфейс и `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
```

Пустой интерфейс (`interface{}` / `any`) может содержать любое значение — используется, когда тип неизвестен заранее (хотя обобщения теперь часто заменяют это).

## Интерфейсы стандартной библиотеки, которые вы будете использовать постоянно

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

Большая часть стандартной библиотеки построена на маленьких интерфейсах (`io.Reader`/`io.Writer`, `error`, `Stringer`) — реализация их делает ваши типы совместимыми с экосистемой.

## Идиома: принимать интерфейсы, возвращать структуры

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

## Почему это важно

Интерфейсы находятся в центре дизайна Go и его подхода к абстракции и полиморфизму — и их **неявное удовлетворение** (без ключевого слова `implements`; структурная типизация) — одна из самых отличительных и мощных особенностей языка.

Эта развязка означает, что типы и интерфейсы эволюционируют независимо, вы можете определить интерфейсы *после* типов, которые их удовлетворяют, и любой соответствующий тип автоматически подключается к коду на основе интерфейсов — что позволяет создавать гибкие, слабосвязанные дизайны и упрощает тестирование (подмените реализации-заглушки).

Понимание неявной реализации, полиморфизма через интерфейсы, пустого интерфейса/`any`, идиомы маленьких интерфейсов («принимать интерфейсы, возвращать структуры») и повсеместно встречающихся интерфейсов стандартной библиотеки (`error`, `io.Reader`/`Writer`, `Stringer`) необходимо для идиоматичного Go.

Это частая тема собеседований именно потому, что неявная, структурная модель фундаментально отличается от явных интерфейсов в Java/C#.

Определение и неявная реализация интерфейса

Полиморфизм через интерфейсы

Пустой интерфейс и any

Интерфейсы стандартной библиотеки, которые вы будете использовать постоянно

Идиома: принимать интерфейсы, возвращать структуры

Почему это важно

Пустой интерфейс и `any`