కూర్పు (పొందుపరచడం)

గో కి వారసత్వం లేదు. పునర్వినియోగానికి అనువైన సమాధానం కంపోజిషన్, మరియు ముఖ్యంగా ** ఎంబెడ్డింగ్**: ఒక రకంతో సహా ఫీల్డ్ పేరు ఇవ్వకుండా మరొక దాని లోపల. క్షేత్రాలు మరియు పద్ధతులు పొందుపరిచిన రకం ప్రమోట్ చేయబడింది, నేరుగా అందుబాటులోకి వస్తుంది అవి బయటి రకానికి చెందినవి.

స్ట్రక్ట్ ఎంబెడ్డింగ్

type Animal struct {
    Name string
}

func (a Animal) Greet() string {
    return "ciao da " + a.Name
}

type Dog struct {
    Animal        // embedding — NO field name
    Breed string
}

c := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Pastore",
}

fmt.Println(c.Name)         // "Rex" — promoted from Animal
fmt.Println(c.Greet())      // "ciao da Rex" — promoted method
fmt.Println(c.Breed)        // own field

పొందుపరిచిన ఫీల్డ్ ** ఇప్పటికీ రకం పేరు ద్వారా యాక్సెస్ చేయవచ్చు**: c.Animal.Name పని చేస్తుంది మరియు c.Nameకి సమానంగా ఉంటుంది. ఇది ఎప్పుడు అవసరం ఘర్షణలు ఉన్నాయి.

ఓవర్‌రైడ్ (పాక్షిక): పద్ధతి "షాడోయింగ్"

ప్రమోట్ చేయబడిన అదే పేరుతో బాహ్య రకం పద్ధతిని నిర్వచిస్తే ఒకటి, దాని పద్ధతి "విజయం". లోపల నుండి మీరు ఎల్లప్పుడూ ఎంబెడెడ్ చేరుకోవచ్చు రకం పేరు ద్వారా ఒకటి:

func (c Dog) Greet() string {
    return "BAU! " + c.Animal.Greet()
}

ఇది పాలిమార్ఫిక్ వారసత్వం కాదు: ఇది కేవలం లెక్సికల్ నేమ్ రిజల్యూషన్. పాలిమార్ఫిజం కోసం మీరు ** ఇంటర్‌ఫేస్‌లను** (మాడ్యూల్ 6) ఉపయోగిస్తారు.

బహుళ పొందుపరచడం

మీరు అనేక రకాలను పొందుపరచవచ్చు:

type Logger struct{ /*...*/ }
func (l Logger) Log(msg string) { /*...*/ }

type Timer struct{ /*...*/ }
func (t Timer) Now() time.Time { /*...*/ }

type Service struct {
    Logger
    Timer
    Name string
}

s := Service{Name: "api"}
s.Log("start")   // promoted from Logger
s.Now()          // promoted from Timer

రెండు ఎంబెడెడ్ రకాలు ఒకే పేరుతో పద్ధతిని కలిగి ఉంటే, ప్రత్యక్ష ప్రాప్యత అస్పష్టంగా మారుతుంది మరియు కంపైలర్‌కు స్పష్టమైన రూపం అవసరం (s.Logger.Foo() లేదా s.Timer.Foo()).

ఇంటర్ఫేస్ పొందుపరచడం

ఇంటర్‌ఫేస్‌లను కూడా "ఎంబెడెడ్" చేయవచ్చు (మాడ్యూల్ 6 చూడండి):

type ReadWriter interface {
    io.Reader
    io.Writer
}

ఇది Reader మరియు Writer పద్ధతుల కలయికకు సమానం.

స్పష్టమైన కూర్పును ఎప్పుడు ఉపయోగించాలి (పొందుపరచడం కాదు)

మీకు పేరు పెట్టబడిన ఫీల్డ్ మరియు ఆటో-ప్రమోషన్ లేకపోతే, సాదా ఉపయోగించండి కూర్పు:

type Dog struct {
    Anim  Animal    // NORMAL field, no promotion
    Breed string
}
c.Anim.Name   // you need the field name

పొందుపరచడం అనేది సులభ ప్రతినిధి సాధనం, డిజైన్ ఎంపిక కాదు స్పష్టమైన కూర్పు కంటే ఖచ్చితంగా ఉత్తమం: మీకు నిజంగా కావలసినప్పుడు దాన్ని ఉపయోగించండి అంతర్గత రకం APIని ప్రోత్సహించడానికి.

దీనిని ప్రయత్నించండి

type B struct { /* extends A? */ }

రీక్యాప్

• వారసత్వం లేదు: మీరు ** ఎంబెడ్డింగ్**తో కంపోజ్ చేస్తారు.
• పొందుపరచడం = స్ట్రక్ట్‌లో ఫీల్డ్ పేరు లేకుండా టైప్ రాయడం.
• పొందుపరిచిన రకానికి చెందిన ఫీల్డ్‌లు మరియు పద్ధతులు ప్రమోట్ చేయబడతాయి.
• స్పష్టమైన యాక్సెస్ ఎల్లప్పుడూ అందుబాటులో ఉంటుంది: outer.Inner.Field.
• "లెక్సికల్" ఓవర్‌రైడ్: బయటి రకం యొక్క పద్ధతి ప్రమోట్ చేయబడిన దానిని నీడ చేస్తుంది.
• పొందుపరచడం ≠ అనేది-a: పాలిమార్ఫిజం కోసం ఇంటర్‌ఫేస్‌లు.