akrennmair

package main

import (
	"fmt"
)

type Foo struct {
	Foo1 int
}

akrennmair

package main

import (
	"fmt"
)

type Vehicle struct {
	speed int
}

akrennmair

        a := NewAmphibian()
        a.Accelerate(10)
        a.Swim(true)
        a.Accelerate(20)
        fmt.Printf("amphibian speed swimming: %d kph\n", a.Speed())
        a.Swim(false)
        fmt.Printf("amphibian speed on land: %d kph\n", a.Speed())

        var d Drivable
        d = a

akrennmair

ype Amphibian struct {
        Car
        Boat
        swimming bool
}

func NewAmphibian() *Amphibian {
        a := new(Amphibian)
        a.swimming = false
        return a

akrennmair

vehicle.go:65: Amphibian.Accelerate is ambiguous
vehicle.go:65: cannot use a (type *Amphibian) as type Drivable in return argument:
	*Amphibian does not implement Drivable (missing Accelerate method)

akrennmair

type Amphibian struct {
        Car
        Boat
}

func NewAmphibian() Drivable {
        a := new(Amphibian)
        return a
}

akrennmair

type Boat struct {
        Vehicle
}

func(b *Boat) Accelerate(delta uint) {
        b.Vehicle.speed += int(delta)
}

func(b *Boat) Brake(delta uint) {
        b.Vehicle.speed -= int(delta)

akrennmair

type Car struct {
        Vehicle
}

func(c *Car) Accelerate(delta uint) {
        c.Vehicle.speed += int(delta)
}

func(c *Car) Brake(delta uint) {
        c.Vehicle.speed -= int(delta)

akrennmair

type Car struct {
        Vehicle
}

func(c *Car) Accelerate(delta uint) {
        c.Vehicle.speed += int(delta)
}

func(c *Car) Brake(delta uint) {
        c.Vehicle.speed -= int(delta)

akrennmair

type Drivable interface {
        Accelerate(delta uint)
        Brake(delta uint)
        Speed() int
}