Како имплементирати концепте објектно оријентисаног програмирања у Го

Објектно оријентисано програмирање (ООП) је програмска парадигма заснована на објектима као централном концепту. У ООП-у, код је форматиран на основу функционалности, омогућавајући одржавање кода, апстракцију, поновну употребу, ефикасност и бројне функционалности на објекту.

Објекат има атрибуте (варијабле) који дефинишу његове карактеристике, својства и методе (функције) које дефинишу акције (процедуре) и понашања објекта.

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

Прилагођавање типова у Го

Прилагођени типови олакшавају груписање и идентификацију сличног кода за поновну употребу.

Код за декларисање прилагођених типова је:

тип типеНаме датаТипе 

Када креирате прилагођени тип и доделите променљиву, можете проверити тип помоћу одразити. Тип() који узима променљиву и враћа тип променљиве.

увоз( "фмт"
 "одразити")
тип два инт// креира тип "два"
вар број два // променљива типа "два"
фмт. Принтлн (рефлект. ТипеОф (број))

​​​

Тхе број променљива је врста два који је цео број. Можете ићи даље да бисте креирали више прилагођеног типа.

Креирање структура у Го

Структуре (структуре) су нацрти за објектно оријентисано програмирање у Го. Структуре су кориснички дефинисане колекције поља.

Структура може да садржи различите типове података, укључујући типове сложених и методе.

Можете креирати структуру користећи ову синтаксу:

тип СтруцтНаме струцт {
// неки код
}

Конвенционално, имена структура се обично пишу великим словима и великим и малим словима ради читљивости.

Тип структуре преузима имена поља и типове података. Структуре могу да приме било који тип података Го, укључујући прилагођене типове.

тип Корисник струцт {
 поље1 низ
 поље2 инт
 фиелдМап Мапа[низ]инт
}

Можете инстанцирати тип структуре тако што ћете структуру доделити као променљиву.

инстанце := Корисник{
// неки код
}

Инстанца структуре може бити попуњена пољима при инстанцирању како је дефинисано при иницијализацији или постављена на нулл.

инстанце := Корисник{
 поље 1: „а низ поље",
 поље 2: 10,
 мапа поља: Мапа[низ]инт{},
 }

Приступ елементима структуре

Можете приступити пољима инстанце структуре користећи тачку у пољу.

фмт. Принтлн("Приступ пољу вредности", инстанце.фиелд2)

Ово даје излаз поље2 инстанце структуре инстанциране.

Додељивање метода структурама

Функције (методе) се додељују типовима структуре навођењем имена примаоца и имена структуре пре имена функције као што је приказано у синтакси испод.

фунц(име структуре примаоца)фунцтионНаме() {
// неки код
}

Метода фунцтионНаме може се користити само на специфицираном типу структуре.

Имплементација наслеђивања у Го

Наслеђе је способност објеката и типова да приступе и користе методе и атрибуте других објеката. Го нема наследство као функцију, али можете користити композиције. У Го, композиција подразумева упућивање на надструктуру (структуру која се наслеђује) у подструктуру тако што се даје име надструктуре подструктури.

Користећи горњи пример структуре:

тип Корисник струцт {
 поље1 низ
 поље2 инт
 фиелдМап Мапа[низ]инт
}
тип Усер2 струцт {
 Корисник
}

Проласком на Корисник име структуре у Усер2 струцт, тхе Усер2 струцт може приступити свим методама и атрибутима Корисник структура на инстанцирању осим што се користе технике апстракције.

син := Усер2{
 Корисник{
 поље 1: "беба",
 поље 2: 0,
 мапа поља: нула,
 },
 }
фмт. Принтлн (сон.фиелд2)

Тхе сине варијабла изнад је инстанција Усер2 струцт. Као што се види у примеру, сине променљива може приступити и инстанцирати вредности типа Усер и користити их.

Енкапсулирање поља типа у Го

Енкапсулација, такође позната као „скривање информација“, је а техника повезивања метода и атрибута објекта у целине да ограничи употребу и приступ осим наведених (омогућавање привилегија читања/писања).

Енкапсулација је имплементирана у Го користећи извезене и неизвезене идентификаторе у пакетима.

Извезени идентификатори (читање и писање)

Извезени идентификатори се извозе из њихових дефинисаних пакета и приступа другим програмима. Употреба великог слова у идентификатору поља извози поље фо.

тип Корисник струцт {
 Поље1 низ
 Поље2 инт
 ФиелдМап Мапа[низ]инт
}
тип Усер2 струцт {
 Корисник
}

Неизвезени идентификатори (само за читање)

Неизвезени идентификатори се не извозе из дефинисаног пакета и обично се пишу малим словима.

тип Корисник струцт {
 поље1 низ
 поље2 инт
 фиелдМап Мапа[низ]инт
}
тип Усер2 струцт {
 Корисник
}

Концепт извезених и неизвезених идентификатора такође се примењује на методе објекта.

Полиморфизам у Го

Полиморфизам је техника која се користи за давање различитих облика објекту ради флексибилности.

Го имплементира полиморфизам користећи интерфејсе. Интерфејси су прилагођени типови који се користе за дефинисање потписа метода.

Декларисање интерфејса

Декларисање интерфејса је слично декларисању структура. Међутим, интерфејси се декларишу помоћу приступ кључна реч.

тип ИнтерфацеНаме приступ{
//неке методе
}

Декларације интерфејса садрже методе које треба да имплементирају типови структуре.

Имплементација интерфејса у структурама

Типови који имплементирају интерфејс морају бити декларисани након чега методе типа имплементирају интерфејс.

// Интерфејс
тип Боја приступ{
 Паинт() низ
}
// Декларисање структура
тип Зелена струцт {
// неки код специфичан за структуру
}
тип Плави струцт {
// неки одређени код
}

Исечак кода изнад има а Боја интерфејс декларисан са а Паинт метод који ће имплементирати Зелена и Плави типови структура.

Интерфејси се имплементирају додељивањем метода типовима структуре, а затим именовањем методе помоћу методе интерфејса која ће бити имплементирана.

фунц(г зелено)Паинт()низ {
повратак "фарбано зелено"
}
фунц(б плава)Паинт()низ {
повратак "фарбано плаво"
}

Методу Паинт имплементирају зелени и плави типови који сада могу да позивају и користе Паинт методом.

четка := зелена{}
фмт. Принтлн (четка. Паинт())

„Обојено зелено“ је одштампано на конзоли која потврђује да је интерфејс успешно имплементиран.

Апстрактна поља у Го

Апстракција је процес скривања неважних метода и атрибута типа, што олакшава заштиту делова програма од ненормалне, ненамерне употребе.

Го нема апстракцију одмах имплементирану; међутим, можете проћи кроз имплементацију апстракције користећи интерфејсе.

// људи могу да трче
тип Хуман приступ {
 трцати() низ
}
// Дечак је човек са ногама
тип Бои струцт {
 ноге низ
}
// метода на дечаку имплементира метод покретања људског интерфејса
фунц(х дечак)трцати()низ {
повратак х. ноге
}

Код изнад креира а Хуман интерфејс са а трцати интерфејс који враћа стринг. Тхе Бои тип имплементира трцати методом Хуман интерфејс и враћа стринг при инстанцирању.

Један од начина да се имплементира апстракција је да структура наследи интерфејс чије методе треба да се апстрахују. Постоји много других приступа, али овај је најлакши.

тип Особа струцт {
 Име низ
 Старост инт
 Статус Хуман 
}
фунцглавни() {
 особа1 := &Дечак{Ноге: "две ноге"}
 особа2 := &Особа{ // инстанца особе
 Име: "амина",
 Старост: 19,
 Статус: особа 1,
 }
 фмт. Принтлн (особа. Статус.рун()) 
}

Тхе Особа струцт наслеђује Хуман интерфејс и може приступити свим својим методама помоћу променљиве Статус наслеђивање интерфејса.

Приликом инстанцирања путем референце (помоћу показивача), инстанца Особа струцт Особа2 упућује на инстанцу Бои струцт Особа1 и добија приступ методама.

На овај начин можете одредити специфичне методе које ће тип имплементирати.

ООП против функционалног програмирања

Објектно оријентисано програмирање је важна парадигма јер вам даје већу контролу над вашим програмом и подстиче поновну употребу кода на начин на који функционално програмирање не чини.

Ово не чини функционално програмирање лошим избором, јер функционално програмирање може бити од помоћи и боље за неке случајеве употребе.

Шта је објектно оријентисано програмирање? Основе објашњене лаичким терминима

Реад Нект

О аутору