Как в GO наследовать и переопределить один метод?

Question

[Bekkazy]

Есть некий код на питоне. Реализовано через ООП.

class Animal:
    def __init__(self, name):
        self.name = name

    def say(self):
        print("My name is", self.name)

    def eat(self):
        print("My name is", self.name, "and i eat grass")

    def walk(self):
        print("My name is", self.name, "and i jump")

    def start(self):
        self.say()
        self.eat()
        self.walk()


class Shark(Animal):
    def eat(self):
        print("My name is", self.name, "and i eat seals")

    def walk(self):
        print("My name is", self.name, "and i swim in the ocean")


if __name__ == '__main__':
    a = Animal("Kangaroo")
    a.start()
    print("------------------------")
    s = Shark("Shark")
    s.start()

Очень надо такой же код реализовать на GO. Прогуглив, так и не нашел того что мне нужно. Может у вас будут подсказки?

Comments

[alfss]

Интерфейсы смотрите

[Bekkazy]

alfss, посмотрел, почитал, попробовал. но не нашел именно той реализации, которая показывала бы как написать вот это так, чтобы и в наследуемых методах не нужно было переписывать или явно вызывать во вложенном обьекте

def start(self):
        self.say()
        self.eat()
        self.walk()

Не подскажете чуть подробнее?

[alfss]

Как пример можно вот так, наверно можно, что-то получше даже сделать.

package main

import "fmt"

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

type ShapeOriginal struct {
	Side float64
}

type ShapeCube struct {
	ShapeOriginal
}

func (s ShapeOriginal) Area() float64 {
	return s.Side * s.Side
}

func (s ShapeOriginal) ShowSide() float64  {
	return s.Side
}

func (s ShapeCube) Area() float64 {
	return  6 * (s.Side * s.Side)
}


func main()  {
	origShape := ShapeOriginal{Side: 6}
	fmt.Println("Original Shape")
	fmt.Println(origShape.Area())
	fmt.Println(origShape.ShowSide())

	cubeShape := ShapeCube{ShapeOriginal{Side:6}}
	fmt.Println("Cube Shape")
	fmt.Println(cubeShape.Area())
	fmt.Println(cubeShape.ShowSide())
}

Answer 1

[Папа Стифлера]

Наследовать не получится. Нет наследования в Go.
Определяйте базовый тип, встраивайте в "наследника" и там же перекрывайте нужный метод.

Answer 2

[Александр Лямин]

Можно что-то вроде этого написать, будет очень похоже )

package main

import "fmt"

// Doer do
type Doer interface {
	eat()
}

// Animal is Animal
type Animal struct {
	name string
}

func (animal *Animal) eat() {
	fmt.Println("My name is", animal.name)
}

// Shark is Animal
type Shark struct {
	Animal
}

func (shark *Shark) eat() {
	fmt.Println("My name is", shark.name, "and i eat seals")
}

func start(doer Doer) {
	doer.eat()
}

func main() {
	animal := new(Animal)
	animal.name = "Kangaroo"
	start(animal)
	fmt.Println("-----------------------")
	shark := new(Shark)
	shark.name = "Shark"
	start(shark)
}