GoSuda

Go Interfaces er ikke arv

By Yunjin Lee
views ...

Oversigt

Go-interfaces gør det nemt for flere structs at have funktioner med de samme argumenter og returværdier, men det adskiller sig fra Java's extends-nøgleord, der forlænger og overskriver den interne funktionsadfærd. Selvom en korrekt forståelse af Go's kompositionelle kodegenbrug ville forhindre forveksling med arv, er det svært at opnå en teoretisk perfekt forståelse fra starten. Lad os undersøge dette med et scenario, der ofte fører til fejl.

Hyppige fejl

Begyndere kan begå følgende fejl:

 1package main
 2import (
 3	"fmt"
 4	"strings"
 5)
 6
 7type Fruits interface {
 8	GetBrix() float64
 9	GetName() string
10	SetLabel()
11	GetLabel(string) string
12	PrintAll()
13}
14
15type Apple struct {
16	Label string
17	Name  string
18	Brix  float64
19}
20
21type Watermelon struct {
22	Label string
23	Name  string
24	Brix  float64
25}
26
27func (a *Apple) PrintAll() {
28	fmt.Printf("Fruit: %s, Label: %s, Brix: %v\n", a.Name, a.Label, a.Brix)
29}
30
31const (
32	NO_LABEL = "EMPTY LABEL"
33)
34
35func (a *Apple) SetLabel(lbl string) {
36	a.Brix 	= 14.5;
37	a.Name 	= "apple";
38	lbl_lower := strings.ToLower(lbl)
39	if strings.Contains(lbl_lower, a.Name) {
40		fmt.Println("Succeed: Label was ", lbl)
41		a.Label = lbl;
42	} else {
43		fmt.Println("Failed: Label was ", lbl)
44		a.Label = NO_LABEL;
45	}
46}
47
48func (w *Watermelon) SetLabel(lbl string) {
49	w.Brix = 10;
50	w.Name = "watermelon";
51	lbl_lower := strings.ToLower(lbl)
52	if strings.Contains(lbl_lower, w.Name) {
53		w.Label = lbl;
54	} else {
55		w.Label = NO_LABEL;
56	}
57}
58
59func main() {
60	fmt.Println("Inheritance test #1")
61	apple := new(Apple)
62	watermelon := apple
63	apple.SetLabel("Apple_1")
64	fmt.Println("Apple, before copied to Watermelon")
65	apple.PrintAll()
66	watermelon.SetLabel("WaterMelon_2")
67	fmt.Println("Apple, after copied to Watermelon")
68	apple.PrintAll()
69	fmt.Println("Watermelon, which inherited Apple's Method")
70	watermelon.PrintAll()
71}

Denne kode virker problemfri, hvis man fejlagtigt antager, at Go følger traditionel arv. Outputtet er dog som følger:

1Inheritance test #1
2Succeed: Label was  Apple_1
3Apple, before copied to Watermelon
4Fruit: apple, Label: Apple_1, Brix: 14.5
5Failed: Label was  WaterMelon_2
6Apple, after copied to Watermelon
7Fruit: apple, Label: EMPTY LABEL, Brix: 14.5
8Watermelon, which inherited Apple's Method
9Fruit: apple, Label: EMPTY LABEL, Brix: 14.5

Her bliver Go's adfærd klar.

1watermelon := apple

Denne kode konverterer slet ikke Apple til en Watermelon-klasse. I stedet er watermelon blot en pointer til apple.

Det skal understreges igen, at Go følger ikke traditionelle arvekoncepter.

Hvis man skriver kode med denne misforståelse, vil det føre til kritiske fejl såsom meningsløs pointergenerering og uventet kopiering af funktioner til andre structs.

Hvad ville så være et eksempel på god kode?

Passende eksempler i Go-sprog

 1package main
 2import (
 3	"fmt"
 4	"strings"
 5)
 6
 7type Fruits interface {
 8	GetBrix() float64
 9	GetName() string
10	SetLabel()
11	GetLabel(string) string
12	PrintAll()
13}
14
15type BaseFruit struct {
16	Name  string
17	Brix  float64
18}
19
20type Apple struct {
21	Label string
22	Fruit BaseFruit
23}
24
25type Watermelon struct {
26	Label string
27	Fruit BaseFruit
28
29}
30
31func (b *BaseFruit) PrintAll() {
32	fmt.Printf("Fruit: %s, Brix: %v\n", b.Name, b.Brix)
33}
34
35
36const (
37	NO_LABEL = "EMPTY LABEL"
38)
39
40func (a *Apple) SetLabel(lbl string) {
41	a.Fruit.Brix 	= 14.5;
42	a.Fruit.Name 	= "apple";
43	lbl_lower := strings.ToLower(lbl)
44	if strings.Contains(lbl_lower, a.Fruit.Name) {
45		fmt.Println("Succeed: Label was ", lbl)
46		a.Label = lbl;
47	} else {
48		fmt.Println("Failed: Label was ", lbl)
49		a.Label = NO_LABEL;
50	}
51	fmt.Printf("Fruit %s label set to %s\n", a.Fruit.Name, a.Label);
52	a.Fruit.PrintAll()
53}
54
55func (w *Watermelon) SetLabel(lbl string) {
56	w.Fruit.Brix = 10;
57	w.Fruit.Name = "Watermelon";
58	lbl_lower := strings.ToLower(lbl)
59	if strings.Contains(lbl_lower, w.Fruit.Name) {
60		w.Label = lbl;
61	} else {
62		w.Label = NO_LABEL;
63	}
64	fmt.Printf("Fruit %s label set to %s\n", w.Fruit.Name, w.Label);
65	w.Fruit.PrintAll()
66}
67
68func main() {
69	apple := new(Apple)
70	watermelon := new(Watermelon)
71	apple.SetLabel("Apple_1")
72	watermelon.SetLabel("WaterMelon_2")
73}

Det er dog muligt at få det til at se ud som arv i Go. Et eksempel på dette er anonym indlejring. Dette er muligt, hvis den interne struct erklæres som en navnløs struct. I sådanne tilfælde er det muligt at tilgå felterne i under-struct'en uden eksplicit at angive dem. Ved at bruge dette mønster, hvor felterne i under-struct'en promoveres til den overordnede struct, kan læsbarheden forbedres i visse tilfælde. Det anbefales dog ikke at bruge det, når under-struct'en skal vises eksplicit.

 1package main
 2import (
 3	"fmt"
 4	"strings"
 5)
 6
 7type Fruits interface {
 8	GetBrix() float64
 9	GetName() string
10	SetLabel()
11	GetLabel(string) string
12	PrintAll()
13}
14
15type BaseFruit struct {
16	Name  string
17	Brix  float64
18}
19
20type Apple struct {
21	Label string
22	BaseFruit
23}
24
25type Watermelon struct {
26	Label string
27	BaseFruit
28
29}
30
31func (b *BaseFruit) PrintAll() {
32	fmt.Printf("Fruit: %s, Brix: %v\n", b.Name, b.Brix)
33}
34
35
36const (
37	NO_LABEL = "EMPTY LABEL"
38)
39
40func (a *Apple) SetLabel(lbl string) {
41	a.Brix 	= 14.5;
42	a.Name 	= "apple";
43	lbl_lower := strings.ToLower(lbl)
44	if strings.Contains(lbl_lower, a.Name) {
45		fmt.Println("Succeed: Label was ", lbl)
46		a.Label = lbl;
47	} else {
48		fmt.Println("Failed: Label was ", lbl)
49		a.Label = NO_LABEL;
50	}
51	fmt.Printf("Fruit %s label set to %s\n", a.Name, a.Label);
52	a.PrintAll()
53}
54
55func (w *Watermelon) SetLabel(lbl string) {
56	w.Brix = 10;
57	w.Name = "Watermelon";
58	lbl_lower := strings.ToLower(lbl)
59	if strings.Contains(lbl_lower, w.Name) {
60		w.Label = lbl;
61	} else {
62		w.Label = NO_LABEL;
63	}
64	fmt.Printf("Fruit %s label set to %s\n", w.Name, w.Label);
65	w.PrintAll()
66}
67
68func main() {
69	apple := new(Apple)
70	watermelon := new(Watermelon)
71	apple.SetLabel("Apple_1")
72	watermelon.SetLabel("WaterMelon_2")
73}

I dette eksempel er der følgende forskel:

1w.PrintAll() // w.Friut.PrintAll() kaldes ikke, men automatisk promovering via en navnløs struct

Begge eksempler fremhæver følgende vigtige punkter:

  • main bør være enkel, og funktioner bør være opdelt efter funktionalitet.
  • Brug forskellige objekter til forskellige structs.
  • Brug interne structs, når deling er nødvendig.

Hvilke fordele har denne programmeringsfilosofi?

Fordele

  • Klar adskillelse mellem metoder, der kræver deling, og dem, der ikke gør.
  • Adskillelse af ansvar for individuelle structs og metoder.
  • Strukturelt adskilt kode baseret på specificerede funktionskrav.

I begyndelsen kan Go-sproget virke uvant, da det adskiller sig fra traditionel OOP, men når man først er vant til det, muliggør det eksplicit programmering.

Resumé

  • Isoler ansvar.
  • Opdel i detaljerede struct-enheder.
  • Metoder bør ikke forstås som Javas abstrakte klasser.
  • Programmer eksplicit og specifikt. Go-sproget bør behandles enklere og mere individuelt end den traditionelle OOP-model. Lad os skrive koden trinvist og strukturelt adskilt i stedet for at programmere ekspansivt.