Какие структуры удовлетворяют интерфейсам?

Структуры и интерфейсы в Go

В Go интерфейс — это набор методов. Любой тип (включая структуры) удовлетворяет интерфейсу, если реализует все методы, объявленные в этом интерфейсе. Это называется утиной типизацией (duck typing): "Если что-то ходит как утка и крякает как утка, то это утка".

Основные принципы

1. Неявная реализация — структура автоматически удовлетворяет интерфейсу, если содержит методы с нужными сигнатурами. Явного объявления (как в Java) не требуется.
2. Минимальное требование — достаточно реализовать все методы интерфейса.
3. Пустой интерфейс interface{} — ему удовлетворяет любая структура (и любой тип), так как он не требует методов. С Go 1.18 используется any.

Примеры реализации

Базовый пример

package main

import "fmt"

// Объявляем интерфейс
type Speaker interface {
    Speak() string
}

// Структура Dog
type Dog struct {
    Name string
}

// Реализуем метод Speak для Dog
func (d Dog) Speak() string {
    return fmt.Sprintf("Гав! Меня зовут %s", d.Name)
}

// Структура Cat
type Cat struct{}

// Реализуем метод Speak для Cat
func (c Cat) Speak() string {
    return "Мяу!"
}

func main() {
    var s Speaker // Переменная интерфейсного типа
    
    s = Dog{Name: "Бобик"}
    fmt.Println(s.Speak()) // Гав! Меня зовут Бобик
    
    s = Cat{}
    fmt.Println(s.Speak()) // Мяу!
}

Интерфейс с несколькими методами

type Writer interface {
    Write([]byte) (int, error)
}

type Closer interface {
    Close() error
}

type ReadWriteCloser interface {
    Writer
    Closer
    Read([]byte) (int, error)
}

// Структура File удовлетворяет ReadWriteCloser
type File struct {
    name string
}

func (f File) Write(data []byte) (int, error) {
    // реализация
    return len(data), nil
}

func (f File) Read(data []byte) (int, error) {
    // реализация
    return len(data), nil
}

func (f File) Close() error {
    // реализация
    return nil
}

Важные особенности

1. Методы с получателями по значению и указателю

type Mover interface {
    Move()
}

type Car struct {
    Model string
}

// Метод с получателем по значению
func (c Car) Move() {
    fmt.Printf("%s едет\n", c.Model)
}

// Такой метод работает и для Car, и для *Car
func main() {
    var m Mover
    
    c1 := Car{Model: "Toyota"}
    m = c1  // OK
    m.Move()
    
    c2 := &Car{Model: "BMW"}
    m = c2  // Тоже OK
    m.Move()
}

Однако если метод определен с получателем-указателем, интерфейсу будет удовлетворять только указатель на структуру:

type Swimmer interface {
    Swim()
}

type Fish struct{}

func (f *Fish) Swim() { // Получатель-указатель
    fmt.Println("Рыба плывет")
}

func main() {
    var s Swimmer
    
    f := Fish{}
    // s = f  // ОШИБКА: Fish does not implement Swimmer
    s = &f  // OK
    s.Swim()
}

2. Встраивание структур и интерфейсов

Структура может удовлетворять интерфейсу через встраивание других типов:

type Reader interface {
    Read() string
}

type BaseReader struct{}

func (br BaseReader) Read() string {
    return "базовое чтение"
}

// AdvancedReader наследует метод Read от BaseReader
type AdvancedReader struct {
    BaseReader // Встраивание
    Format string
}

func main() {
    var r Reader
    ar := AdvancedReader{Format: "JSON"}
    r = ar // OK, так как AdvancedReader имеет метод Read
    fmt.Println(r.Read())
}

3. Пустой интерфейс и type assertion

type Person struct {
    Name string
    Age  int
}

func processAnything(v interface{}) {
    // Все структуры удовлетворяют interface{}
    
    // Проверка типа
    if p, ok := v.(Person); ok {
        fmt.Printf("Это человек: %s, %d лет\n", p.Name, p.Age)
    }
}

func main() {
    p := Person{Name: "Иван", Age: 30}
    processAnything(p)
    processAnything("строка")
    processAnything(42)
}

Практические рекомендации

1. Используйте интерфейсы для абстракции — например, io.Reader, io.Writer позволяют работать с файлами, сетью, буферами единообразно.
2. Предпочитайте маленькие интерфейсы — принцип "интерфейс должен делать одну вещь" (как в io.Reader).
3. Тестируемость — интерфейсы позволяют легко создавать моки для тестирования.
4. Проверяйте реализацию на этапе компиляции — компилятор Go строго проверяет соответствие интерфейсам.

Заключение

Структуры в Go удовлетворяют интерфейсам неявно, реализуя все требуемые методы. Это дает гибкость проектирования, сохраняя статическую типизацию. Ключевое понимание: интерфейсы определяют поведение, а не данные, что позволяет создавать чистые абстракции и тестируемый код.