ఉదాహరణ 1: గోలాంగ్ ఖాళీ ఇంటర్ఫేస్
గోలో ఇంటర్‌ఫేస్‌గా సూచించబడే ఖాళీ ఇంటర్‌ఫేస్‌తో ప్రారంభించండి{}. ఇది ఏ రకమైన విలువనైనా నిల్వ చేయగల రకాన్ని సూచిస్తుంది. గోలో ఖాళీ ఇంటర్‌ఫేస్‌కు సోర్స్ కోడ్ క్రిందిది:
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
రకం మార్క్స్ కాలిక్యులేటర్ ఇంటర్ఫేస్ {}
ఫంక్ ప్రధాన () {
ఉంది m మార్క్స్ కాలిక్యులేటర్
fmt . Println ( m )
}
ఇక్కడ, 'MarksCalculator' ఇంటర్ఫేస్ ఖాళీగా ఉన్నందున నిర్దిష్ట పద్ధతి సంతకాలు లేని కోడ్‌ను మేము అందిస్తాము. ఫలితంగా, ఇది ఎటువంటి కార్యాచరణను అందించదు. తరువాత, మేము ఈ ఖాళీ ఇంటర్ఫేస్ యొక్క ప్రధాన() ఫంక్షన్‌ని కలిగి ఉన్నాము, ఇక్కడ మార్క్స్ కాలిక్యులేటర్ రకం యొక్క వేరియబుల్ “m” ప్రకటించబడుతుంది. ఇంటర్ఫేస్ ఖాళీగా ఉన్నందున, “m” ఏ రకమైన విలువనైనా కలిగి ఉంటుంది. ఈ సందర్భంలో, 'm' అనేది ప్రారంభించబడదు, కనుక ఇది ఇంటర్‌ఫేస్‌ల కోసం 'nil' అయిన దాని రకానికి సున్నా విలువను కలిగి ఉంటుంది. “fmt.Println”ని ఉపయోగించి “m” ముద్రించబడినప్పుడు అది కన్సోల్‌కు “nil”ని అందిస్తుంది.
మునుపటి సోర్స్ కోడ్ నుండి ఊహించిన విధంగా తిరిగి పొందబడిన అవుట్‌పుట్ “నిల్”:
ఉదాహరణ 2: ఇంటర్ఫేస్ గోలాంగ్ ఇంప్లిమెంటేషన్
ఈ విభాగం గోలాంగ్ ఇంటర్ఫేస్ అమలును ప్రదర్శిస్తుంది. గోలో అమలు చేయడానికి ఇంటర్‌ఫేస్‌లో పేర్కొన్న ప్రతి పద్ధతికి ఒక రకం తప్పనిసరిగా అమలును అందించాలి. ఇంటర్ఫేస్ అమలు కోసం కిందిది సోర్స్ కోడ్ ఇవ్వబడింది:
ప్యాకేజీ ప్రధాన
దిగుమతి (
'fmt'
)
రకం అచ్చులు ఇంటర్ఫేస్ {
శోధన అచ్చులు () [] రూన్
}
రకం MyStr స్ట్రింగ్
ఫంక్ ( సెయింట్ MyStr ) శోధన అచ్చులు () [] రూన్ {
ఉంది అచ్చులు [] రూన్
కోసం _ , రూన్ := పరిధి సెయింట్ {
ఉంటే రూన్ == 'a' || రూన్ == 'అది' || రూన్ == 'నేను' || రూన్ == 'ఓ' || రూన్ == 'లో' {
అచ్చులు = జోడించు ( అచ్చులు , రూన్ )
}
}
తిరిగి అచ్చులు
}
ఫంక్ ప్రధాన () {
న్యూస్ట్రింగ్ := MyStr ( 'గోలాంగ్ ఇంటర్‌ఫేస్‌లు' )
ఉంది v1 అచ్చులు
v1 = న్యూస్ట్రింగ్
fmt . ప్రింట్ఎఫ్ ( 'అచ్చులు %c' , v1 . శోధన అచ్చులు ())
}
ఇక్కడ, కోడ్ 'అచ్చులు' అనే ఇంటర్‌ఫేస్‌ను నిర్వచిస్తుంది, ఇది రూన్ (రకం int32) యొక్క స్లైస్‌ను అందించే ఒకే పద్ధతిని సెర్చ్‌వోవెల్స్()ని నిర్దేశిస్తుంది. ఇంటర్ఫేస్ ఈ పద్ధతిని అమలు చేసే ఏ రకాన్ని అయినా ఇంటర్ఫేస్ రకం యొక్క వేరియబుల్‌కు కేటాయించేలా చేస్తుంది. అప్పుడు, కొత్త “MyStr” రకం ప్రకటించబడింది, ఇది అంతర్లీన రకం స్ట్రింగ్‌కు మారుపేరు. దీనర్థం 'MyStr' స్ట్రింగ్ యొక్క అన్ని పద్ధతులను వారసత్వంగా పొందుతుంది కానీ ఇది ఒక ప్రత్యేక రకం.
ఆ తర్వాత, మేము 'MyStr' రకం కోసం SearchVowels() పద్ధతిని అమలు చేస్తాము. ఈ పద్ధతి ఇన్‌పుట్ స్ట్రింగ్ క్యారెక్టర్‌ను అక్షరం వారీగా స్కాన్ చేస్తుంది మరియు ప్రతి అక్షరం అచ్చు (“a”, “e”, “i”, “o”, లేదా “u”) కాదా అని తనిఖీ చేస్తుంది. అక్షరం అచ్చు అయితే, అది అచ్చు ముక్కకు జోడించబడుతుంది.
ప్రధాన() ఫంక్షన్ లోపల, 'MyStr' రకం యొక్క 'NewString' వేరియబుల్ 'GoLang ఇంటర్‌ఫేస్‌లు' విలువతో సృష్టించబడుతుంది. తరువాత, 'అచ్చులు' రకం యొక్క 'v1' వేరియబుల్ ప్రకటించబడింది. “MyStr” “Vowels” ఇంటర్‌ఫేస్‌లో నిర్వచించబడిన SearchVowels() పద్ధతిని అమలు చేస్తుంది కాబట్టి, “NewString”ని “v1”కి కేటాయించవచ్చు.
అవుట్‌పుట్ పేర్కొన్న స్ట్రింగ్‌లో కనిపించే అన్ని అచ్చుల శ్రేణిని ప్రదర్శిస్తుంది:
ఉదాహరణ 3: గోలాంగ్ స్ట్రింగర్ ఇంటర్ఫేస్
అదనంగా, గోలాంగ్ 'fmt' ప్యాకేజీలో ముందే నిర్వచించబడిన 'స్ట్రింగర్' ఇంటర్‌ఫేస్‌ను కలిగి ఉంది. ఇది 'fmt' ప్యాకేజీ ప్రింటింగ్ ఫంక్షన్‌లలో '%v' క్రియతో ఫార్మాట్ చేసినప్పుడు దాని స్ట్రింగ్ ప్రాతినిధ్యాన్ని నియంత్రించడానికి అనుకూల రకాన్ని అనుమతిస్తుంది. గో యొక్క స్ట్రింగర్ ఇంటర్ఫేస్ కోసం క్రింది ఉదాహరణ కోడ్:
ప్యాకేజీ ప్రధానదిగుమతి (
'fmt'
)
రకం విద్యార్థి నిర్మాణం {
పేరు స్ట్రింగ్
డిగ్రీ స్ట్రింగ్
}
ఫంక్ ( లు విద్యార్థి ) స్ట్రింగ్ () స్ట్రింగ్ {
తిరిగి fmt . స్ప్రింట్ఎఫ్ ( '%s అనేది a(n) %s' , లు . పేరు , లు . డిగ్రీ )
}
ఫంక్ ప్రధాన () {
s1 := విద్యార్థి { 'ఎలెనా గిల్బర్ట్' , 'కంప్యూటర్ సైన్స్' }
s2 := విద్యార్థి { 'కరోలిన్ కాండిస్' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
ఇక్కడ, కోడ్ మొదట అవసరమైన ప్యాకేజీని దిగుమతి చేస్తుంది, ఇది కన్సోల్‌కు ప్రింట్ చేయడానికి “fmt”. అప్పుడు, మేము రెండు ఫీల్డ్‌లతో “స్టూడెంట్” అనే స్ట్రక్ట్ రకాన్ని నిర్వచించాము: “పేరు” మరియు “డిగ్రీ”. ఈ నిర్మాణం విద్యార్థి సమాచారాన్ని సూచిస్తుంది. ఇంకా, “స్టూడెంట్” రకం కోసం స్ట్రింగ్() పద్ధతి సృష్టించబడుతుంది. ఈ పద్ధతిలో “విద్యార్థి” రకం రిసీవర్ ఉంది మరియు స్ట్రింగ్‌ను అందిస్తుంది. “స్ట్రింగ్()” పద్ధతి అనేది గోలో ఒక ప్రత్యేక పద్ధతి, ఇది ఆబ్జెక్ట్‌ను ప్రింట్ చేసినప్పుడు దాని స్ట్రింగ్ ప్రాతినిధ్యాన్ని అనుకూలీకరించడానికి ఉపయోగించబడుతుంది. ఈ సందర్భంలో, “స్ట్రింగ్()” పద్ధతి విద్యార్థి పేరు మరియు డిగ్రీని కలిగి ఉన్న స్ట్రింగ్‌ను ఫార్మాట్ చేస్తుంది మరియు అందిస్తుంది.
తరువాత, 'విద్యార్థి' రకానికి చెందిన s1 మరియు s2 అనే రెండు వేరియబుల్స్ డిక్లేర్ చేయబడి, విద్యార్థి సమాచారంతో ప్రారంభించబడిన ప్రధాన() ఫంక్షన్‌ని మేము కలిగి ఉన్నాము. చివరగా, కోడ్ s1 మరియు s2 విలువలను ముద్రించడానికి fmt.Println() ఫంక్షన్‌ని ఉపయోగిస్తుంది. స్ట్రింగ్() పద్ధతి “విద్యార్థి” రకం కోసం నిర్వచించబడినందున, “స్టూడెంట్” ఆబ్జెక్ట్‌ను ప్రింట్ చేస్తున్నప్పుడు Go ఈ పద్ధతిని స్వయంచాలకంగా పిలుస్తుంది. String() పద్ధతి 'fmt.Sprintf()' ఫంక్షన్‌ని ఉపయోగించి విద్యార్థి సమాచారాన్ని ఫార్మాట్ చేస్తుంది మరియు ఫార్మాట్ చేసిన స్ట్రింగ్‌ను అందిస్తుంది.
కింది అవుట్‌పుట్ స్ట్రింగర్ ఇంటర్ఫేస్ యొక్క “స్టూడెంట్” రకం వస్తువును ప్రింట్ చేస్తుంది:
ఉదాహరణ 4: గోలాంగ్ టైప్ స్విచ్ ఇంటర్ఫేస్
అప్పుడు గో టైప్ స్విచ్ ఇంటర్ఫేస్ వస్తుంది. టైప్ స్విచ్ అనేది నియంత్రణ నిర్మాణం, ఇది ఇంటర్ఫేస్ విలువ యొక్క డైనమిక్ రకాన్ని తనిఖీ చేయడానికి అనుమతిస్తుంది. రకం స్విచ్ ఇంటర్ఫేస్ సోర్స్ కోడ్‌ని అనుసరించండి:
ప్యాకేజీ ప్రధానదిగుమతి 'fmt
func MyFunction(F1 ఇంటర్ఫేస్{}) {
స్విచ్ F1.(రకం) {
కేసు పూర్తి:
fmt.Println(' టైప్ చేయండి : int , విలువ : ', F1.(మీరు))
కేసు స్ట్రింగ్:
fmt.Println(' \nరకం : స్ట్రింగ్ , విలువ : ', F1.(స్ట్రింగ్))
కేసు ఫ్లోట్ 64:
fmt.Println(' \nరకం : ఫ్లోట్64 , విలువ : ', F1.(float64))
డిఫాల్ట్:
fmt.Println(' \nరకం చెల్లదు ')
}
}
ఫంక్ మెయిన్() {
MyFunction(' గోలాంగ్ ఇంటర్‌ఫేస్‌ల ట్యుటోరియల్ ')
MyFunction(89.7)
MyFunction (నిజం)
}
ఇక్కడ, అందించిన కోడ్ 'MyFunction' ఫంక్షన్‌ని నిర్వచిస్తుంది, అది 'F1' పరామితి 'ఇంటర్ఫేస్{}' రకంని తీసుకుంటుంది. 'F1' ఏ రకమైన విలువనైనా ఆమోదించగలదని ఇది సూచిస్తుంది. ఫంక్షన్ లోపల, 'MyFunction'కి పంపబడిన విలువ యొక్క రకాన్ని తనిఖీ చేయడానికి 'F1.(టైప్)'తో స్విచ్ స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. ఇంటర్ఫేస్ విలువ యొక్క అంతర్లీన డైనమిక్ రకాన్ని పొందడానికి టైప్ స్విచ్‌లో “.(రకం)” సింటాక్స్ ఉపయోగించబడుతుంది. ఇక్కడ స్విచ్ కేసులు మూడు నిర్దిష్ట రకాలను నిర్వహిస్తాయని గమనించండి: 'int', 'string' మరియు 'float64'. 'F1' రకం ఈ సందర్భాలలో ఒకదానితో సరిపోలితే. ఇది టైప్ అసెర్షన్స్ (F1.(int), F1.(string), F1.(float64)) ఉపయోగించి సంబంధిత రకం మరియు విలువను ప్రింట్ చేస్తుంది. 'F1' రకం నిర్వచించిన కేసుల్లో దేనితోనూ సరిపోలకపోతే, 'రకం చెల్లదు' అని ప్రింట్ చేసే డిఫాల్ట్ కేస్ అమలు చేయబడుతుంది.
ఆ తర్వాత, మెయిన్() ఫంక్షన్‌లో, “MyFunction” మూడు సార్లు వేర్వేరు విలువలతో పిలువబడుతుంది: స్ట్రింగ్, ఫ్లోట్64 మరియు బూలియన్ (ఇది స్విచ్ స్టేట్‌మెంట్‌లో నిర్వహించబడదు).
అవుట్‌పుట్ స్విచ్ ఇంటర్ఫేస్ యొక్క ప్రదర్శనను టైప్ అసెర్షన్‌లతో ప్రదర్శిస్తుంది:
ఉదాహరణ 5: గోలాంగ్ మల్టిపుల్ ఇంటర్‌ఫేస్‌లు
అంతేకాకుండా, Go బహుళ ఇంటర్‌ఫేస్‌లను అందిస్తుంది, ఇది సందర్భాన్ని బట్టి విభిన్న ప్రవర్తనలను అందించడానికి అనుమతిస్తుంది. ఈ లక్షణాన్ని 'బహుళ ఇంటర్‌ఫేస్‌లు' లేదా 'ఇంటర్ఫేస్ కూర్పు' అంటారు. కింది కోడ్ బహుళ ఇంటర్‌ఫేస్‌ల అమలును ప్రదర్శిస్తుంది:
ప్యాకేజీ ప్రధానదిగుమతి 'fmt'
రకం పక్షులు ఇంటర్ఫేస్ {
ఊపిరి పీల్చుకుంటారు ()
ఎగురు ()
}
రకం ఏవియన్స్ ఇంటర్ఫేస్ {
తిండి ()
}
రకం ఎక్కడ నిర్మాణం {
వయస్సు int
}
ఫంక్ ( d ఎక్కడ ) ఊపిరి పీల్చుకుంటారు () {
fmt . Println ( 'పావురం ఊపిరి పీల్చుకుంటుంది' )
}
ఫంక్ ( d ఎక్కడ ) ఎగురు () {
fmt . Println ( 'పావురం ఫ్లై' )
}
ఫంక్ ( d ఎక్కడ ) తిండి () {
fmt . Println ( 'పావురము పిల్లలను పెంచును' )
}
ఫంక్ ప్రధాన () {
ఉంది b పక్షులు
డి := ఎక్కడ {}
బి = డి
బి . ఊపిరి పీల్చుకుంటారు ()
బి . ఎగురు ()
ఉంది ఒక ఏవియన్స్
a = డి
a . తిండి ()
}
ఇక్కడ, మేము రెండు ఇంటర్‌ఫేస్‌లను నిర్వచించాము: 'పక్షులు' మరియు 'ఏవియన్స్'. 'బర్డ్స్' ఇంటర్ఫేస్ రెండు పద్ధతులను ప్రకటించింది: శ్వాస () మరియు ఫ్లై (). “ఏవియన్స్” ఇంటర్ఫేస్ ఫీడ్() పద్ధతిని ప్రకటించింది. అప్పుడు, 'పావురం' నిర్మాణం 'పక్షులు' మరియు 'ఏవియన్స్' ఇంటర్‌ఫేస్‌ల యొక్క అన్ని పద్ధతులను అమలు చేస్తుంది. ఇది బ్రీత్(), ఫ్లై(), మరియు ఫీడ్() కోసం అమలులను అందిస్తుంది.
తరువాత, మేము ప్రధాన() ఫంక్షన్‌లో 'బర్డ్స్' రకం యొక్క వేరియబుల్ 'b'ని ప్రకటిస్తాము. 'పావురం' యొక్క ఉదాహరణ సృష్టించబడుతుంది మరియు b = d అసైన్‌మెంట్ ఉపయోగించి 'b'కి కేటాయించబడుతుంది. 'పావురం' 'పక్షులు' ఇంటర్ఫేస్ యొక్క అన్ని పద్ధతులను అమలు చేస్తుంది, ఈ అసైన్‌మెంట్ చెల్లుబాటు అవుతుంది.
అప్పుడు, బ్రీత్ () మరియు ఫ్లై () పద్ధతులను 'బి' అని పిలుస్తారు, ఇది 'పక్షులు' రకం. అదేవిధంగా, “ఏవియన్స్” రకం యొక్క వేరియబుల్ “a” ప్రకటించబడింది మరియు “d” యొక్క “డోవ్” ఉదాహరణతో కేటాయించబడుతుంది. “ఏవియన్స్” ఇంటర్‌ఫేస్‌లో నిర్వచించబడిన ఫీడ్() పద్ధతిని “డోవ్” అమలు చేస్తుంది కాబట్టి, ఈ అసైన్‌మెంట్ కూడా చెల్లుతుంది. ఫీడ్() పద్ధతిని “ఏవియన్స్” రకానికి చెందిన “a” అని పిలుస్తారు. “a” “పావురం” ఉదాహరణను కలిగి ఉన్నందున, “పావురం” ద్వారా అమలు చేయబడిన ఫీడ్() పద్ధతి అమలు చేయబడుతుంది.
ఇంటర్‌ఫేస్‌ల పద్ధతులు సరిగ్గా అమలు చేయబడతాయని అవుట్‌పుట్ చూపిస్తుంది:
ముగింపు
మేము గో ఇంటర్‌ఫేస్‌ల ప్రాథమికాలను నేర్చుకున్నాము మరియు వాటి వినియోగాన్ని వివరించడానికి ఆచరణాత్మక ఉదాహరణలను అందించాము. ఇంటర్‌ఫేస్‌లను నిర్వచించడం మరియు వాటిని వివిధ రకాలతో అమలు చేయడం ద్వారా, మేము సౌకర్యవంతమైన మరియు విస్తరించదగిన ప్రోగ్రామ్‌లను సృష్టించవచ్చు.