Часть 5. Типы и абстракцииУрок 16# go# интерфейсы# ооп# дженерики# собеседование

Интерфейсы

неявная реализация, полиморфизм, any, type assertion, nil-интерфейс, дженерики

Цели главы

  • Объявлять интерфейсы и понимать неявную реализацию.
  • Использовать полиморфизм: интерфейсные переменные, слайсы и параметры.
  • Работать с any: type assertion и type switch.
  • Собирать интерфейсы из маленьких и реализовывать fmt.Stringer и error.
  • Объяснить ловушку nil-интерфейса.

Интерфейс — контракт поведения

В GoFlix есть фильмы, сериалы и подкасты. У всех есть название и длительность, но считаются они по-разному. В классическом ООП завели бы базовый класс Content и наследовали бы от него. В Go вместо этого описывают интерфейс — набор методов, которые должен уметь тип. Интерфейс не содержит данных и ничего не знает о реализации: это договор «тип умеет делать вот это».

Неявная реализация — главная особенность Go. В Java и C# пишут implements, а в Go тип автоматически удовлетворяет интерфейсу, если у него есть все перечисленные методы. Это работает даже для интерфейса из чужого пакета, о котором тип ничего не знает, и уменьшает связность кода.

В примере ниже:

  • Content — название, длительность и описание;
  • Playable — воспроизведение и пауза;
  • Movie и Series реализуют оба интерфейса, а Podcast — только Content;
  • MediaPlayer собран из двух интерфейсов — это композиция интерфейсов.
go
package main

import "fmt"

// Content — всё, у чего есть название, длительность и описание.
type Content interface {
    Title() string
    Duration() int
    Description() string
}

// Playable — то, что умеет воспроизводиться.
type Playable interface {
    Play() string
    Pause() string
}

// MediaPlayer = Content + Playable.
type MediaPlayer interface {
    Content
    Playable
}

type Movie struct {
    Name    string
    Year    int
    Minutes int
    Genre   string
}

func (m Movie) Title() string       { return m.Name }
func (m Movie) Duration() int       { return m.Minutes }
func (m Movie) Description() string { return fmt.Sprintf("%s (%d), %s", m.Name, m.Year, m.Genre) }
func (m Movie) Play() string        { return "▶ " + m.Name }
func (m Movie) Pause() string       { return "⏸ " + m.Name }

type Series struct {
    Name     string
    Seasons  int
    Episodes int
    AvgLen   int
}

func (s Series) Title() string       { return s.Name }
func (s Series) Duration() int       { return s.Episodes * s.AvgLen }
func (s Series) Description() string { return fmt.Sprintf("%s, сезонов: %d", s.Name, s.Seasons) }
func (s Series) Play() string        { return "▶ " + s.Name + " S01E01" }
func (s Series) Pause() string       { return "⏸ " + s.Name }

// Podcast реализует только Content: методов Play и Pause у него нет.
type Podcast struct {
    Name    string
    Host    string
    Minutes int
}

func (p Podcast) Title() string { return p.Name }
func (p Podcast) Duration() int { return p.Minutes }
func (p Podcast) Description() string {
    return fmt.Sprintf("подкаст %q, ведущий %s", p.Name, p.Host)
}

func printContentInfo(c Content) {
    fmt.Printf("%s — %d мин\n", c.Description(), c.Duration())
}

func main() {
    var item Content = Movie{Name: "Интерстеллар", Year: 2014, Minutes: 169, Genre: "фантастика"}
    printContentInfo(item)
    item = Series{Name: "Во все тяжкие", Seasons: 5, Episodes: 62, AvgLen: 47}
    printContentInfo(item)

    catalog := []Content{
        Movie{Name: "Дюна", Year: 2021, Minutes: 155, Genre: "фантастика"},
        Series{Name: "Чернобыль", Seasons: 1, Episodes: 5, AvgLen: 65},
        Podcast{Name: "GoFlix Talks", Host: "Анна", Minutes: 45},
    }
    total := 0
    for _, c := range catalog {
        fmt.Printf("%s: %d мин\n", c.Title(), c.Duration())
        total += c.Duration()
    }
    fmt.Println("итого:", total, "мин")

    var player MediaPlayer = Movie{Name: "Начало", Year: 2010, Minutes: 148, Genre: "фантастика"}
    fmt.Println(player.Description()) // метод из Content
    fmt.Println(player.Play())        // метод из Playable
}
stdout // вывод программы
Интерстеллар (2014), фантастика — 169 мин
Во все тяжкие, сезонов: 5 — 2914 мин
Дюна: 155 мин
Чернобыль: 325 мин
GoFlix Talks: 45 мин
итого: 525 мин
Начало (2010), фантастика
▶ Начало

Полиморфизм

Один и тот же код работает с разными типами, если они удовлетворяют интерфейсу. Функция printContentInfo принимает не конкретный тип, а Content — ей всё равно, фильм пришёл или сериал. В слайсе []Content рядом лежат три разных структуры, и в цикле Go сам вызывает нужную реализацию метода в зависимости от того, какой тип лежит внутри.

То же с геометрией: интерфейс Shape требует два метода, а прямоугольник и круг считают их по своим формулам.

go
package main

import (
    "fmt"
    "math"
)

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Rectangle struct{ Width, Height float64 }

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

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 main() {
    shapes := []Shape{Rectangle{Width: 16, Height: 9}, Circle{Radius: 5}}
    for _, s := range shapes {
        fmt.Printf("%T: площадь %.2f, периметр %.2f\n", s, s.Area(), s.Perimeter())
    }
}
stdout // вывод программы
main.Rectangle: площадь 144.00, периметр 50.00
main.Circle: площадь 78.54, периметр 31.42

Тип, которому не хватает метода, интерфейсу не подходит — и это ловит компилятор. Подкаст нельзя положить в MediaPlayer:

go
var p MediaPlayer = Podcast{} // Podcast does not implement MediaPlayer (missing method Pause)

any — пустой интерфейс

У пустого интерфейса interface{} нет методов, поэтому ему удовлетворяет любой тип — аналог Object в Java или Any в Kotlin. С Go 1.18 у него есть короткое имя any — это просто псевдоним.

За гибкость приходится платить: компилятор уже не знает, что лежит внутри, поэтому реальный тип приходится проверять отдельно. any полезен в универсальных местах — разбор JSON, логирование, произвольные данные, — но в обычном коде его используют аккуратно, чтобы не терять типобезопасность.

Type assertion

Конкретное значение достают через type assertion x.(T). Короткая форма предполагает, что тип угадан, и паникует, если нет. Безопасная форма v, ok := x.(T) возвращает флаг: при несовпадении — нулевое значение и false, без паники. Используй безопасную.

go
package main

import "fmt"

func main() {
    var anything any = "строка" // any — то же, что interface{}
    fmt.Printf("%v (%T)\n", anything, anything)
    anything = 42
    fmt.Printf("%v (%T)\n", anything, anything)

    var i any = "Привет"
    s := i.(string) // небезопасно: паника, если внутри не string
    fmt.Println(s)

    s2, ok := i.(string) // безопасно: ok сообщает, удалось ли
    fmt.Println(s2, ok)

    n, ok := i.(int)
    fmt.Println(n, ok) // нулевое значение и false — без паники
}
stdout // вывод программы
строка (string)
42 (int)
Привет
Привет true
0 false

Короткая форма с неверным типом:

go
package main

import "fmt"

func main() {
    var i any = "Привет"
    n := i.(int) // ожидается panic
    fmt.Println(n)
}
text
panic: interface conversion: interface {} is string, not int

Type switch

Если вариантов типа несколько, вместо цепочки assertion пишут type switch — он перебирает типы и выбирает первый совпавший case. Внутри ветки переменная уже имеет тип этой ветки — например, у Movie можно читать поля. default ловит всё остальное.

go
package main

import "fmt"

type Movie struct {
    Name string
    Year int
}

func classify(v any) string {
    switch val := v.(type) {
    case Movie:
        return fmt.Sprintf("фильм %s (%d)", val.Name, val.Year)
    case string:
        return "строка " + val
    case int:
        return fmt.Sprintf("число %d", val)
    case nil:
        return "nil"
    default:
        return fmt.Sprintf("другое: %T", val)
    }
}

func main() {
    for _, v := range []any{Movie{Name: "Матрица", Year: 1999}, "поиск", 42, nil, 8.7} {
        fmt.Println(classify(v))
    }
}
stdout // вывод программы
фильм Матрица (1999)
строка поиск
число 42
nil
другое: float64

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

Интерфейсы, как и структуры, встраиваются друг в друга. MediaPlayer из первого примера не объявляет методы заново, а объединяет Content и Playable: тип подходит под него, только если умеет всё, что требуют оба. Фильм подходит, подкаст — нет.

Так большой контракт собирают из маленьких и понятных. Это ISP (Interface Segregation Principle, принцип разделения интерфейсов): лучше много маленьких интерфейсов, чем один огромный. В стандартной библиотеке это повсюду: io.Reader — один метод Read, io.Writer — один метод Write, а io.ReadWriter — их композиция.

fmt.Stringer

Пакет fmt проверяет, реализует ли значение интерфейс fmt.Stringer — метод String() string. Если да, Println и %v печатают результат этого метода вместо стандартного вывода всех полей. Удобно для логирования, отладки и человекочитаемого вида объектов. В стандартной библиотеке таких интерфейсов много — например, json.Marshaler для своей сериализации.

go
package main

import "fmt"

type GoFlixUser struct {
    Name          string
    Plan          string
    MoviesWatched int
}

func (u GoFlixUser) String() string {
    return fmt.Sprintf("%s (%s, %d просмотров)", u.Name, u.Plan, u.MoviesWatched)
}

func main() {
    user := GoFlixUser{Name: "Алексей", Plan: "Premium", MoviesWatched: 45}
    fmt.Println(user) // вызовет String()
    fmt.Printf("пользователь: %v\n", user)
}
stdout // вывод программы
Алексей (Premium, 45 просмотров)
пользователь: Алексей (Premium, 45 просмотров)

Интерфейс error

Ошибки в Go — значения, а error — встроенный интерфейс с одним методом Error() string. Любой тип с этим методом можно вернуть как ошибку и добавить ему поля: статус, код, контекст. Снаружи код работает с общим интерфейсом и не зависит от конкретного типа, а когда нужны поля — достаёт конкретный тип.

go
package main

import (
    "errors"
    "fmt"
)

type SubscriptionError struct {
    Status string
    Code   int
}

func (e *SubscriptionError) Error() string {
    return fmt.Sprintf("подписка: %s (код %d)", e.Status, e.Code)
}

func checkSubscription(status string) error {
    switch status {
    case "expired":
        return &SubscriptionError{Status: status, Code: 402}
    case "banned":
        return &SubscriptionError{Status: status, Code: 403}
    }
    return nil
}

func main() {
    err := checkSubscription("expired")
    if err != nil {
        fmt.Println("ошибка:", err)
        if subErr, ok := err.(*SubscriptionError); ok { // type assertion
            fmt.Println("статус:", subErr.Status, "код:", subErr.Code)
        }
    }

    wrapped := fmt.Errorf("запуск фильма: %w", checkSubscription("banned"))
    var subErr *SubscriptionError
    found := errors.As(wrapped, &subErr)
    _, asserted := wrapped.(*SubscriptionError)
    fmt.Println(asserted, found, subErr.Code)
}
stdout // вывод программы
ошибка: подписка: expired (код 402)
статус: expired код: 402
false true 403

Ловушка nil-интерфейса

Интерфейсная переменная хранит два элемента: динамический тип и динамическое значение. Она равна nil, только если nil оба. Если положить в интерфейс nil-указатель конкретного типа, тип запишется, а значение останется nil — и сравнение с nil вернёт false, хотя внутри «пусто». Это один из самых коварных моментов Go и любимый вопрос на собеседованиях.

go
package main

import "fmt"

type Content interface{ Title() string }

type Movie struct{ Name string }

func (m *Movie) Title() string {
    if m == nil {
        return "<нет фильма>"
    }
    return m.Name
}

func main() {
    var c Content
    fmt.Println(c == nil) // нет ни типа, ни значения

    var m *Movie // nil-указатель
    c = m
    fmt.Println(c == nil)  // внутри тип *Movie и значение nil
    fmt.Println(c.Title()) // метод вызвался: интерфейс не пустой
}
stdout // вывод программы
true
false
<нет фильма>

Дженерики

Функция с параметром типа [T ограничение] работает с любым типом, который подходит под ограничение. Частые ограничения: any — любой тип, comparable — типы с ==, cmp.Ordered — числа и строки с < и >.

go
package main

import (
    "cmp"
    "fmt"
)

// Map применяет функцию к каждому элементу слайса любого типа.
func Map[T, U any](items []T, fn func(T) U) []U {
    result := make([]U, 0, len(items))
    for _, item := range items {
        result = append(result, fn(item))
    }
    return result
}

// MaxOf возвращает максимум; cmp.Ordered — типы, которые сравниваются через < и >.
func MaxOf[T cmp.Ordered](items ...T) T {
    best := items[0]
    for _, v := range items[1:] {
        if v > best {
            best = v
        }
    }
    return best
}

// Contains работает с любым сравнимым типом.
func Contains[T comparable](items []T, target T) bool {
    for _, v := range items {
        if v == target {
            return true
        }
    }
    return false
}

func main() {
    durations := Map([]int{148, 169, 155}, func(m int) string { return fmt.Sprintf("%d мин", m) })
    fmt.Println(durations)
    fmt.Println(MaxOf(8.1, 8.8, 7.5), MaxOf("Дюна", "Матрица"))
    fmt.Println(Contains([]string{"Дюна", "Довод"}, "Довод"))
}
stdout // вывод программы
[148 мин 169 мин 155 мин]
8.8 Матрица
true
Интерфейс Дженерик
Разные типы с общим поведением (методами) Один и тот же алгоритм для разных типов данных
Конкретный тип выбирается во время выполнения Тип подставляется при компиляции
[]Content с фильмами и сериалами Map, Contains, MaxOf для слайсов любых типов

Многие такие функции уже есть в стандартной библиотеке: пакеты slices и maps, встроенные min и max (Go 1.21+).

Практика

Домашнее задание

  1. Каналы уведомлений. Интерфейс Notifier с методами Send() string и ChannelName() string. Структуры EmailNotification и PushNotification его реализуют. Положи по объекту каждого типа в []Notifier и в цикле выведи канал доставки и результат отправки.
  2. Экспорт в разные форматы. Интерфейс Exporter с методом Export(). Структуры CSVExport и JSONExport. Функция RunExport(e Exporter) вызывает Export(); передай в неё оба типа.
  3. Композиция интерфейсов. Интерфейсы Authorizer с Authorize() string и Capturer с Capture() string. Составной PaymentProvider объединяет оба. Структура StripeProvider реализует оба интерфейса и метод String() string. Сохрани её в переменную PaymentProvider, вызови оба метода и выведи объект через fmt.Println.
  4. any в результатах поиска. Функция InspectSearchResult(value any): безопасным assertion проверь, строка ли это, потом — int; затем type switch по string, int, bool, SeriesResult (структура с полем Title) и default. Вызови для строки, числа, bool, SeriesResult и []string.
  5. Ошибка модерации. Структура ModerationError с полями ContentID и Reason и методом Error() string. Функция CheckPoster(status string) error: для approved — nil, иначе ModerationError. Вызови для approved и rejected, через assertion достань ContentID и Reason. Отдельно покажи nil-указатель внутри интерфейса error.
решениеЭталонное решение
go
package main

import (
    "fmt"
    "strings"
)

// 1. Каналы уведомлений.
type Notifier interface {
    Send() string
    ChannelName() string
}

type EmailNotification struct{ To, Subject string }

func (e EmailNotification) Send() string        { return "письмо для " + e.To + ": " + e.Subject }
func (e EmailNotification) ChannelName() string { return "email" }

type PushNotification struct{ DeviceID, Text string }

func (p PushNotification) Send() string        { return "push на " + p.DeviceID + ": " + p.Text }
func (p PushNotification) ChannelName() string { return "push" }

// 2. Экспорт.
type Exporter interface {
    Export() string
}

type CSVExport struct{ Rows [][]string }

func (c CSVExport) Export() string {
    lines := make([]string, 0, len(c.Rows))
    for _, row := range c.Rows {
        lines = append(lines, strings.Join(row, ","))
    }
    return strings.Join(lines, "\n")
}

type JSONExport struct{ Title string }

func (j JSONExport) Export() string { return fmt.Sprintf(`{"title":%q}`, j.Title) }

func RunExport(e Exporter) {
    fmt.Printf("%T:\n%s\n", e, e.Export())
}

// 3. Платёжный провайдер.
type Authorizer interface{ Authorize() string }

type Capturer interface{ Capture() string }

type PaymentProvider interface {
    Authorizer
    Capturer
}

type StripeProvider struct{ Account string }

func (s StripeProvider) Authorize() string { return "авторизация в " + s.Account }
func (s StripeProvider) Capture() string   { return "списание в " + s.Account }
func (s StripeProvider) String() string    { return "Stripe(" + s.Account + ")" }

// 4. Результаты поиска.
type SeriesResult struct{ Title string }

func InspectSearchResult(value any) {
    if s, ok := value.(string); ok {
        fmt.Println("assertion: строка", s)
    }
    if n, ok := value.(int); ok {
        fmt.Println("assertion: число", n)
    }
    switch v := value.(type) {
    case string:
        fmt.Println("switch: string", v)
    case int:
        fmt.Println("switch: int", v)
    case bool:
        fmt.Println("switch: bool", v)
    case SeriesResult:
        fmt.Println("switch: сериал", v.Title)
    default:
        fmt.Printf("switch: другой тип %T\n", v)
    }
}

// 5. Ошибка модерации.
type ModerationError struct {
    ContentID string
    Reason    string
}

func (e *ModerationError) Error() string {
    return fmt.Sprintf("постер %s отклонён: %s", e.ContentID, e.Reason)
}

func CheckPoster(status string) error {
    if status == "approved" {
        return nil
    }
    return &ModerationError{ContentID: "poster-42", Reason: "status=" + status}
}

func CheckPosterBuggy(status string) error {
    var err *ModerationError
    if status != "approved" {
        err = &ModerationError{ContentID: "poster-42", Reason: "status=" + status}
    }
    return err // ловушка: nil-указатель внутри интерфейса error
}

func main() {
    for _, n := range []Notifier{
        EmailNotification{To: "alex@goflix.ru", Subject: "Новый сезон"},
        PushNotification{DeviceID: "iphone-7", Text: "Скидка 50%"},
    } {
        fmt.Println(n.ChannelName(), "→", n.Send())
    }

    RunExport(CSVExport{Rows: [][]string{{"title", "year"}, {"Дюна", "2021"}}})
    RunExport(JSONExport{Title: "Дюна"})

    var provider PaymentProvider = StripeProvider{Account: "goflix-main"}
    fmt.Println(provider.Authorize())
    fmt.Println(provider.Capture())
    fmt.Println(provider)

    for _, v := range []any{"дюна", 42, true, SeriesResult{Title: "Чернобыль"}, []string{"a"}} {
        InspectSearchResult(v)
    }

    fmt.Println(CheckPoster("approved") == nil)
    err := CheckPoster("rejected")
    fmt.Println(err)
    if modErr, ok := err.(*ModerationError); ok {
        fmt.Println("ContentID:", modErr.ContentID, "| Reason:", modErr.Reason)
    }
    fmt.Println("buggy approved == nil:", CheckPosterBuggy("approved") == nil)
}
stdout // вывод программы
email → письмо для alex@goflix.ru: Новый сезон
push → push на iphone-7: Скидка 50%
main.CSVExport:
title,year
Дюна,2021
main.JSONExport:
{"title":"Дюна"}
авторизация в goflix-main
списание в goflix-main
Stripe(goflix-main)
assertion: строка дюна
switch: string дюна
assertion: число 42
switch: int 42
switch: bool true
switch: сериал Чернобыль
switch: другой тип []string
true
постер poster-42 отклонён: status=rejected
ContentID: poster-42 | Reason: status=rejected
buggy approved == nil: false

Проверь себя

вопросЧто такое интерфейс и как тип его реализует?

Набор сигнатур методов — контракт поведения без данных. Тип реализует интерфейс неявно: достаточно иметь все его методы, implements не пишут.

вопросКак в Go достигается полиморфизм?

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

вопросЧем короткая форма type assertion отличается от формы с ok?

v := x.(T) паникует при несовпадении типа. v, ok := x.(T) возвращает нулевое значение и false.

вопросКогда интерфейсная переменная равна nil?

Только когда в ней нет ни динамического типа, ни значения. Интерфейс с nil-указателем конкретного типа внутри не равен nil.

вопросПочему функция, вернувшая var e *MyErr как error, даёт err != nil?

В интерфейс записался тип *MyErr со значением nil — такой интерфейс не пустой. Возвращать нужно буквальный nil.

вопросЧто такое ISP и как композиция интерфейсов помогает его соблюдать?

Принцип разделения интерфейсов: лучше много маленьких интерфейсов, чем один большой. Большой контракт собирают встраиванием маленьких: io.ReadWriter = io.Reader + io.Writer.

вопросПочему Dog{} не реализует интерфейс, если метод объявлен как func (d *Dog) Speak()?

Метод с получателем-указателем входит в набор методов только *Dog. Нужно класть указатель: &Dog{}.

вопросЧем дженерики отличаются от интерфейсов?

Интерфейс — общее поведение разных типов, тип выбирается во время выполнения. Дженерик — один алгоритм для разных типов данных, тип подставляется при компиляции; ограничения параметров типа — интерфейсы.


Ключевые выводы

  • 📜 Интерфейс — контракт поведения; реализация неявная, без implements.
  • 🎭 Полиморфизм: интерфейсные переменные, параметры и слайсы работают с любыми подходящими типами.
  • 🧩 Маленькие интерфейсы собирают в большие композицией — принцип ISP.
  • 🔍 any принимает всё; тип достают через v, ok := x.(T) или type switch.
  • 🖨️ String() настраивает вывод через fmt, Error() делает тип ошибкой.
  • 🕳️ Интерфейс равен nil, только если пусты и тип, и значение — возвращай буквальный nil.
  • 🧬 Дженерики — один алгоритм для разных типов; ограничения задаются интерфейсами.
// связанные темы и шпаргалки