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

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

Go имеет свой уникальный подход к объектно-ориентированному программированию. Это НЕ традиционное ООП с классами и наследованием, а так называемое "объектное программирование без классов". Go достигает ООП через композицию, методы и интерфейсы.

1. Структуры вместо классов

Go использует структуры (structs) вместо классов.

type Person struct {
    Name string
    Age  int
}

2. Методы (Methods)

Методы — это функции с получателем (receiver).

type Person struct {
    Name string
    Age  int
}

func (p Person) Greet() string {
    return "Привет, я " + p.Name
}

func (p *Person) HaveBirthday() {
    p.Age++
}

3. Композиция вместо наследования

Go использует композицию — встраивание структур вместо наследования.

type Animal struct {
    Name string
}

func (a Animal) Speak() string {
    return a.Name + " издаёт звук"
}

type Dog struct {
    Animal
    Breed string
}

4. Интерфейсы (Interfaces)

Интерфейсы определяют контракт поведения. Это ключевой инструмент для полиморфизма в Go.

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

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + " лает"
}

func (d Dog) Move() string {
    return d.Name + " бегает"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + " мяучит"
}

func (c Cat) Move() string {
    return c.Name + " ходит"
}

func describe(animal Animal) {
    fmt.Println(animal.Speak())
    fmt.Println(animal.Move())
}

5. Инкапсуляция (Encapsulation)

Go использует простое правило: маленькая буква — приватное, большая буква — публичное.

type BankAccount struct {
    balance float64  // Приватное
    owner   string   // Приватное
    AccountID string  // Публичное
}

func (a *BankAccount) GetBalance() float64 {
    return a.balance
}

func (a *BankAccount) Deposit(amount float64) error {
    if amount <= 0 {
        return errors.New("сумма должна быть положительной")
    }
    a.balance += amount
    return nil
}

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

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

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

type Rectangle struct {
    Width, Height float64
}

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

func printArea(s Shape) {
    fmt.Printf("Area: %.2f\n", s.Area())
}

7. Встраивание методов из структур

Встроенные структуры автоматически предоставляют свои методы.

type Reader struct{}
func (r Reader) Read() string {
    return "Читаю..."
}

type Writer struct{}
func (w Writer) Write() string {
    return "Пишу..."
}

type ReadWriter struct {
    Reader
    Writer
}

rw := ReadWriter{}
fmt.Println(rw.Read())    // "Читаю..."
fmt.Println(rw.Write())   // "Пишу..."

8. Type assertion для работы с интерфейсами

func processValue(v interface{}) {
    if str, ok := v.(string); ok {
        fmt.Println("Это строка:", str)
    }
}

func describe(v interface{}) {
    switch v.(type) {
    case string:
        fmt.Println("Строка")
    case int:
        fmt.Println("Число")
    }
}

Сравнение: Go vs Традиционное ООП

Практический пример: система логирования

type Logger interface {
    Log(message string)
    Error(message string)
}

type ConsoleLogger struct{}
func (c ConsoleLogger) Log(msg string) {
    fmt.Println("[INFO]", msg)
}
func (c ConsoleLogger) Error(msg string) {
    fmt.Println("[ERROR]", msg)
}

type Service struct {
    logger Logger
}

func (s Service) DoWork() {
    s.logger.Log("Начало работы")
}

service := Service{logger: ConsoleLogger{}}
service.DoWork()

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

Go реализует ООП не через классы и наследование, а через:

1. Структуры для группировки данных
2. Методы для добавления поведения
3. Композицию для переиспользования кода
4. Интерфейсы для полиморфизма и гибкости
5. Утиную типизацию для неявной реализации

Этот подход проще, чем традиционное ООП, но не менее мощный. Он поощряет композицию и избегает сложности иерархий классов. Go доказал, что можно написать высокоуровневый, правильно спроектированный код без явного наследования.