Примери интерфејса Голанг

Primeri Interfejsa Golang



У Го, скуп потписа метода садржи интерфејс. Он одређује групу радњи које тип мора да предузме да би био одређен да би испунио тај интерфејс. Другим речима, интерфејс специфицира методе које тип мора имати, али не пружа информације о имплементацији. Иако, Го интерфејси пружају моћан механизам за постизање полиморфног понашања и писање кода за вишекратну употребу. У овом посту ћемо испитати идеју интерфејса у Го-у и понудити примере из стварног света да покажемо како их користити.

Пример 1: Голанг празан интерфејс

Почните са празним интерфејсом{} који се у Го-у назива интерфејсом. Означава тип који може да ускладишти било коју врсту вредности. Следеће је изворни код за празан интерфејс у ​​Го:

пакет главни
увоз 'фмт'
тип МарксЦалцулатор интерфејс {}
фунц главни () {
био м МарксЦалцулатор
фмт . Принтлн ( м )
}

Овде пружамо код где интерфејс „МарксЦалцулатор“ нема ниједан специфицирани потпис метода јер је празан. Као резултат, не пружа никакву функционалност. Затим имамо функцију маин() овог празног интерфејса где је декларисана променљива „м” типа МарксЦалцулатор. Пошто је интерфејс празан, „м“ може да садржи било коју вредност било ког типа. У овом случају, „м“ није иницијализовано, тако да има нулту вредност за свој тип која је „нула“ за интерфејсе. Када се „м“ одштампа помоћу „фмт.Принтлн“, он даје „нил“ на конзолу.







Излаз који се преузима је „нула“ како се очекује од претходног изворног кода:





Пример 2:  Голанг имплементација интерфејса

Овај одељак показује имплементацију Голанг интерфејса. Тип мора да понуди имплементацију за сваки од наведених метода у интерфејсу да би га имплементирао у Го. У наставку је дат изворни код за имплементацију интерфејса:





пакет главни
увоз (
'фмт'
)
тип Самогласници интерфејс {
СеарцхВовелс () [] руне
}
тип МиСтр низ
фунц ( ст МиСтр ) СеарцхВовелс () [] руне {
био самогласници [] руне
за _ , руне := домет ст {
ако руне == 'а' || руне == 'То је' || руне == 'ја' || руне == 'О' || руне == 'у' {
самогласници = додати ( самогласници , руне )
}
}
повратак самогласници
}

фунц главни () {
НевСтринг := МиСтр ( „ГоЛанг интерфејси“ )
био в1 Самогласници
в1 = НевСтринг
фмт . Принтф ( „Вокали су %ц“ , в1 . СеарцхВовелс ())
}

Овде код дефинише интерфејс под називом „Вовелс“ који специфицира један метод СеарцхВовелс() који враћа део руне (тип инт32). Интерфејс омогућава да било који тип који имплементира потпис овог метода буде додељен променљивој типа интерфејса. Затим се декларише нови тип „МиСтр“, који је псеудоним за основни низ типа. То значи да „МиСтр“ наслеђује све методе стринга, али је посебан тип.

Након тога имплементирамо метод СеарцхВовелс() за тип „МиСтр“. Овај метод скенира улазни низ карактер по карактер и проверава да ли је сваки знак самогласник („а“, „е“, „и“, „о“ или „у“). Ако је знак самогласник, он се додаје самогласнику.



Унутар функције маин() креира се променљива „НевСтринг“ типа „МиСтр“ са вредношћу „ГоЛанг Интерфацес“. Затим се декларише променљива „в1“ типа „Вовелс“. Пошто „МиСтр“ имплементира метод СеарцхВовелс() који је дефинисан у интерфејсу „Вовелс“, „НевСтринг“ се може доделити „в1“.

Излаз приказује сав низ самогласника који се налазе у наведеном низу:

Пример 3: Голанг Стрингер интерфејс

Поред тога, Голанг има унапред дефинисан интерфејс „Стрингер“ у „фмт“ пакету. Омогућава прилагођеном типу да контролише своју репрезентацију стрингова када је форматиран глаголом „%в“ у функцијама штампања пакета „фмт“. Следи пример кода за стрингер интерфејс Го:

пакет главни
увоз (
'фмт'
)
тип Ученик струцт {
Име низ
Степен низ
}
фунц ( с Студент ) Низ () низ {
повратак фмт . Спринтф ( „%с је (н) %с“ , с . Име , с . Степен )
}
фунц главни () {
с1 := Ученик { 'Елена Гилберт' , 'Информатика' }
с2 := Ученик { 'Керолајн Кендис' , 'ББА' }
фмт . Принтлн ( с1 )
фмт . Принтлн ( с2 )
}

Овде код прво увози потребан пакет који је „фмт“ за штампање на конзолу. Затим дефинишемо структуру типа „Студент“ са два поља: „Име“ и „Дегрее“. Ова структура представља информацију ученика. Даље, креира се метод Стринг() за тип „Студент“. Овај метод има пријемник типа „Студент“ и враћа стринг. Метода „Стринг()“ је посебна метода у Го-у која се користи за прилагођавање стринг репрезентације објекта када се штампа. У овом случају, метода „Стринг()“ форматира и враћа стринг који укључује име и степен студента.

Затим имамо функцију маин() где су две променљиве, с1 и с2 типа „Студент“, декларисане и иницијализоване информацијама о ученику. На крају, код користи функцију фмт.Принтлн() за штампање вредности с1 и с2. Пошто је метода Стринг() дефинисана за тип „Студент“, Го аутоматски позива овај метод када штампа објекат „Студент“. Метод Стринг() форматира информације о ученику помоћу функције „фмт.Спринтф()“ и враћа форматирани стринг.

Следећи излаз штампа објекат типа „Студент“ интерфејса стрингера:

Пример 4: Прекидач типа Голанг

Затим долази интерфејс за пребацивање типа у Го. Прекидач типа је контролна структура која нам омогућава да проверимо динамички тип вредности интерфејса. Пратите изворни код интерфејса за пребацивање типа:

пакет главни
увоз „фмт
фунц МиФунцтион(Ф1 интерфејс{}) {
прекидач Ф1.(тип) {
цасе инт:
фмт.Принтлн('
Тип : инт , Валуе : ', Ф1.(ви))
стринг случаја:
фмт.Принтлн('
\нТип : низ , Валуе : ', Ф1.(стринг))
цасе флоат64:
фмт.Принтлн('
\нТип : флоат64 , Валуе : ', Ф1.(флоат64))
Уобичајено:
фмт.Принтлн('
\нТип није важећи ')
}
}
фунц маин() {
Моја функција('
Водич за Голанг интерфејсе ')
МиФунцтион(89.7)
МиФунцтион(труе)
}

Овде обезбеђени код дефинише функцију „МиФунцтион“ која узима параметар „Ф1“ типа „интерфејс{}“. Ово указује да „Ф1“ може да прихвати вредност било ког типа. Унутар функције, наредба свитцх се користи са „Ф1.(типе)“ за проверу типа вредности која се прослеђује „МиФунцтион“. Синтакса „.(типе)“ се користи у прекидачу типа да би се добио основни динамички тип вредности интерфејса. Имајте на уму да случајеви прекидача овде обрађују три специфична типа: „инт“, „стринг“ и „флоат64“. Ако тип „Ф1“ одговара једном од ових случајева. Штампа одговарајући тип и вредност користећи тврдње типа (Ф1.(инт), Ф1.(стринг), Ф1.(флоат64)). Ако тип „Ф1“ не одговара ниједном од дефинисаних случајева, извршава се подразумевани случај који штампа „Тип није важећи“.

Након тога, унутар функције маин(), „МиФунцтион“ се позива три пута са различитим вредностима: стринг, флоат64 и Боолеан (који се не обрађује у наредби свитцх).

Излаз приказује демонстрацију интерфејса прекидача са тврдњама типа:

Пример 5: Голанг вишеструки интерфејси

Штавише, Го нуди више интерфејса који му омогућавају да обезбеди различите скупове понашања у зависности од контекста. Ова функција се назива „више интерфејса“ или „композиција интерфејса“. Следећи код показује имплементацију више интерфејса:

пакет главни
увоз 'фмт'
тип птице интерфејс {
дисати ()
лети ()
}

тип авианс интерфејс {
напајање ()
}
тип Где струцт {
старости инт
}
фунц ( д где ) дисати () {
фмт . Принтлн ( 'Голуб дише' )
}
фунц ( д где ) лети () {
фмт . Принтлн ( 'голубица' )
}
фунц ( д где ) напајање () {
фмт . Принтлн ( 'Голуб негује бебе' )
}
фунц главни () {
био б птице
д := Где {}
б = д
б . дисати ()
б . лети ()
био а авианс
а = д
а . напајање ()
}

Овде дефинишемо два интерфејса: „птице“ и „птичје“. Интерфејс „птице“ декларише две методе: дахајте() и лети(). Док „авианс” интерфејс декларише метод феед(). Затим, структура „голубица“ имплементира све методе интерфејса „птице“ и „авианс“. Обезбеђује имплементације за бреатхе(), фли() и феед().

Затим декларишемо променљиву „б“ типа „птице“ унутар функције маин(). Инстанца „голуба“ се креира и додељује „б“ коришћењем задатка б = д. Пошто „голубица“ имплементира све методе „птичјег“ интерфејса, овај задатак је валидан.

Затим се методе бреатхе() и фли() позивају на „б“ који је типа „птице“. Слично, променљива „а” типа „птичје” је декларисана и додељена је инстанци „дове” „дове”. Пошто „дове“ имплементира метод феед() који је дефинисан у „авианс“ интерфејсу, ова додела је такође важећа. Метода феед() се позива на „а” која је типа „птичје”. Пошто „а“ држи инстанцу „голубице“, извршава се метода феед() коју имплементира „дове“.

Излаз показује да су методе интерфејса исправно извршене:

Закључак

Научили смо основе Го интерфејса и пружили практичне примере који илуструју њихову употребу. Дефинисањем интерфејса и њиховом имплементацијом са различитим типовима можемо креирати флексибилне и прошириве програме.