Polimorfizm idź lang

Question

uczę odchodzenie lang i zastanawiałem się, czy istnieje sposób, aby zrobić coś takiego:

type Foo struct { 
    ... 
} 

type Bar struct { 
    Foo 
    ... 
} 

func getFoo() Foo { 
    return Bar{...} 
} 

W języku obiektowym, taki kod powinien działać bez problemów, ale w podróży rzuca mi błąd, mówiąc, że getFoo() musi zwrócić instancję klasy Foo.

Czy istnieje sposób na polimorfizm podobny do tego, co opisałem w Go?

Answer 1

Go nie jest typowym językiem OO. Także każdy język ma własny sposób robienia rzeczy. Można użyć interfejsu i kompozycji, aby osiągnąć to, czego pragniesz, jak pokazano poniżej:

package main 

import "fmt" 

type Foo interface { 
    printFoo() 
} 

type FooImpl struct { 

} 

type Bar struct { 
    FooImpl 
} 

type Bar2 struct { 
    FooImpl 
} 

func (f FooImpl)printFoo(){ 
    fmt.Println("Print Foo Impl") 
} 

func getFoo() Foo { 
    return Bar{} 
} 

func main() { 
    fmt.Println("Hello, playground") 
    b := getFoo() 
    b.printFoo() 
} 

http://play.golang.org/p/iR8QkD3DnP

Answer 2

w Go, polimorfizm jest osiągnięty poprzez wdrożenie interfejsów.

type Being interface { 
     somemethod() 
} 

type Foo struct {} 

type Bar struct { 
     Foo 
} 

type Baz struct { 
     Foo 
} 

// `Bar` and `Baz` implement `Being` 
func (b *Bar) somemethod() {} 
func (b *Baz) somemethod() {} 

func getAnyFoo(b *Being) Foo { 
    return b.Foo 
} 

Dlatego nic nie implementuje pustego interfejsu.

type Foo struct {} 

type Bar struct { 
     Foo 
} 

// Get anything and extract its `Foo` if anything is a Bar 
func getAnyFoo(i interface{}) Foo { 
     // Normally this would need a type switch to check the type 
     mybar := i.(Bar) 
     return mybar.Foo 
}