Gehen "erbschaft" - die Verwendung anonymer Typ in einen struct als parameter der Methode

Ich versuche, die Firma, das Konzept des inheritence, dass Go bietet (eher die "Komposition" als Reine inheritence, vielleicht). Jedoch, ich scheitern zu verstehen, warum ich kann nicht mit den "Eltern" - Typ als func parameter zu produzieren, eine generische Funktion, wirkt auf die parameter.

package main

import "log"

type Animal struct {
    Colour string
    Name string
}

type Dog struct {
    Animal
}

func PrintColour(a *Animal) {
    log.Printf("%s\n", a.Colour)
}


func main () {
    a := new (Animal)
    a.Colour = "Void"
    d := new (Dog)
    d.Colour = "Black"

    PrintColour(a)
    PrintColour(d)
}

Vorausgesetzt mein Verständnis falsch ist, wie kann ich erreichen, was ich will in Gehen?

Bearbeiten
Hinweis:

Möchte ich nicht anfügen, das Verhalten der Struktur
Ich würde gerne zu halten, der Typ pointer als parameter der Methode, weil ich arbeiten bin getrennt auf eine pet-Projekt und das erfordert-ich manipuliere das struct übergeben, bevor Sie dann auf ihn einwirkenden.
In Wirklichkeit, meine Dog struct müssten zusätzliche Felder/Mitglieder; hoffentlich nicht schlammig das Wasser weiter

InformationsquelleAutor Alex | 2014-02-03

go inheritance

13

Mag ich hier die Antworten so weit-und ich möchte hinzufügen, dass es erlaubt, statische Typüberprüfung an der Schnittstelle übergeben, die über eine Schnittstelle:
```
package main

import (
    "fmt"
)

type Animalizer interface {
    GetColour() string
}

type Animal struct {
    Colour string
    Name   string
}

type Dog struct {
    Animal
}

func (a *Animal) GetColour() string {
    return a.Colour
}

func PrintColour(a Animalizer) {
    fmt.Print(a.GetColour())
}

func main() {
    a := new(Animal)
    a.Colour = "Void"
    d := new(Dog)
    d.Colour = "Black"

    PrintColour(a)
    PrintColour(d)
}
```
Auf dem Spielplatz

Wird es möglich sein, weitere Felder hinzufügen, um Dog. Der Unterschied zu Uriel, die Antwort ist, dass Anrufe zu PrintColour scheitern wird zur compile-Zeit, wenn auch etwas anderes als ein struct implementieren Animalizer übergeben wird.

Auch Sie nicht haben, um ein typeswitch, da der compiler kennt eine Animalizer ist die Umsetzung GetColour.

Und schließlich das Verhalten (Druck) wird getrennt von der struct GetColour nur die Renditen der Farbe.
- Dies ist der Ansatz, den ich machen würde, nun, wenn ich versuche diese wieder. Danke!
InformationsquelleAutor Beat Richartz
4

Wenn Sie erklären, die PrintColour Methode auf die Animal geben, es wird "vererbt", wenn Sie Animal im Dog.

Dies ist bekannt als "Einbettung" in die Welt Gehen. Sehen Die "Einbettung" in Abschnitt Effektiver Gehen für mehr info.

Probieren Sie etwas wie:
```
package main

import "log"

type Animal struct {
    Colour string
    Name string
}

type Dog struct {
    Animal
}

func (a *Animal) PrintColour() {
    log.Printf("%s\n", a.Colour)
}


func main () {
    a := new (Animal)
    a.Colour = "Void"
    d := new (Dog)
    d.Colour = "Black"

    a.PrintColour()
    d.PrintColour()
}
```
Produziert:

2009/11/10 23:00:00 Nichtig

2009/11/10 23:00:00 Schwarz

Spielplatz
- Mein problem mit zu tun, dass (ich Ihr erklärt hatte das ich nicht will befestigen Sie die func-wie in der ursprünglichen Frage) ist, dass es eine utility-Funktion und so fühlt sich nicht "richtig" befestigt werden, um den Typ..ich werde überdenken meine design obwohl. Danke.
- Auf den zweiten Gedanken, ist es ein Weg, um dieses, wo ich kann - pass in einen Eltern-Typ der Methode ohne Einbettung?
InformationsquelleAutor Intermernet

Könnten Sie versuchen, es mit interface{}

package main

import ("fmt"
       "reflect")

type Animal struct {
    Colour string
    Name string
}

type Dog struct {
    Animal
}

func PrintColour(a interface{}) {
    switch a.(type){
        case *Dog:
            fmt.Printf("Dog %s\n", a.(*Dog).Colour)
        case *Animal:
            fmt.Printf("Aimal %s\n", a.(*Animal).Colour)
        default:        
            fmt.Printf("hmm %s\n", reflect.TypeOf(a))

    }
}


func main () {
    a := new (Animal)
    a.Colour = "Void"
    d := new (Dog)
    d.Colour = "Black"

    PrintColour(a)
    PrintColour(d)

}

Gut zu finden, vielen Dank. Ich denke, ich werde es saugen, bis und redesign; ich wollte nicht auf "attach" Verhalten, um meine structs oder schaffen Schnittstellen), da das Verhalten nicht, aber ach ich werde einfach weiter üben 🙂

InformationsquelleAutor Milan Halada

Embedded (anonym) - Feld kann immer noch explizit auf die über seine typename :

package main

import "log"

type Animal struct {
    Colour string
    Name   string
}

type Dog struct {
    Animal
}

func PrintColour(a *Animal) {
    log.Printf("%s\n", a.Colour)
}

func main() {
    a := new(Animal)
    a.Colour = "Void"
    PrintColour(a)

    d := new(Dog)
    d.Colour = "Black"
    //you can access the underlying "Animal" through "d.Animal"
    PrintColour(&d.Animal)
}

Spielplatz

In der Referenz : der Satz nach der zweiten code-block wird erklärt, wie Sie erklären, ein "anonymer" - Feld, und Staaten :

Den unqualifizierten Art name dient, wie der name des Feldes.

Yep, danke, bewusst, aber es ist die ganze Art ich will, als ich brauche, zu "Erben" gemeinsame Felder (z.B. Colour), aber auch für einen speziellen Typ.

InformationsquelleAutor LeGEC

1

Mein Beispiel ist vielleicht nicht groß, aber Sie können tun, was Sie wollen auf diese Weise:

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

Verwenden Sie im wesentlichen eine Schnittstelle definieren, die gemeinsame Funktionalität, die Sie verfügbar machen möchten, um die Außenwelt in all Ihren Arten und eingebetteten Schriften.

(Mein Beispiel ist vielleicht nicht das beste, aber es funktioniert)

InformationsquelleAutor Daniel Williams

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.