Go OOP 实现

Question

这个代码片段在 Go 中应该是什么样子的？当子类尚未定义时，如何从父类访问子类的方法？class Parent {abstract class MyParent {   abstract function doSomething();   function internal() {       return static::doSomething();   }}class MyChild extends MyParent {   function doSomething() {       return 'Test';   }}

Answer 1

Go 中没有继承（这是一个甜蜜点）。最接近的是嵌入父类型。

type Parent struct {}

func (p *Parent) doSomething() {

    fmt.Println("Test")

}

type MyChild struct {

    Parent

}

func main() {

    child := &MyChild{}

    child.doSomething() // print "Test"

}

查看https://golang.org/doc/effective_go.html#embedding

Answer 2

我相信你最终想要完成的事情类似于“模板方法”设计模式：

在软件工程中，模板方法模式是一种行为设计模式，它在一个方法中定义算法的程序骨架，称为模板方法，它将一些步骤推迟到子类中。

https://en.wikipedia.org/wiki/Template_method_pattern

AFAIK，在 Go 中实现这样的事情的唯一正确方法是使用 @pie-o-pah 和 @icza 所说的接口。我说“类似的东西”，因为您不能将带有接口的方法定义为接收者（即 Go 中没有诸如部分抽象类型之类的东西）。

正确的实现如下所示：

package main

import "fmt"

// --------------------------

// define your purely abstract type as an interface

type MyParent interface {

    doSomething() string

}

// define a function (your template method) which operates

// on that interface; an interface cannot be a function receiver,

// but it can always be a parameter

func internal(m MyParent) string {

    return m.doSomething()

}

// define the implementation

type MyChild struct {}

// implement the methods for the interface

func (m *MyChild) doSomething() string {

    return "Test"

}

// in Go any type which implements all methods in a given interface

// implements that interface implicitly, but you can "force" the

// compiler to check that for you using the following trick

// (basically try to assign a an instance of the interface to a variable,

// then discard it)

var _ MyParent = (*MyChild)(nil)

// -------------------------------

// test code

func main() {

  m := &MyChild{}

  fmt.Println(m.doSomething())

  fmt.Println(internal(m))

}

Answer 3

//It's called interface

type Parent interface{

    doSomething() string

}

//Use interface before defining implementation

func JustPrint(p Parent){

    fmt.Println(p.doSomething())

}

//Define MyChild

type MyChild SomeType

//You do not have to implement interface explicitly

//Just to define method needed would be enough

func (mc MyChild) doSomething() string{

    return "Test"

}