Go 语言中的多态性

Question

我正在学习 go lang，我想知道是否有办法做这样的事情：type Foo struct {   ...}type Bar struct {   Foo   ...}func getFoo() Foo {   return Bar{...}}在面向对象的语言中，这样的代码应该可以正常工作，但是在 go 中它会抛出一个错误，说getFoo()必须返回类 Foo 的实例。有没有办法做类似于我在 Go 中描述的多态性？

Answer 1

Go 不是典型的 OO 语言。此外，每种语言都有自己的做事方式。你可以使用界面和组合来实现你想要的，如下图：

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

在 Go 中，多态是通过实现接口来实现的。

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

}

因此，任何东西都实现了一个空接口。

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

}

Answer 3

如果您知道要使用的类型，则可以将它们放入数组列表中以实现一种多态实例化：

package main

import (

  "fmt"

  "encoding/json"

)

type  Hans struct{

      Miau string

    }

type  Keule struct {

  Wuff string

}

func (K Keule)ppp() {

  fmt.Printf(K.Wuff)

}

func (K Hans)ppp() {

  fmt.Printf(K.Miau)

}

func (K Keule)TypeInfo() int {

  return 0

}

func (K Hans)TypeInfo() int {

  return 1

}

type Mega interface {

  ppp()

  TypeInfo() int

}

var j_a = `{

  "Kein_Alter": "nix",

  "Miau": "lala",

  "class": 0

}`

var j_b = `{

  "Alter": "nix",

  "Wuff": "lolo",

  "Class": 1

}`

type Class struct {

  Class int

}

func (K *Class)ppp() {

  fmt.Printf("%d", K.Class)

}

func Unmarshal_K(b []byte) (Mega, error) {

  var k Keule

  err := json.Unmarshal([]byte(j_a), &k)

  return k, err

}

func Unmarshal_H(b []byte) (Mega, error) {

  var k Hans

  err := json.Unmarshal([]byte(j_a), &k)

  return k, err

}

var UList = []func(b []byte) (Mega, error) {Unmarshal_H, Unmarshal_K}

func main() {

  var mv Class

  err := json.Unmarshal([]byte(j_a), &mv)

  if err != nil {

    panic(err)

  }

  

  hiho, err := UList[mv.Class]([]byte(j_a))

  if err != nil {

    panic(err)

  }

  hiho.ppp()

}