Пример 1: пустой интерфейс Golang
Начните с пустого интерфейса {}, который в Go называется интерфейсом. Он указывает тип, который может хранить любое значение. Ниже приведен исходный код пустого интерфейса в Go:
упаковка основнойИмпортировать 'ФМТ'
тип ОценкиКалькулятор интерфейс {}
функция основной () {
был m ОценкиКалькулятор
ФМТ . Распечатать ( м )
}
Здесь мы предоставляем код, в котором интерфейс «MarksCalculator» не имеет каких-либо определенных сигнатур методов, потому что он пуст. В результате он не предоставляет никаких функций. Далее у нас есть функция main() этого пустого интерфейса, в которой объявлена переменная «m» типа MarksCalculator. Поскольку интерфейс пуст, «m» может содержать любое значение любого типа. В этом случае «m» не инициализирован, поэтому его тип имеет нулевое значение, которое равно «nil» для интерфейсов. Когда «m» печатается с помощью «fmt.Println», на консоль выводится «nil».
Полученный вывод равен «nil», как и ожидалось из предыдущего исходного кода:
Пример 2. Реализация интерфейса Golang
В этом разделе демонстрируется реализация интерфейса Golang. Тип должен предлагать реализацию для каждого указанного метода в интерфейсе, чтобы реализовать его в Go. Ниже приведен исходный код для реализации интерфейса:
упаковка основной
Импортировать (
'ФМТ'
)
тип Гласные интерфейс {
ПоискГласные () [] руна
}
тип MyStr нить
функция ( ул MyStr ) ПоискГласные () [] руна {
был гласные [] руна
для _ , руна '=' диапазон ул. {
если руна == а || руна == 'Это' || руна == 'я' || руна == 'О' || руна == 'в' {
гласные '=' добавить ( гласные , руна )
}
}
возвращаться гласные
}
функция основной () {
НоваяСтрока '=' MyStr ( «Интерфейсы GoLang» )
был v1 Гласные
v1 '=' НоваяСтрока
ФМТ . Принтф ( 'Гласные %c' , v1 . ПоискГласные ())
}
Здесь код определяет интерфейс с именем «Гласные», который указывает единственный метод SearchVowels(), который возвращает фрагмент руны (тип int32). Интерфейс позволяет любому типу, который реализует сигнатуру этого метода, быть назначенным переменной типа интерфейса. Затем объявляется новый тип «MyStr», который является псевдонимом для строки базового типа. Это означает, что «MyStr» наследует все методы строки, но является отдельным типом.
После этого реализуем метод SearchVowels() для типа MyStr. Этот метод сканирует входную строку символ за символом и проверяет, является ли каждый символ гласным ('a', 'e', 'i', 'o' или 'u'). Если символ является гласным, он добавляется к фрагменту гласного.
Внутри функции main() создается переменная NewString типа MyStr со значением GoLang Interfaces. Далее объявляется переменная «v1» типа «Гласные». Поскольку «MyStr» реализует метод SearchVowels(), определенный в интерфейсе «Vowels», «NewString» может быть присвоен «v1».
Вывод отображает весь массив гласных, которые встречаются в указанной строке:
Пример 3: Интерфейс Golang Stringer
Кроме того, Golang имеет предопределенный интерфейс «Stringer» в пакете «fmt». Это позволяет пользовательскому типу управлять своим строковым представлением при форматировании с помощью глагола «%v» в функциях печати пакета «fmt». Ниже приведен пример кода для интерфейса стрингера Go:
упаковка основнойИмпортировать (
'ФМТ'
)
тип Студент структура {
Имя нить
Степень нить
}
функция ( с Студент ) Нить () нить {
возвращаться ФМТ . Спринтф ( '%s является (n) %s' , с . Имя , с . Степень )
}
функция основной () {
с1 '=' Студент { 'Елена Гилберт' , 'Информатика' }
с2 '=' Студент { «Кэролайн Кэндис» , 'ББА' }
ФМТ . Распечатать ( с1 )
ФМТ . Распечатать ( с2 )
}
Здесь код сначала импортирует необходимый пакет «fmt» для вывода на консоль. Затем мы определяем тип структуры «Студент» с двумя полями: «Имя» и «Степень». Эта структура представляет информацию о студенте. Далее создается метод String() для типа «Студент». Этот метод имеет приемник типа «Студент» и возвращает строку. Метод «String()» — это специальный метод в Go, который используется для настройки строкового представления объекта при его печати. В этом случае метод «String()» форматирует и возвращает строку, содержащую имя и степень студента.
Затем у нас есть функция main(), в которой две переменные, s1 и s2 типа «Студент», объявляются и инициализируются информацией о студенте. Наконец, код использует функцию fmt.Println() для печати значений s1 и s2. Поскольку метод String() определен для типа «Студент», Go автоматически вызывает этот метод при печати объекта «Студент». Метод String() форматирует информацию об ученике с помощью функции «fmt.Sprintf()» и возвращает отформатированную строку.
Следующий вывод выводит объект типа «Студент» интерфейса стрингера:
Пример 4: Интерфейс переключателя типа Golang
Затем идет интерфейс переключения типа Go. Переключатель типа — это управляющая структура, которая позволяет нам проверять динамический тип значения интерфейса. Следуйте исходному коду интерфейса переключателя типа:
упаковка основнойИмпортировать 'ФМТ
func MyFunction (интерфейс F1 {}) {
переключатель F1.(тип) {
случай инт:
fmt.Println(' Тип : инт , Ценить : ', F1.(ты))
строка случая:
fmt.Println(' \nТип : нить , Ценить : ', F1.(строка))
случай поплавок64:
fmt.Println(' \nТип : поплавок64 , Ценить : ', F1.(поплавок64))
по умолчанию:
fmt.Println(' \nТип недействителен ')
}
}
основная функция () {
МояФункция(' Учебник по интерфейсам Golang ')
МояФункция(89.7)
Моя функция (истина)
}
Здесь предоставленный код определяет функцию «MyFunction», которая принимает параметр «F1» типа «интерфейс {}». Это указывает на то, что «F1» может принимать значение любого типа. Внутри функции используется оператор switch с «F1.(type)» для проверки типа значения, которое передается в «MyFunction». Синтаксис «.(type)» используется в переключателе типа для получения базового динамического типа значения интерфейса. Обратите внимание, что здесь варианты переключения обрабатывают три конкретных типа: «int», «string» и «float64». Если тип «F1» соответствует одному из этих случаев. Он печатает соответствующий тип и значение, используя утверждения типа (F1.(int), F1.(string), F1.(float64)). Если тип «F1» не соответствует ни одному из определенных случаев, выполняется случай по умолчанию, который печатает «Тип недействителен».
После этого внутри функции main() «MyFunction» вызывается три раза с разными значениями: строкой, float64 и логическим значением (которое не обрабатывается в операторе switch).
Вывод отображает демонстрацию интерфейса коммутатора с утверждениями типа:
Пример 5: Несколько интерфейсов Golang
Более того, Go предлагает несколько интерфейсов, которые позволяют ему предоставлять различные наборы действий в зависимости от контекста. Эта функция называется «несколько интерфейсов» или «композиция интерфейса». Следующий код демонстрирует реализацию нескольких интерфейсов:
упаковка основнойИмпортировать 'ФМТ'
тип птицы интерфейс {
дышать ()
летать ()
}
тип птицы интерфейс {
кормить ()
}
тип Где структура {
возраст инт
}
функция ( г где ) дышать () {
ФМТ . Распечатать ( «Голубь дышит» )
}
функция ( г где ) летать () {
ФМТ . Распечатать ( 'Голубиный полет' )
}
функция ( г где ) кормить () {
ФМТ . Распечатать ( «Голубь воспитывает малышей» )
}
функция основной () {
был б птицы
д '=' Где {}
б '=' д
б . дышать ()
б . летать ()
был птицы
а '=' д
а . кормить ()
}
Здесь мы определяем два интерфейса: «птицы» и «авианы». Интерфейс «птиц» объявляет два метода: Breath() и fly(). В то время как интерфейс «птиц» объявляет метод feed(). Затем структура «голубь» реализует все методы интерфейса «птицы» и «авианы». Он предоставляет реализации для breath(), fly() и feed().
Далее мы объявляем переменную «b» типа «birds» внутри функции main(). Экземпляр «голубя» создается и назначается «b» с помощью присваивания b = d. Так как «голубь» реализует все методы интерфейса «птицы», это назначение допустимо.
Затем методы breath() и fly() вызываются для 'b' типа 'birds'. Точно так же переменная «a» типа «avians» объявляется и присваивается экземпляру «d» «голубь». Поскольку «голубь» реализует метод feed(), определенный в интерфейсе «птиц», это назначение также допустимо. Метод feed() вызывается для «a» типа «avians». Поскольку «a» содержит экземпляр «голубя», выполняется метод feed(), реализованный «голубем».
Вывод показывает, что методы интерфейсов выполняются корректно:
Заключение
Мы изучили основы интерфейсов Go и предоставили практические примеры, иллюстрирующие их использование. Определяя интерфейсы и реализуя их с различными типами, мы можем создавать гибкие и расширяемые программы.