ఇంటర్‌ఫేస్‌లు: ప్రవర్తనను నిర్వచించడం

Goలో ఇంటర్‌ఫేస్ అనేది పద్ధతి సంతకాల సమితి. ఒక విలువ ఇంటర్‌ఫేస్‌లో అన్ని ఆ పద్ధతులు ఉంటే దాన్ని అమలు చేస్తుంది — లేదు implements, extends లేదు, స్పష్టమైన నమోదు లేదు. ఇది మోడల్‌ను తరచుగా "స్ట్రక్చరల్ టైపింగ్" లేదా "స్టాటిక్ డక్ టైపింగ్" అని పిలుస్తారు: కంపైలర్ కంపైల్ సమయంలో అనుగుణతను తనిఖీ చేస్తుంది, కానీ దాని ఆధారంగా ఆకృతి, ప్రకటనలపై కాదు.

ఇంటర్‌ఫేస్‌ని ప్రకటిస్తోంది

type Greeter interface {
    Greet() string
}

కన్వెన్షన్: సింగిల్-మెథడ్ ఇంటర్‌ఫేస్‌ల కోసం -erతో ముగిసే పేర్లు (Reader, Writer, Stringer, Closer). చిన్న ఇంటర్‌ఫేస్‌లు (1–2 పద్ధతులు) ఇడియొమాటిక్: ప్రామాణిక లైబ్రరీ నిండి ఉంది కలిసి కంపోజ్ చేసే చిన్న ఇంటర్‌ఫేస్‌లు (io.ReadWriter, io.ReadCloser, …).

అవ్యక్త అమలు

type Person struct{ Name string }

func (p Person) Greet() string {
    return "ciao " + p.Name
}

// Person satisfies Greeter because it has the required method.
var s Greeter = Person{Name: "Ada"}
fmt.Println(s.Greet())

కీవర్డ్ లేదు. రకానికి పద్ధతులు ఉంటే, దానిని కేటాయించవచ్చు ఆ ఇంటర్ఫేస్ రకం యొక్క వేరియబుల్. అంతే.

ఇంటర్‌ఫేస్ ద్వారా పాలిమార్ఫిజం

type Robot struct{ ID string }
func (r Robot) Greet() string { return "bip " + r.ID }

func greet(s Greeter) {
    fmt.Println(s.Greet())
}

greet(Person{Name: "Ada"})
greet(Robot{ID: "R2"})

greet Greeterని సంతృప్తిపరిచే ఏ రకాన్ని అయినా అంగీకరిస్తుంది. ఇది గో మార్గం పాలిమార్ఫిజం చేయడం: సోపానక్రమాలు లేవు, కేవలం సామర్థ్యం.

ఖాళీ ఇంటర్‌ఫేస్

var x interface{} = 42
var y any = "ciao"   // any is the built-in alias of interface{}

interface{} (లేదా any గో 1.18 నుండి) ఎటువంటి పద్ధతులు అవసరం లేదు, కాబట్టి ఏదైనా విలువ దానిని సంతృప్తిపరుస్తుంది. సాధారణ కంటైనర్లకు ఉపయోగపడుతుంది, కానీ సంగ్రహించడానికి మీకు అవసరమైన కాంక్రీట్ విలువ రకం నిర్ధారణ లేదా రకం స్విచ్ (తదుపరి పాఠాలు).

పద్ధతి సెట్: విలువ vs పాయింటర్ రిసీవర్ (ప్రివ్యూ)

మాడ్యూల్ 5 నుండి రీకాల్:

• విలువ రిసీవర్తో ఉన్న పద్ధతులు T మరియు *T రెండింటి యొక్క పద్ధతి సెట్‌లో ఉన్నాయి.
• పాయింటర్ రిసీవర్తో ఉన్న పద్ధతులు *T పద్ధతి సెట్‌లో మాత్రమే ఉన్నాయి.

ఆచరణాత్మక పరిణామం:

type Counter struct{ N int }
func (c *Counter) Inc() { c.N++ }

type Incrementer interface { Inc() }

var i Incrementer = &Counter{}   // OK: *Counter has Inc()
// var j Incrementer = Counter{} // ERROR: Counter (value) does NOT

పద్ధతికి పాయింటర్ రిసీవర్ ఉన్నప్పుడు, మీరు తప్పనిసరిగా పాయింటర్‌ను కేటాయించాలి ఇంటర్ఫేస్ వేరియబుల్.

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

type P struct{}
// ?

రీక్యాప్

• ఇంటర్ఫేస్ = పద్ధతి సంతకాల సమితి; సంఖ్య implements.
• అవ్యక్త అమలు: సరైన సంతకంతో పద్ధతులను కలిగి ఉండండి.
• ఇడియోమాటిక్: చిన్న ఇంటర్‌ఫేస్‌లు (1–2 పద్ధతులు), -erలో పేర్లు.
• interface{} / any: ఏదైనా విలువను అంగీకరిస్తుంది, రకం భద్రతను కోల్పోతుంది.
• విధానం సెట్: పాయింటర్ రిసీవర్ → మాత్రమే *T ఇంటర్‌ఫేస్‌ను సంతృప్తిపరుస్తుంది.
• గో పాలిమార్ఫిజం: ఇంటర్‌ఫేస్-టైప్ చేసిన పారామితులు, సోపానక్రమాలు లేవు.