Golang 인터페이스 예제

Golang Inteopeiseu Yeje



Go에서 일련의 메서드 시그니처는 인터페이스를 구성합니다. 해당 인터페이스를 이행하기 위해 결정하기 위해 유형이 수행해야 하는 작업 그룹을 지정합니다. 즉, 인터페이스는 유형이 가져야 하는 메소드를 지정하지만 구현 정보를 제공하지 않습니다. 하지만 Go 인터페이스는 다형성 동작을 달성하고 재사용 가능한 코드를 작성하는 강력한 메커니즘을 제공합니다. 이 게시물에서는 Go의 인터페이스 개념을 살펴보고 이를 사용하는 방법을 보여주는 실제 예제를 제공합니다.

예제 1: Golang 빈 인터페이스

Go에서 인터페이스라고 하는 빈 인터페이스{}로 시작합니다. 모든 종류의 값을 저장할 수 있는 형식을 나타냅니다. 다음은 Go의 빈 인터페이스에 대한 소스 코드입니다.

패키지 기본
수입 'fmt'
유형 마크 계산기 상호 작용 {}
기능 기본 () {
~였다 m 마크 계산기
fmt . Println ( )
}

여기에서는 'MarksCalculator' 인터페이스가 비어 있기 때문에 지정된 메서드 시그니처가 없는 코드를 제공합니다. 결과적으로 어떤 기능도 제공하지 않습니다. 다음으로 MarksCalculator 유형의 변수 'm'이 선언된 이 빈 인터페이스의 main() 함수가 있습니다. 인터페이스가 비어 있기 때문에 'm'은 모든 유형의 값을 보유할 수 있습니다. 이 경우 'm'은 초기화되지 않았으므로 해당 유형의 값은 0이고 인터페이스의 경우 'nil'입니다. 'fmt.Println'을 사용하여 'm'을 인쇄하면 콘솔에 'nil'이 출력됩니다.

검색된 출력은 이전 소스 코드에서 예상한 대로 'nil'입니다.

예 2: 인터페이스의 Golang 구현

이 섹션에서는 Golang 인터페이스의 구현을 보여줍니다. 유형은 Go에서 구현하기 위해 인터페이스에서 지정된 각 메소드에 대한 구현을 제공해야 합니다. 다음은 인터페이스 구현을 위한 주어진 소스 코드입니다.

패키지 기본
수입 (
'fmt'
)
유형 모음 상호 작용 {
검색모음 () []
}
유형 MyStr
기능 ( 성 MyStr ) 검색모음 () [] {
~였다 모음 []
~을 위한 _ , := 범위 {
만약에 == 'ㅏ' || == '그것은' || == '나' || == '영형' || == '안에' {
모음 = 추가 ( 모음 , )
}
}
반품 모음
}

기능 기본 () {
새 문자열 := MyStr ( 'GoLang 인터페이스' )
~였다 v1 모음
v1 = 새 문자열
fmt . Printf ( '모음은 %c입니다' , v1 . 검색모음 ())
}

여기서 코드는 룬 조각(유형 int32)을 반환하는 단일 메서드 SearchVowels()를 지정하는 'Vowels'라는 인터페이스를 정의합니다. 인터페이스를 사용하면 이 메서드 서명을 구현하는 모든 형식이 인터페이스 형식의 변수에 할당될 수 있습니다. 그런 다음 기본 유형 문자열의 별칭인 새로운 'MyStr' 유형이 선언됩니다. 즉, 'MyStr'은 문자열의 모든 메서드를 상속하지만 고유한 유형입니다.

그런 다음 'MyStr' 유형에 대한 SearchVowels() 메서드를 구현합니다. 이 메서드는 입력된 문자열을 문자별로 스캔하고 각 문자가 모음('a', 'e', 'i', 'o' 또는 'u')인지 확인합니다. 문자가 모음이면 모음 조각에 추가됩니다.

main() 함수 내에서 'MyStr' 유형의 'NewString' 변수가 'GoLang Interfaces' 값으로 생성됩니다. 다음으로 'Vowels' 타입의 'v1' 변수가 선언됩니다. 'MyStr'은 'Vowels' 인터페이스에 정의된 SearchVowels() 메서드를 구현하므로 'NewString'을 'v1'에 할당할 수 있습니다.

출력에는 지정된 문자열에서 발견되는 모든 모음 배열이 표시됩니다.

예제 3: Golang 스트링거 인터페이스

또한 Golang에는 'fmt' 패키지에 미리 정의된 'Stringer' 인터페이스가 있습니다. 'fmt' 패키지의 인쇄 기능에서 '%v' 동사로 형식을 지정할 때 사용자 정의 유형이 문자열 표현을 제어할 수 있습니다. 다음은 Go의 스트링거 인터페이스에 대한 예제 코드입니다.

패키지 기본
수입 (
'fmt'
)
유형 학생 구조체 {
이름

}
기능 ( 학생 ) () {
반품 fmt . 스프린트프 ( '%s는(n) %s입니다' , 에스 . 이름 , 에스 . )
}
기능 기본 () {
s1 := 학생 { '엘레나 길버트' , '컴퓨터 사이언스' }
s2 := 학생 { '캐롤라인 캔디스' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}

여기에서 코드는 콘솔에 인쇄하기 위해 'fmt'인 필요한 패키지를 먼저 가져옵니다. 그런 다음 'Name'과 'Degree'라는 두 개의 필드가 있는 구조체 유형 'Student'를 정의합니다. 이 구조체는 학생의 정보를 나타냅니다. 또한 'Student' 유형에 대한 String() 메서드가 생성됩니다. 이 메서드는 'Student' 유형의 수신자를 가지며 문자열을 반환합니다. 'String()' 메서드는 개체가 인쇄될 때 개체의 문자열 표현을 사용자 지정하는 데 사용되는 Go의 특수 메서드입니다. 이 경우 'String()' 메서드는 학생의 이름과 학위를 포함하는 문자열을 형식화하고 반환합니다.

다음으로, “Student” 타입의 두 변수 s1과 s2를 선언하고 학생 정보로 초기화하는 main() 함수가 있습니다. 마지막으로 코드는 fmt.Println() 함수를 사용하여 s1 및 s2의 값을 인쇄합니다. String() 메서드는 'Student' 유형에 대해 정의되어 있으므로 Go는 'Student' 개체를 인쇄할 때 이 메서드를 자동으로 호출합니다. String() 메서드는 'fmt.Sprintf()' 함수를 사용하여 학생 정보의 형식을 지정하고 형식이 지정된 문자열을 반환합니다.

다음 출력은 stringer 인터페이스의 'Student' 유형 개체를 인쇄합니다.

예제 4: Golang 유형 스위치 인터페이스

그런 다음 Go의 유형 스위치 인터페이스가 제공됩니다. 유형 스위치는 인터페이스 값의 동적 유형을 검사할 수 있는 제어 구조입니다. 유형 스위치 인터페이스의 소스 코드를 따르십시오.

패키지 기본
수입 'fmt
func MyFunction(F1 인터페이스{}) {
스위치 F1.(유형) {
케이스 정수:
fmt.Println('
유형 : 정수 , : ', F1.(너))
케이스 문자열:
fmt.Println('
\n유형 : , : ', F1.(문자열))
케이스 float64:
fmt.Println('
\n유형 : float64 , : ', F1.(float64))
기본:
fmt.Println('
\n유형이 올바르지 않습니다. ')
}
}
함수 메인() {
내함수('
Golang 인터페이스 튜토리얼 ')
마이펑션(89.7)
내함수(참)
}

여기서 제공된 코드는 'interface{}' 유형의 'F1' 매개변수를 사용하는 'MyFunction' 함수를 정의합니다. 이는 'F1'이 모든 유형의 값을 허용할 수 있음을 나타냅니다. 함수 내에서 “F1.(type)”과 함께 switch 문을 사용하여 “MyFunction”으로 전달되는 값의 유형을 확인합니다. '.(type)' 구문은 인터페이스 값의 기본 동적 유형을 가져오기 위해 유형 스위치에서 사용됩니다. 여기서 스위치 케이스는 'int', 'string' 및 'float64'의 세 가지 특정 유형을 처리합니다. 'F1' 유형이 이러한 경우 중 하나와 일치하는 경우. 유형 어설션(F1.(int), F1.(string), F1.(float64))을 사용하여 해당 유형 및 값을 인쇄합니다. 'F1' 유형이 정의된 케이스와 일치하지 않는 경우 '유형이 유효하지 않음'을 인쇄하는 기본 케이스가 실행됩니다.

그 후, main() 함수 내에서 'MyFunction'은 문자열, float64 및 부울(switch 문에서 처리되지 않음)의 서로 다른 값으로 세 번 호출됩니다.

출력에는 유형 어설션이 포함된 스위치 인터페이스의 데모가 표시됩니다.

예제 5: Golang 다중 인터페이스

또한 Go는 컨텍스트에 따라 다양한 동작 집합을 제공할 수 있는 여러 인터페이스를 제공합니다. 이 기능을 '다중 인터페이스' 또는 '인터페이스 구성'이라고 합니다. 다음 코드는 다중 인터페이스 구현을 보여줍니다.

패키지 기본
수입 'fmt'
유형 조류 상호 작용 {
숨 쉬다 ()
파리 ()
}

유형 조류 상호 작용 {
밥을 먹이다 ()
}
유형 어디 구조체 {
나이 정수
}
기능 ( d 여기서 ) 숨 쉬다 () {
fmt . Println ( '비둘기가 숨을 쉬다' )
}
기능 ( d 여기서 ) 파리 () {
fmt . Println ( '비둘기 비행' )
}
기능 ( d 여기서 ) 밥을 먹이다 () {
fmt . Println ( '비둘기는 아기를 키운다' )
}
기능 기본 () {
~였다 b 새
:= 어디 {}
=
. 숨 쉬다 ()
. 파리 ()
~였다 조류
=
. 밥을 먹이다 ()
}

여기에서 'birds'와 'avians'라는 두 가지 인터페이스를 정의합니다. 'birds' 인터페이스는 breath()와 fly()라는 두 가지 메서드를 선언합니다. 'avians' 인터페이스는 feed() 메서드를 선언합니다. 그런 다음 'dove' 구조체는 'birds' 및 'avians' 인터페이스의 모든 메서드를 구현합니다. Breath(), fly() 및 feed()에 대한 구현을 제공합니다.

다음으로 main() 함수 내에서 'birds' 유형의 변수 'b'를 선언합니다. '비둘기'의 인스턴스가 생성되고 b = d 할당을 사용하여 'b'에 할당됩니다. 'dove'는 'birds' 인터페이스의 모든 메서드를 구현하므로 이 할당이 유효합니다.

그런 다음 'birds' 유형의 'b'에서 breath() 및 fly() 메서드가 호출됩니다. 유사하게 'avians' 유형의 변수 'a'가 선언되고 'd'의 'dove' 인스턴스가 할당됩니다. 'dove'는 'avians' 인터페이스에 정의된 feed() 메서드를 구현하므로 이 할당도 유효합니다. feed() 메서드는 'avians' 유형의 'a'에서 호출됩니다. 'a'가 'dove' 인스턴스를 보유하므로 'dove'에 의해 구현된 feed() 메서드가 실행됩니다.

출력은 인터페이스의 메서드가 올바르게 실행되었음을 보여줍니다.

결론

우리는 Go 인터페이스의 기본 사항을 배웠고 사용법을 설명하는 실용적인 예제를 제공했습니다. 인터페이스를 정의하고 다양한 유형으로 구현함으로써 유연하고 확장 가능한 프로그램을 만들 수 있습니다.