polimorfismo in Go lang

Question

sto imparando andare lang e mi chiedevo se c'è un modo per fare qualcosa di simile:

type Foo struct { 
    ... 
} 

type Bar struct { 
    Foo 
    ... 
} 

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

In un linguaggio orientato agli oggetti, tale codice dovrebbe funzionare senza problemi, ma in movimento mi viene un errore, dicendo che getFoo() deve restituire un'istanza di classe Foo.

C'è un modo per fare il polimorfismo simile a quello che ho descritto in Go?

Answer 1

Go non è un tipico linguaggio OO. Inoltre ogni lingua ha il proprio modo di fare le cose. È possibile utilizzare l'interfaccia e la composizione per raggiungere ciò che si desidera, come illustrato di seguito:

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

In Vai, il polimorfismo si ottiene da interfacce di attuazione.

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 
} 

Pertanto, qualsiasi cosa implementa un'interfaccia vuota.

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 
}