Go interface method signatures సమితిని నిర్వచిస్తుంది — ఇది ఆচరణ యొక్క ఒక ఒప్పందం. కీలకంగా, interfaces 암묵적으로 సంతృప్తి చెందుతాయి: ఆ methods ఉన్న ఏదైనా type explicit "implements" declaration లేకుండా స్వయంచాలకంగా interface ని సంతృప్తిపరుస్తుంది. ఈ structural, duck-typing విధానం విశిష్టమైనది మరియు శక్తిశాలីనది.
Speaker {
Speak()
}
Dog {}
Speak() { }
Cat {}
Speak() { }
s Speaker = Dog{}
s.Speak()
implements keyword లేదు — ఒక type interface యొక్క అన్ని methods ఉంటే, అది స్వయంచాలకంగా interface ని సంతృప్తిపరుస్తుంది. ఇది interface ను దాని implementations నుండి వేరుపరుస్తుంది (implementer interface యొక్క ఉనికి గురించి కూడా తెలుసుకోవాలసిన అవసరం లేదు).
func announce(s Speaker) { // accepts ANY type that has Speak()
fmt.Println(s.Speak())
}
announce(Dog{}) // "Woof"
announce(Cat{}) // "Meow"
speakers := []Speaker{Dog{}, Cat{}} // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
Interfaces polymorphism ను ప్రారంభిస్తాయి — ఆచరణకు వ్యతిరేకంగా కోడ్ రాయండి, మరియు ఏదైనా సమానమైన type పనిచేస్తుంది.
anyvar x interface{} // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) } // accepts anything
Empty interface (interface{} / any) ఏదైనా విలువను కలిగి ఉంటుంది — type ముందుగా తెలియనప్పుడు ఉపయోగించబడుతుంది (అయితే generics ఇప్పుడు తరచుగా దీనిని భర్తీ చేస్తుంది).
type Stringer interface { String() string } // controls fmt printing
type error interface { Error() string } // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
Standard library యొక్క చాలా భాగం చిన్న interfaces (io.Reader/io.Writer, error, Stringer) పై నిర్మితమైనది — వాటిని implement చేయడం మీ types ను మొత్తం ecosystem లో పనిచేయడానికి సక్షమ చేస్తుంది.
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
Interfaces Go యొక్క డిజైన్ మరియు abstraction మరియు polymorphism కు దానిని విధానం కు కేంద్రీయమైనవి — మరియు వాటి implicit satisfaction (implements keyword లేదు; structural typing) భాష లోని అత్యంత విశిష్టమైన మరియు శక్తిశాలీ లక్షణాలలో ఒకటి.
ఈ decoupling అంటే types మరియు interfaces స్వతంత్రంగా పరిణామం చెందుతాయి, మీరు వాటిని satisfy చేసే types తర్వాత interfaces నిర్వచించవచ్చు, మరియు ఏదైనా సమానమైన type interface-based కోడ్ లోకి స్వయంచాలకంగా plug చేయబడుతుంది — limp చేయడానికి, loosely-coupled డిజైన్లను ప్రారంభిస్తుంది మరియు సులభమైన testing (mock implementations లో swap).
Implicit implementation, interfaces ద్వారా polymorphism, empty interface/any, small-interface idiom ("accept interfaces, return structs"), మరియు ubiquitous standard-library interfaces (error, io.Reader/Writer, Stringer) ను అర్థం చేసుకోవడం idiomatic Go కు అవసరమైనది.
ఇది ఒక ఇంటర్వ్యూ విషయం ఖచ్చితంగా implicit, structural model Java/C# యొక్క explicit interfaces నుండి బదులుగా సంపూర్ణంగా భిన్నమైనది ఎందుకంటే.