Как да внедрите концепции за обектно-ориентирано програмиране в Go

Обектно-ориентирано програмиране (ООП) е парадигма за програмиране, базирана на обекти като централна концепция. В OOP кодът е форматиран въз основа на функционалност, позволявайки поддръжка на кода, абстракция, повторна употреба, ефективност и многобройни функционалности на обекта.

Обектът има атрибути (променливи), които определят неговите характеристики, свойства и методи (функции), които определят действията (процедурите) и поведението на обекта.

Обектно-ориентираното програмиране в Go е различно от другите езици. Обектно-ориентираните концепции се реализират в Go с помощта на структури, интерфейси и персонализирани типове.

Персонализиране на типове в Go

Персонализираните типове улесняват групирането и идентифицирането на подобен код за повторна употреба.

Кодът за деклариране на персонализирани типове е:

Тип typeName dataType 

При създаване на персонализиран тип и присвояване на променлива, можете да проверите типа с помощта на отразяват. Тип() който приема променлива и връща типа на променливата.

внос( "fmt"
 "отразява")
Тип две международен// създава тип "две"
вар номер две // променлива от тип "две"
fmt. Println (отразява. TypeOf (брой))

​​​

В номер променливата е вид на две което е цяло число. Можете да отидете по-далеч, за да създадете повече от персонализирания тип.

Създаване на структури в Go

Структурите (структурите) са чертежите за обектно-ориентирано програмиране в Go. Структурите са дефинирани от потребителя колекции от полета.

Структурата може да съдържа различни типове данни, включително съставни типове и методи.

Можете да създадете структура с помощта на този синтаксис:

Тип StructName структура {
// някакъв код
}

Обикновено имената на структурите обикновено се изписват с главни букви и с главни букви за четливост.

Типът структура приема имена на полета и типове данни. Структурите могат да приемат всеки тип данни на Go, включително персонализирани типове.

Тип потребител структура {
 поле1 низ
 поле 2 международен
 fieldMap карта[низ]международен
}

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

екземпляр := Потребител{
// някакъв код
}

Инстанцията на структурата може да бъде попълнена с полета при инстанциране, както е дефинирана при инициализация, или да бъде зададена на нула.

екземпляр := Потребител{
 поле 1: "а низ поле",
 поле 2: 10,
 карта на полето: карта[низ]международен{},
 }

Достъп до структурни елементи

Можете да получите достъп до полетата на екземпляр на структура, като използвате нотация с точка към полето.

fmt. Println("Достъп до поле със стойност", instance.field2)

Това извежда поле 2 на инстанцираната инстанция на структурата.

Присвояване на методи на структури

Функциите (методите) се присвояват на структурни типове чрез посочване на име на приемник и името на структурата преди името на функцията, както е показано в синтаксиса по-долу.

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

Методът име на функция може да се използва само за посочения тип структура.

Внедряване на наследяване в Go

Наследството е способността на обекти и типове да осъществяват достъп и да използват методи и атрибути на други обекти. Go няма наследяване като функция, но можете да използвате композиции. В Go композицията включва препращане към суперструктура (структурата, която трябва да бъде наследена) в подструктура чрез предоставяне на името на суперструктура на подструктура.

Използвайки примера за структура по-горе:

Тип потребител структура {
 поле1 низ
 поле 2 международен
 fieldMap карта[низ]международен
}
Тип Потребител 2 структура {
 потребител
}

Чрез преминаване на потребител името на структурата в Потребител 2 структура, Потребител 2 struct има достъп до всички методи и атрибути на потребител структура при инстанциране, освен че се използват техники за абстракция.

син := Потребител2{
 потребител{
 поле 1: "бебе",
 поле 2: 0,
 карта на полето: нула,
 },
 }
fmt. Println (son.field2)

В син променливата по-горе е инстанция на Потребител 2 структура. Както се вижда в примера, син променливата може да осъществява достъп и да инстанцира стойности от типа потребител и да ги използва.

Капсулиране на полета с тип в Go

Капсулирането, известно още като „скриване на информация“, е а техника за групиране на методите и атрибутите на обект в единици за да ограничите използването и достъпа освен посочените (разрешаване на права за четене/запис).

Капсулирането се реализира в Go с помощта на експортирани и неекспортирани идентификатори в пакети.

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

Експортираните идентификатори се експортират от техните дефинирани пакети и достъп до други програми. Изписването с главни букви на идентификатор на поле експортира полето fo.

Тип потребител структура {
 Поле 1 низ
 Поле 2 международен
 FieldMap карта[низ]международен
}
Тип Потребител 2 структура {
 потребител
}

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

Неекспортираните идентификатори не се експортират от дефинирания пакет и обикновено са с малки букви.

Тип потребител структура {
 поле1 низ
 поле 2 международен
 fieldMap карта[низ]международен
}
Тип Потребител 2 структура {
 потребител
}

Концепцията за експортирани и неекспортирани идентификатори се прилага и за методите на обект.

Полиморфизъм в Go

Полиморфизмът е техника, използвана за придаване на различни форми на обект за гъвкавост.

Go прилага полиморфизъм с помощта на интерфейси. Интерфейсите са персонализирани типове, използвани за дефиниране на сигнатури на методите.

Деклариране на интерфейси

Декларирането на интерфейси е подобно на декларирането на структури. Въпреки това, интерфейсите се декларират с помощта на интерфейс ключова дума.

Тип InterfaceName интерфейс{
//някои методи
}

Декларациите на интерфейса съдържат методи, които трябва да се реализират от типове структури.

Внедряване на интерфейси в структури

Типовете, които имплементират интерфейса, трябва да бъдат декларирани, след което методите на типа имплементират интерфейса.

// Интерфейсът
Тип Цвят интерфейс{
 боя() низ
}
// Деклариране на структурите
Тип зелено структура {
// някакъв специфичен за структура код
}
Тип Син структура {
// някакъв специфичен код
}

Кодовият фрагмент по-горе има a Цвят интерфейс, деклариран с a Боя метод, който трябва да бъде приложен от зелено и Син типове структури.

Интерфейсите се реализират чрез присвояване на методи на структурни типове и след това именуване на метода чрез интерфейсния метод, който трябва да бъде внедрен.

функция(g зелено)Боя()низ {
връщане "боядисани в зелено"
}
функция(b синьо)Боя()низ {
връщане "боядисани в синьо"
}

Методът Paint се реализира от зелени и сини типове, които вече могат да извикват и използват Боя метод.

четка := зелена{}
fmt. Println (четка. боя())

„Боядисано в зелено“ се отпечатва на конзолата, което потвърждава, че интерфейсът е внедрен успешно.

Абстрактиране на полета в Go

Абстракцията е процесът на скриване на маловажни методи и атрибути на даден тип, което улеснява защитата на части от програмата от необичайна, непреднамерена употреба.

Go няма абстракция, внедрена веднага; обаче можете да работите по нашия път чрез внедряване на абстракция с помощта на интерфейси.

// хората могат да бягат
Тип Човек интерфейс {
 бягай() низ
}
// Момчето е човек с крака
Тип момче структура {
 Крака низ
}
// метод за момче имплементира метода на изпълнение на човешкия интерфейс
функция(h момче)бягай()низ {
връщане з. Крака
}

Кодът по-горе създава a Човек интерфейс с a бягай интерфейс, който връща низ. В момче тип реализира бягай метод на Човек интерфейс и връща низ при инстанциране.

Един от начините за реализиране на абстракция е като накарате структура да наследи интерфейса, чиито методи трябва да се абстрахират. Има много други подходи, но този е най-лесният.

Тип Лице структура {
 име низ
 възраст международен
 Статус Човек 
}
функцияглавен() {
 person1 := &Момче{Крака: "два крака"}
 лице2 := &Лице{ // екземпляр на лице
 Име: "амина",
 възраст: 19,
 Статус: лице 1,
 }
 fmt. Println (човек. Status.run()) 
}

В Лице структурата наследява Човек интерфейс и има достъп до всичките му методи, използвайки променливата Състояние наследяване на интерфейса.

При инстанциране чрез препратка (с помощта на указател), екземплярът на Лице структура Лице 2 препраща към екземпляр на момче структура Лице 1 и получава достъп до методите.

По този начин можете да посочите конкретни методи, които да бъдат приложени от типа.

ООП срещу функционално програмиране

Обектно-ориентираното програмиране е важна парадигма, тъй като ви дава повече контрол върху вашата програма и насърчава повторното използване на кода по начин, по който функционалното програмиране не го прави.

Това не прави функционалното програмиране лош избор, тъй като функционалното програмиране може да бъде полезно и по-добро за някои случаи на употреба.

Какво е обектно-ориентирано програмиране? Основите, обяснени в термините на неспециалистите

Прочетете Следващото

За автора