Как ООП в Go реализовано

В Go объектно-ориентированное программирование (ООП) реализовано не через классы и наследование, как в Java или C++, а через комбинацию структур, методов, интерфейсов и встраивания. Такой подход обеспечивает композицию вместо наследования и неявный полиморфизм через интерфейсы, что делает код более гибким и простым.

Структуры и методы вместо классов

В Go нет классов. Основная единица данных — структура (struct), которая объединяет поля. Методы определяются отдельно от структуры и привязываются к ней через получатель (receiver). Получатель может быть значением или указателем; выбор влияет на то, изменяет ли метод исходную структуру.

type Person struct {
    Name string
    Age  int
}

// Метод с получателем-значением: не изменяет исходную структуру
func (p Person) Greet() string {
    return "Hello, my name is " + p.Name
}

// Метод с получателем-указателем: может изменять поля
func (p *Person) Birthday() {
    p.Age++
}

Здесь Person — структура, а Greet и Birthday — методы, ассоциированные с ней. Такой синтаксис позволяет группировать данные и поведение, сохраняя разделение.

Интерфейсы для полиморфизма

Полиморфизм в Go достигается через интерфейсы. Интерфейс — это набор сигнатур методов. Тип автоматически реализует интерфейс, если содержит все его методы, без явного объявления implements. Это называется утиной типизацией.

type Greeter interface {
    Greet() string
}

func GreetSomeone(g Greeter) {
    fmt.Println(g.Greet())
}

// Person автоматически реализует Greeter, так как имеет метод Greet()
func main() {
    p := Person{Name: "Alice", Age: 30}
    GreetSomeone(p) // Выведет: Hello, my name is Alice
}

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

Встраивание для композиции

Вместо наследования Go предлагает встраивание (embedding). Одна структура может быть встроена в другую, и тогда все поля и методы встроенной структуры становятся доступны на верхнем уровне. Это позволяет переиспользовать код без жёсткой иерархии.

type Employee struct {
    Person   // встраивание Person
    Position string
}

func (e Employee) Work() string {
    return e.Name + " works as " + e.Position
}

func main() {
    emp := Employee{Person: Person{Name: "Bob", Age: 25}, Position: "Engineer"}
    fmt.Println(emp.Greet()) // Метод Person доступен напрямую
    fmt.Println(emp.Work())
}

Встраивание — это композиция, а не наследование: Employee не является подтипом Person, но делегирует ему поведение. При необходимости можно переопределить метод, определив его с тем же именем на уровне Employee.

Подводные камни

• Получатель-значение vs указатель: если метод должен изменять структуру, используйте указатель. Иначе изменения не сохранятся.
• Пустой интерфейс interface{}: принимает любой тип, но требует приведения типа для использования конкретных методов.
• Встраивание и конфликты имён: если встроенные структуры имеют одинаковые поля или методы, возникает неоднозначность — нужно явно указывать тип.
• Отсутствие перегрузки методов: в Go нельзя определить два метода с одним именем, но разными параметрами. Используйте разные имена или интерфейсы.

Когда использовать

• Используйте структуры для моделирования сущностей с данными и поведением.
• Применяйте интерфейсы для абстракции и полиморфизма, особенно при написании функций, работающих с разными типами.
• Встраивание удобно для расширения функциональности без создания глубоких иерархий.

Коротко

• ООП в Go строится на структурах, методах, интерфейсах и встраивании, а не на классах и наследовании.
• Методы привязываются к структурам через получатель; выбирайте значение или указатель в зависимости от необходимости мутации.
• Интерфейсы реализуются неявно: достаточно иметь все методы интерфейса.
• Встраивание обеспечивает композицию и переиспользование кода, но не создаёт отношения «является».