Go OOP Realisierung

Question

Wie soll dieser Codeausschnitt in Go aussehen? Wie kann ich auf die Methode der Kindklasse von der Elternklasse zugreifen, wenn die Kindklasse noch nicht definiert ist?

class Parent { 

abstract class MyParent { 
    abstract function doSomething(); 

    function internal() { 
     return static::doSomething(); 
    } 
} 

class MyChild extends MyParent { 
    function doSomething() { 
     return 'Test'; 
    } 
} 

Answer 1

//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" 
} 

Answer 2

Wie @icza sagte, gibt es keine Vererbung in Go (das ist ein Sweetspot ist). Am nächsten wäre das Einbetten eines Elterntyps.

type Parent struct {} 
func (p *Parent) doSomething() { 
    fmt.Println("Test") 
} 

type MyChild struct { 
    Parent 
} 

func main() { 
    child := &MyChild{} 
    child.doSomething() // print "Test" 
} 

Check out https://golang.org/doc/effective_go.html#embedding

Answer 3

Ich glaube, was Sie versuchen, am Ende zu erreichen, ist so etwas wie die "Template-Methode" Entwurfsmuster:

In Software-Engineering, die Das Vorlagenmethodenmuster ist ein Verhaltensmuster , das das Programmskelett eines Algorithmus in einer -Methode definiert, die Vorlagenmethode genannt wird, die einige Schritte zu Unterklassen verschiebt.

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

AFAIK, der einzig richtige Weg, so etwas wie dies in Go zu erreichen, ist Schnittstellen wie @ pie-o-pah zu verwenden und @icza gesagt hat. Ich sage "etwas Ähnliches", weil Sie Methoden mit Schnittstellen nicht als Empfänger definieren können (d. H. Es gibt keinen teilweise abstrakten Typ in Go).

Eine korrekte Implementierung würde wie folgt aussehen:

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)) 
}