Как реализовать концепции объектно-ориентированного программирования в Go

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

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

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

Настройка типов в Go

Пользовательские типы упрощают группировку и идентификацию похожего кода для повторного использования.

Код для объявления пользовательских типов:

тип typeName тип данных 

При создании пользовательского типа и назначении переменной вы можете проверить тип, используя отражать. Тип() который принимает переменную и возвращает тип переменной.

импорт("фмт"
 "отражать")
тип два инт// создает тип "два"
вар номер два // переменная типа "два"
ФМТ. Распечатать (отражать. TypeOf (число))

​​​

количество переменная является типом два что является целым числом. Вы можете пойти дальше, чтобы создать больше пользовательского типа.

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

Структуры (structs) — это чертежи для объектно-ориентированного программирования в Go. Структуры — это определяемые пользователем наборы полей.

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

Вы можете создать структуру, используя этот синтаксис:

тип имя структуры структура {
// какой-то код
}

Традиционно имена структур обычно пишутся с заглавной буквы и в верхнем регистре для удобства чтения.

Тип структуры принимает имена полей и типы данных. Структуры могут принимать любой тип данных Go, включая пользовательские типы.

тип Пользователь структура {
 поле1 нить
 поле2 инт
 полеКарта карта[нить]инт
}

Вы можете создать экземпляр типа структуры, назначив структуру в качестве переменной.

экземпляр := Пользователь{
// какой-то код
}

Экземпляр структуры может быть заполнен полями при создании экземпляра, как определено при инициализации, или может быть задано значение null.

экземпляр := Пользователь{
 поле1: "а нить поле",
 поле2: 10,
 карта поля: карта[нить]инт{},
 }

Доступ к элементам структуры

Вы можете получить доступ к полям экземпляра структуры, используя точечную нотацию поля.

ФМТ. Println("Доступ к полю значения", instance.field2)

Это выводит поле2 созданного экземпляра структуры.

Назначение методов структурам

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

функция(имя структуры получателя)имя_функции() {
// какой-то код
}

Метод имя_функции может использоваться только для указанного типа структуры.

Реализация наследования в Go

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

Используя приведенный выше пример структуры:

тип Пользователь структура {
 поле1 нить
 поле2 инт
 полеКарта карта[нить]инт
}
тип Пользователь2 структура {
 Пользователь
}

Пройдя Пользователь имя структуры в Пользователь2 структура, Пользователь2 struct может получить доступ ко всем методам и атрибутам Пользователь struct при создании экземпляра, за исключением того, что используются методы абстракции.

сын := User2{
 Пользователь{
 поле1: "ребенок",
 поле2: 0,
 карта поля: ноль,
 },
 }
ФМТ. Println (son.field2)

сын переменная выше является экземпляром Пользователь2 структура. Как видно на примере, сын переменная может получать доступ и создавать экземпляры значений типа User и использовать их.

Инкапсуляция полей типа в Go

Инкапсуляция, также известная как «сокрытие информации», представляет собой техника объединения методов и атрибутов объекта в блоки ограничить использование и доступ, кроме указанных (включение прав чтения/записи).

Инкапсуляция реализована в Go с помощью экспортируемых и неэкспортируемых идентификаторов в пакетах.

Экспортированные идентификаторы (чтение и запись)

Экспортированные идентификаторы экспортируются из их определенных пакетов и доступа к другим программам. Использование заглавных букв в идентификаторе поля экспортирует поле fo.

тип Пользователь структура {
 Поле1 нить
 Поле2 инт
 FieldMap карта[нить]инт
}
тип Пользователь2 структура {
 Пользователь
}

Неэкспортированные идентификаторы (только для чтения)

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

тип Пользователь структура {
 поле1 нить
 поле2 инт
 полеКарта карта[нить]инт
}
тип Пользователь2 структура {
 Пользователь
}

Концепция экспортируемых и неэкспортируемых идентификаторов также применяется к методам объекта.

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

Полиморфизм — это метод, используемый для придания объектам различных форм для обеспечения гибкости.

Go реализует полиморфизм с помощью интерфейсов. Интерфейсы — это настраиваемые типы, используемые для определения сигнатур методов.

Объявление интерфейсов

Объявление интерфейсов аналогично объявлению структур. Однако интерфейсы объявляются с использованием интерфейс ключевое слово.

тип Имя интерфейса интерфейс{
//некоторые методы
}

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

Реализация интерфейсов в структурах

Типы, реализующие интерфейс, должны быть объявлены, после чего методы типа реализуют интерфейс.

// Интерфейс
тип Цвет интерфейс{
 Покрасить() нить
}
// Объявление структур
тип Зеленый структура {
// какой-то специфичный для структуры код
}
тип Синий структура {
// какой-то конкретный код
}

Фрагмент кода выше имеет Цвет интерфейс, объявленный с помощью Покрасить метод, который должен быть реализован Зеленый и Синий типы структур.

Интерфейсы реализуются путем назначения методов типам структур с последующим присвоением имени методу реализуемого метода интерфейса.

функция(г Зеленый)Покрасить()нить {
возврат "окрашенный в зеленый цвет"
}
функция(б Синий)Покрасить()нить {
возврат "окрашенный в синий цвет"
}

Метод Paint реализован типами Green и Blue, которые теперь могут вызывать и использовать Покрасить метод.

кисть: = зеленый {}
ФМТ. Println (кисть. Покрасить())

«Окрашено в зеленый цвет» отображается на консоли, подтверждая, что интерфейс был успешно реализован.

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

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

В Go нет встроенной абстракции; однако вы можете работать по-нашему, реализуя абстракцию с помощью интерфейсов.

// люди могут бегать
тип Человек интерфейс {
 бежать() нить
}
// Мальчик - человек с ногами
тип Мальчик структура {
 Ноги нить
}
// метод для мальчика реализует метод запуска интерфейса Human
функция(ч Мальчик)бежать()нить {
возврат час Ноги
}

Приведенный выше код создает Человек интерфейс с бежать интерфейс, который возвращает строку. Мальчик тип реализует бежать метод Человек интерфейс и возвращает строку при создании экземпляра.

Одним из способов реализации абстракции является создание структуры, наследующей интерфейс, методы которого должны быть абстрагированы. Есть много других подходов, но этот самый простой.

тип Человек структура {
 Имя нить
 Возраст инт
 Статус человека 
}
функцияглавный() {
 person1 := &Boy{Ноги: "две ноги"}
 человек2 := &человек{ // экземпляр человека
 Имя: "Амина",
 Возраст: 19,
 Статус: человек1,
 }
 ФМТ. Печать (лиц. Статус.выполнить()) 
}

Человек структура наследует Человек интерфейс и может получить доступ ко всем его методам, используя переменную Статус наследование интерфейса.

При создании экземпляра по ссылке (используя указатель) экземпляр Человек структура Человек2 ссылается на экземпляр Мальчик структура Человек1 и получает доступ к методам.

Таким образом, вы можете указать конкретные методы, которые должны быть реализованы типом.

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

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

Это не делает функциональное программирование плохим выбором, поскольку функциональное программирование может быть полезным и лучшим для некоторых случаев использования.

Что такое объектно-ориентированное программирование? Основы, объясненные с точки зрения непрофессионала

Читать далее

Об авторе