МОДУЛЬ 4 · УРОК 4.4

Интерфейсы — мощь Go

Понимаем, что такое интерфейсы, почему они работают неявно и как с их помощью писать гибкий, расширяемый код

В предыдущих уроках мы научились создавать структуры, методы, работать с файлами. Всё это — строительные блоки. Но что, если вам нужно написать функцию, которая принимает «что угодно, у чего есть метод Area()»? Или передать в функцию и файл, и сетевое соединение, и буфер в памяти — потому что все они умеют «читать байты»? Именно для этого в Go существуют интерфейсы. Интерфейсы — это одна из самых мощных и одновременно элегантных концепций языка. Они делают код гибким, тестируемым и расширяемым. Сегодня мы разберём их от самых основ до реальных примеров из стандартной библиотеки, а в конце построим систему геометрических фигур.

📐 Что такое интерфейс и зачем он нужен

Представьте, что вы в ресторане. Вы нажимаете кнопку «Позвать официанта». Вам неважно, кто именно подойдёт — Иван, Мария или робот. Важно одно: этот «кто-то» умеет принять заказ. Именно это и есть интерфейс — набор действий (методов), которые должен уметь выполнять объект.

В Go интерфейс — это тип, который описывает набор методов. Если какой-то тип имеет все эти методы, значит он «реализует» интерфейс. Никакого специального ключевого слова для этого не нужно — но об этом чуть позже.

Вот как объявляется интерфейс:

type Speaker interface {
    Speak() string
}

Мы объявили интерфейс Speaker. Он говорит: «Любой тип, у которого есть метод Speak(), возвращающий string, является Speaker».

Теперь создадим два типа, которые реализуют этот интерфейс:

package main

import "fmt"

// Интерфейс
type Speaker interface {
    Speak() string
}

// Тип Dog
type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + " говорит: Гав!"
}

// Тип Cat
type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + " говорит: Мяу!"
}

// Функция принимает интерфейс, а не конкретный тип!
func greet(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "Рекс"}
    cat := Cat{Name: "Барсик"}

    greet(dog) // Рекс говорит: Гав!
    greet(cat) // Барсик говорит: Мяу!
}

Обратите внимание на функцию greet. Она принимает Speaker — не Dog, не Cat, а любой тип, который умеет «говорить». Завтра вы добавите тип Parrot с методом Speak() — и функция greet будет работать с ним без единого изменения. Вот в чём мощь интерфейсов.

🔑 Неявная реализация — ключевая идея Go

Вот что делает интерфейсы Go по-настоящему особенными. Во многих языках (Java, C#, PHP) вы должны явно написать: «мой класс реализует такой-то интерфейс». В Go ничего такого нет.

Давайте убедимся в этом на примере. Мы нигде не писали «Dog implements Speaker». Мы просто добавили структуре Dog метод Speak() string — и Go сам понял, что Dog реализует интерфейс Speaker.

Почему это гениально? Потому что интерфейс и тип могут жить в разных пакетах, написанных разными людьми. Вы можете написать тип, который реализует интерфейс из стандартной библиотеки Go, даже не зная об этом интерфейсе заранее.

Сравним с другими языками:

// Java — нужно ЯВНО указать implements
// class Dog implements Speaker {
//     public String speak() { ... }
// }

// Go — просто есть метод, и всё
type Dog struct{ Name string }

func (d Dog) Speak() string {
    return d.Name + " говорит: Гав!"
}
// Dog автоматически является Speaker!

Интерфейс может содержать несколько методов. Тип должен реализовать все из них:

package main

import "fmt"

type Animal interface {
    Speak() string
    Move() string
}

type Dog struct{ Name string }

func (d Dog) Speak() string { return "Гав!" }
func (d Dog) Move() string  { return d.Name + " бежит" }

type Turtle struct{ Name string }

func (t Turtle) Speak() string { return "..." }
func (t Turtle) Move() string  { return t.Name + " ползёт" }

func describe(a Animal) {
    fmt.Println(a.Speak(), "|", a.Move())
}

func main() {
    describe(Dog{Name: "Рекс"})      // Гав! | Рекс бежит
    describe(Turtle{Name: "Тортилла"}) // ... | Тортилла ползёт
}

📦 interface{} / any — пустой интерфейс

Раз интерфейс — это набор методов, то что будет, если набор пустой? Получится тип, который реализуют абсолютно все типы в Go, ведь у любого типа есть «ноль или более методов».

// Пустой интерфейс — принимает что угодно
var x interface{}

x = 42
x = "hello"
x = true
x = []int{1, 2, 3}

Начиная с Go 1.18 появился удобный псевдоним: any. Это то же самое, что interface{}, просто короче:

// Эти две записи полностью идентичны
var a interface{}
var b any

Пустой интерфейс используется, когда функция должна принимать данные любого типа. Именно так работает fmt.Println:

// Сигнатура fmt.Println (упрощённо):
// func Println(a ...any) (n int, err error)

fmt.Println(42)          // int
fmt.Println("привет")    // string
fmt.Println(true)        // bool
fmt.Println([]int{1,2})  // []int

Но есть проблема: когда вы получили any, вы не знаете, какой конкретно тип внутри. Чтобы это выяснить, используют приведение типа (type assertion):

package main

import "fmt"

func describe(val any) {
    // Пробуем привести к string
    if s, ok := val.(string); ok {
        fmt.Println("Это строка:", s)
        return
    }

    // Пробуем привести к int
    if n, ok := val.(int); ok {
        fmt.Println("Это число:", n)
        return
    }

    fmt.Println("Неизвестный тип")
}

func main() {
    describe("Go")   // Это строка: Go
    describe(42)      // Это число: 42
    describe(3.14)    // Неизвестный тип
}

Конструкция val.(string) пытается «достать» из интерфейса значение типа string. Если внутри действительно строка, ok будет true. Если нет — false, и программа не упадёт.

Есть ещё более удобный способ — type switch:

package main

import "fmt"

func printType(val any) {
    switch v := val.(type) {
    case int:
        fmt.Printf("Целое число: %d\n", v)
    case string:
        fmt.Printf("Строка: %s\n", v)
    case bool:
        fmt.Printf("Булево: %t\n", v)
    case []int:
        fmt.Printf("Срез int: %v\n", v)
    default:
        fmt.Printf("Неизвестный тип: %T\n", v)
    }
}

func main() {
    printType(100)          // Целое число: 100
    printType("Go")         // Строка: Go
    printType(true)         // Булево: true
    printType([]int{1,2,3}) // Срез int: [1 2 3]
    printType(3.14)         // Неизвестный тип: float64
}

📚 Интерфейсы из стандартной библиотеки

Go активно использует интерфейсы в своей стандартной библиотеке. Зная ключевые из них, вы поймёте философию всего языка. Разберём три самых важных.

fmt.Stringer — «покажи себя красиво»

Когда вы вызываете fmt.Println(myObject), Go проверяет: «Есть ли у этого объекта метод String() string?». Если есть — вызывает его. Этот метод описан в интерфейсе fmt.Stringer:

// Из пакета fmt:
type Stringer interface {
    String() string
}

Это как toString() в Java или __str__() в Python. Давайте реализуем его:

package main

import "fmt"

type User struct {
    Name string
    Age  int
}

// Реализуем интерфейс fmt.Stringer
func (u User) String() string {
    return fmt.Sprintf("%s (%d лет)", u.Name, u.Age)
}

func main() {
    user := User{Name: "Алиса", Age: 25}

    // БЕЗ метода String(): {Алиса 25}
    // С методом String(): Алиса (25 лет)
    fmt.Println(user) // Алиса (25 лет)
}

Мы нигде не писали implements Stringer. Просто добавили метод String() string — и Go автоматически понял, что User реализует fmt.Stringer. Теперь fmt.Println выводит нашу красивую строку вместо стандартного представления структуры.

io.Reader и io.Writer — универсальный ввод-вывод

Это, пожалуй, два самых важных интерфейса во всём Go. Они определены в пакете io:

// Из пакета io:
type Reader interface {
    Read(p []byte) (n int, err error)
}

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

io.Reader — это «что-то, из чего можно читать байты». io.Writer — «что-то, куда можно записать байты». Всего один метод — но какая мощь!

Файл на диске? Реализует io.Reader и io.Writer. Сетевое соединение? Тоже. Буфер в памяти? Да. HTTP-ответ? Конечно. Все они «умеют» читать и писать байты, а значит, с ними можно работать одинаково:

package main

import (
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
    // strings.NewReader создаёт io.Reader из строки
    reader := strings.NewReader("Привет из строки!")

    // io.Copy копирует байты из Reader в Writer
    // os.Stdout — это io.Writer (стандартный вывод)
    io.Copy(os.Stdout, reader) // Привет из строки!
    fmt.Println()
}

Функция io.Copy принимает io.Writer и io.Reader. Ей всё равно, откуда вы читаете (файл, сеть, строка) и куда пишете (файл, экран, сеть). Она просто перекладывает байты. Это и есть сила интерфейсов — один код работает с любыми источниками данных.

error — тоже интерфейс!

Вы уже много раз видели тип error. На самом деле это интерфейс:

// Встроенный интерфейс:
type error interface {
    Error() string
}

Это значит, что вы можете создавать свои собственные типы ошибок:

package main

import "fmt"

// Наш собственный тип ошибки
type ValidationError struct {
    Field   string
    Message string
}

// Реализуем интерфейс error
func (e ValidationError) Error() string {
    return fmt.Sprintf("ошибка в поле '%s': %s", e.Field, e.Message)
}

func validateAge(age int) error {
    if age < 0 {
        return ValidationError{
            Field:   "age",
            Message: "возраст не может быть отрицательным",
        }
    }
    if age > 150 {
        return ValidationError{
            Field:   "age",
            Message: "слишком большой возраст",
        }
    }
    return nil
}

func main() {
    err := validateAge(-5)
    if err != nil {
        fmt.Println(err) // ошибка в поле 'age': возраст не может быть отрицательным
    }

    err = validateAge(25)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("Возраст корректен") // Возраст корректен
    }
}

🧩 Полезные паттерны работы с интерфейсами

Разберём несколько важных принципов, которые помогут вам использовать интерфейсы правильно.

Маленькие интерфейсы лучше больших

В Go принято делать интерфейсы маленькими — 1-2 метода. Посмотрите на стандартную библиотеку: io.Reader — 1 метод, io.Writer — 1 метод, fmt.Stringer — 1 метод, error — 1 метод. Чем меньше интерфейс, тем больше типов его реализуют, тем он полезнее.

Композиция интерфейсов

Несколько маленьких интерфейсов можно объединить в один:

type Reader interface {
    Read(p []byte) (n int, err error)
}

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

// ReadWriter — объединение Reader и Writer
type ReadWriter interface {
    Reader
    Writer
}

Тип, реализующий ReadWriter, должен иметь оба метода: Read и Write. Это как конструктор — собираете сложный интерфейс из простых кирпичиков.

Срезы интерфейсов

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

package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }
func (d Dog) Speak() string { return "Гав!" }

type Cat struct{ Name string }
func (c Cat) Speak() string { return "Мяу!" }

type Duck struct{}
func (d Duck) Speak() string { return "Кря!" }

func main() {
    // Срез интерфейсов — разные типы в одном срезе!
    animals := []Speaker{
        Dog{Name: "Рекс"},
        Cat{Name: "Мурка"},
        Duck{},
    }

    for _, a := range animals {
        fmt.Println(a.Speak())
    }
    // Гав!
    // Мяу!
    // Кря!
}

В одном срезе лежат собака, кошка и утка. Они совершенно разные структуры, но все реализуют Speaker, поэтому Go разрешает поместить их в один срез.

🛠 Практика: система геометрических фигур

Давайте соберём всё изученное в одну программу. Создадим систему, в которой разные фигуры (круг, прямоугольник, треугольник) реализуют общий интерфейс для вычисления площади и периметра.

package main

import (
    "fmt"
    "math"
)

// ================================
// Интерфейс Shape — описывает фигуру
// ================================
type Shape interface {
    Area() float64
    Perimeter() float64
    String() string // заодно реализуем fmt.Stringer
}

// ================================
// Круг
// ================================
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

func (c Circle) String() string {
    return fmt.Sprintf("Круг (радиус %.1f)", c.Radius)
}

// ================================
// Прямоугольник
// ================================
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

func (r Rectangle) String() string {
    return fmt.Sprintf("Прямоугольник (%.1f x %.1f)", r.Width, r.Height)
}

// ================================
// Треугольник
// ================================
type Triangle struct {
    A, B, C float64 // стороны
}

func (t Triangle) Area() float64 {
    // Формула Герона
    s := t.Perimeter() / 2
    return math.Sqrt(s * (s - t.A) * (s - t.B) * (s - t.C))
}

func (t Triangle) Perimeter() float64 {
    return t.A + t.B + t.C
}

func (t Triangle) String() string {
    return fmt.Sprintf("Треугольник (стороны %.1f, %.1f, %.1f)", t.A, t.B, t.C)
}

// ================================
// Функции, работающие с интерфейсом
// ================================

// Печатает информацию о любой фигуре
func printInfo(s Shape) {
    fmt.Println(s)
    fmt.Printf("  Площадь:   %.2f\n", s.Area())
    fmt.Printf("  Периметр:  %.2f\n", s.Perimeter())
    fmt.Println()
}

// Находит фигуру с наибольшей площадью
func largestShape(shapes []Shape) Shape {
    largest := shapes[0]
    for _, s := range shapes[1:] {
        if s.Area() > largest.Area() {
            largest = s
        }
    }
    return largest
}

// Считает суммарную площадь всех фигур
func totalArea(shapes []Shape) float64 {
    total := 0.0
    for _, s := range shapes {
        total += s.Area()
    }
    return total
}

func main() {
    // Создаём разные фигуры
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 4, Height: 6},
        Triangle{A: 3, B: 4, C: 5},
    }

    // Печатаем информацию о каждой
    fmt.Println("=== Все фигуры ===")
    for _, s := range shapes {
        printInfo(s)
    }

    // Находим самую большую
    biggest := largestShape(shapes)
    fmt.Printf("Самая большая фигура: %s (площадь %.2f)\n", biggest, biggest.Area())

    // Суммарная площадь
    fmt.Printf("Суммарная площадь: %.2f\n", totalArea(shapes))
}

Вывод программы:

=== Все фигуры ===
Круг (радиус 5.0)
  Площадь:   78.54
  Периметр:  31.42

Прямоугольник (4.0 x 6.0)
  Площадь:   24.00
  Периметр:  20.00

Треугольник (стороны 3.0, 4.0, 5.0)
  Площадь:   6.00
  Периметр:  12.00

Самая большая фигура: Круг (радиус 5.0) (площадь 78.54)
Суммарная площадь: 108.54

Давайте разберём, что здесь важно:

🔍 Проверка реализации на этапе компиляции

Поскольку реализация неявная, иногда хочется убедиться, что тип точно реализует интерфейс. Для этого есть идиоматический приём:

// Проверка на этапе компиляции
var _ Shape = Circle{}
var _ Shape = Rectangle{}
var _ Shape = Triangle{}

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

Это полезно в больших проектах, когда вы добавляете метод в интерфейс и хотите сразу увидеть, какие типы «сломались».

⚠️ Интерфейсы и nil — частая ловушка

Есть один нюанс, который ловит даже опытных разработчиков. Интерфейс в Go хранит две вещи: тип и значение. Интерфейс равен nil только когда оба — тип и значение — равны nil:

package main

import "fmt"

type MyError struct {
    Message string
}

func (e *MyError) Error() string {
    return e.Message
}

func doSomething(fail bool) error {
    var err *MyError // nil указатель типа *MyError

    if fail {
        err = &MyError{Message: "что-то пошло не так"}
    }

    return err // Осторожно! Возвращаем НЕ nil интерфейс
}

func main() {
    err := doSomething(false)

    // err содержит: тип = *MyError, значение = nil
    // Это НЕ nil интерфейс!
    if err != nil {
        fmt.Println("Ошибка:", err) // Это выполнится!
    }
}

Даже когда err содержит nil-указатель, интерфейс не равен nil, потому что в нём хранится информация о типе (*MyError). Решение — возвращайте nil явно:

func doSomething(fail bool) error {
    if fail {
        return &MyError{Message: "что-то пошло не так"}
    }
    return nil // Правильно! Возвращаем nil, а не типизированный nil
}

📋 Итоги урока

• Интерфейс — это набор методов, описывающий поведение, а не конкретный тип
• Реализация интерфейсов в Go неявная: есть все методы — значит реализует. Никакого implements
• any (он же interface{}) — пустой интерфейс, принимающий любой тип
• Приведение типа: val.(string) и switch v := val.(type)
• fmt.Stringer — реализуйте String() string, чтобы fmt.Println красиво выводил ваш тип
• io.Reader / io.Writer — универсальные интерфейсы чтения и записи байтов
• error — тоже интерфейс, и вы можете создавать собственные типы ошибок
• Делайте интерфейсы маленькими (1-2 метода) и комбинируйте через композицию
• Осторожно с nil: интерфейс с типизированным nil-указателем не равен nil
• Мы построили систему фигур, в которой одни функции работают с кругами, прямоугольниками и треугольниками через единый интерфейс

В следующем уроке мы начинаем Модуль 5 — финальный проект. В уроке 5.1 поговорим об архитектуре проекта: как организовать файлы и папки, разделить код на пакеты, спроектировать зависимости и создать каркас настоящего Go-приложения. Это первый шаг к тому, чтобы собрать всё изученное в единый полноценный проект!