Встраивание вместо наследования в Движении

Решающий принцип Банды 4 - «предпочитать композицию наследованию»; Go заставляет следовать за ним; -).

Единственными реальными вариантами использования наследования являются:

• Полиморфизм

  • Система «статической утиной типизации» интерфейса Go решает эту проблему

• Заимствование реализации из другого класса

  • Это то, что встраивание предназначено для

Подход Go не совсем отображает 1-к-1, рассмотрим этот классический пример наследования и полиморфизма в Java ( на основе этого ):

//roughly in Java (omitting lots of irrelevant details)
//WARNING: don't use at all, not even as a test

abstract class BankAccount
{
    int balance; //in cents
    void Deposit(int money)
    {
        balance += money;
    }

    void withdraw(int money)
    {
        if(money > maxAllowedWithdrawl())
            throw new NotEnoughMoneyException();
        balance -= money;
    }

    abstract int maxAllowedWithdrawl();
}

class Account extends BankAccount
{
    int maxAllowedWithdrawl()
    {
        return balance;
    }
}

class OverdraftAccount extends BankAccount
{
    int overdraft; //amount of negative money allowed

    int maxAllowedWithdrawl()
    {
        return balance + overdraft;
    }
}

Здесь наследование и полиморфизм вместе, и вы не можете перевести это на Go без изменения базовой структуры.

Я не углублялся в Go, но полагаю, это будет выглядеть примерно так:

//roughly Go? .... no?
//for illustrative purposes only; not likely to compile
//
//WARNING: This is totally wrong; it's programming Java in Go

type Account interface {
    AddToBalance(int)
    MaxWithdraw() int
}

func Deposit(account Account, amount int) {
    account.AddToBalance(amount)
}

func Withdraw(account Account, amount int) error {
    if account.MaxWithdraw() < amount {
        return errors.New("Overdraft!")
    }
    account.AddToBalance(-amount)
    return nil
}

type BankAccount {
    balance int
}

func (account *BankAccount) AddToBalance(amount int) {
    account.balance += amount;
}

type RegularAccount {
    *BankAccount
}

func (account *RegularAccount) MaxWithdraw() int {
    return account.balance //assuming it's allowed
}

type OverdraftAccount {
    *BankAccount
    overdraft int
}

func (account *OverdraftAccount) MaxWithdraw() int {
    return account.balance + account.overdraft
}

Согласно примечанию, это полностью неправильный способ кодирования, поскольку Java выполняется на Go. Если бы кто-то написал такую ​​вещь на Go, она, вероятно, была бы организована иначе, чем эта.

Я только сейчас изучаю Go, но, поскольку вы спрашиваете мнение, я предлагаю его на основе того, что мне известно до сих пор. Встраивание, по-видимому, типично для многих других вещей в Go, что является явной языковой поддержкой лучших практик, которые уже применяются в существующих языках. Например, как заметил Алекс Мартелли, «Банда четырех» говорит «предпочитать композицию наследованию». Go не только удаляет наследование, но и делает композицию более простой и мощной, чем в C ++ / Java / C #.

Я был озадачен комментариями типа «Go не предоставляет ничего нового, чего я уже не могу сделать на языке X» и "Зачем нам нужен другой язык?" Мне кажется, что с одной стороны Go не предоставляет ничего нового, чего раньше нельзя было сделать с помощью некоторой работы, но с другой стороны,