GoSuda

Rozhrania v Go nie sú dedičnosťou

By Yunjin Lee
views ...

Prehľad

Rozhrania Go umožňujú viacerým štruktúram ľahko mať funkcie s rovnakými argumentmi a návratovými hodnotami, avšak líšia sa od spôsobu, akým kľúčové slovo extends v Jave primerane rozširuje a prepisuje správanie vnútorných funkcií. Ak sa má predišlo zámene s dedičnosťou, je nevyhnutné správne pochopiť kompozičné opätovné použitie kódu v Go, ale dosiahnuť dokonalé teoretické pochopenie od začiatku je náročné. Poďme sa na to pozrieť prostredníctvom scenárov náchylných na chyby.

Časté chyby

Začiatočníci sa môžu dopúšťať nasledujúcich chýb:

 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}

Tento kód sa môže zdať bezproblémový, ak sa mylne predpokladá, že Go sa riadi tradičným dedičstvom. Výsledok jeho spustenia je však nasledovný:

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

Tu sa správanie Go stáva jednoznačným.

1watermelon := apple

Tento kód vôbec nekonvertuje Apple na triedu Watermelon.watermelon je len ukazovateľ na apple.

Opätovne zdôrazňujeme, že Go sa neriadi tradičným konceptom dedičnosti.

Ak sa kód píše s týmto nedorozumením, môžu nastať kritické chyby, ako je vytváranie zbytočných ukazovateľov a neočakávané kopírovanie funkcií pre iné štruktúry.

Aký by teda bol príklad osvedčeného kódu?

Vhodný príklad v jazyku Go

 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}

Avšak, v jazyku Go je možné dosiahnuť vzhľad ako keby išlo o dedičnosť. Príkladom je anonymné vkladanie. To je možné deklarovaním vnútornej štruktúry ako bezmennej štruktúry. V takýchto prípadoch je možné pristupovať k poliam podradenej štruktúry bez explicitného uvedenia. Použitie tohto vzoru na propagáciu polí podradenej štruktúry do nadradenej štruktúry môže v niektorých prípadoch zlepšiť čitateľnosť. Neodporúča sa však používať v prípadoch, keď je potrebné explicitne zobraziť podradenú štruktúru.

 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}

V tomto príklade sú tieto rozdiely:

1w.PrintAll() // Automatické volanie propagácie cez bezmennú štruktúru, nie w.Friut.PrintAll()

Oba príklady zdôrazňujú tieto dôležité body:

  • main by mala byť zjednodušená, funkcie by mali byť rozdelené podľa ich funkčnosti.
  • Pre rôzne štruktúry používajte rôzne objekty.
  • Ak je potrebné zdieľanie, použite vnútorné štruktúry.

Aké výhody prináša táto programovacia filozofia?

Výhody

  • Jasné rozlíšenie medzi metódami, ktoré vyžadujú zdieľanie, a tými, ktoré nie.
  • Oddelenie zodpovednosti za jednotlivé štruktúry a metódy.
  • Štrukturálne oddelený kód podľa požadovaných funkčných špecifikácií.

Spočiatku môže byť jazyk Go neznámy, pretože sa líši od tradičného OOP, ale po zvyknutí si umožňuje explicitné programovanie.

Zhrnutie

  • Izolujte zodpovednosť.
  • Rozdeľte kód detailne na úrovni štruktúr.
  • Metódy by sa nemali chápať ako abstraktné triedy v Jave.
  • Praktizujte explicitné a konkrétne programovanie. Jazyk Go je jednoduchší a mal by sa spracovávať individuálne v porovnaní s tradičným OOP modelom. Namiesto rozsiahleho programovania by sme mali písať kód postupne a štrukturálne oddelene.