Golang 인터페이스

Go 프로그래밍 언어에 관심을 갖게 된 이유는 인터페이스의 개념 때문이었습니다. 객체 지향 프로그래밍은 Go에서 다르게 생각됩니다. Go OOP를 다른 OOP 언어와 비교하면 이 언어에서 객체가 작동하는 방식이 다른 것을 알 수 있습니다.

Go는 간단하고 읽기 쉬운 구문으로 유명하며 25개의 기본 제공 키워드만 포함하는 언어입니다. 예를 들어 class 키워드(대부분의 언어에 있음)와 같은 유명한 키워드는 Go 구문에 존재하지 않습니다. 대신 struct는 클래스 정의에 대한 대체 키워드입니다.

이러한 단순성 때문에 상속, 다형성 및 추상화와 같은 개념은 Go에서 다르게 구현됩니다.

인터페이스 설명을 시작하기 전에 Go의 객체 정의는 struct 유형입니다. 따라서 Go에서 Person 구조체를 정의하기 위해 다음 코드 블록에서 설명합니다.

type Person struct{
    Name string
    Age int
}

그 사람은 2개의 속성(이름 및 나이 속성)을 가집니다.

인터페이스란 무엇입니까?

인터페이스는 형식이 구현할 수 있는 메서드 서명 집합입니다. 따라서 인터페이스는 개체(모든 종류의 개체)의 동작을 정의합니다.

정의는 그만큼 간단합니다.

예를 들어 Speak라는 인터페이스가 있다고 가정하면 다음과 같이 정의됩니다.

type Speak interface{
    Arabic()
    French()
    English()
}

유형이 Speak 인터페이스를 구현하도록 하려면 유형(객체 또는 변수)이 Speak 인터페이스에서 추상적으로 구현된 3가지 메서드( Arabic() , French() 및 English() )를 모두 정의해야 합니다.

Person 유형은 자체적으로 3가지 메소드 정의가 있는 경우 Speak를 구현합니다.

func (p Person) Arabic(){ /* code here */ }
func (p Person) French(){ /* code here */ }
func (p Person) English(){ /* code here */ }

다른 언어에서는 implements 키워드를 사용하여 인터페이스에서 상속해야 합니다. 그러나 함수를 정의하기만 하면 됩니다.

빈 인터페이스의 기능

Go 프로그래밍 언어에는 정적 유형 지정이 있습니다. 즉, 프로그램 수명 주기의 모든 변수는 하나의 유형(내장 또는 사용자 지정)만 있어야 합니다. 정수 변수는 정수 변수로 유지되며 다른 유형에도 동일하게 적용됩니다.
Python과 달리 변수는 새로운 다른 값으로 재할당해야만 유형을 변경할 수 있습니다.

그러나 Go는 Python의 동적 타이핑을 모방할 수 있고 단일 프로그램에서 변수를 한 유형에서 다른 유형으로 변경할 수 있으며 빈 인터페이스에 감사할 수 있습니다.

예를 들어 보겠습니다.

func main(){
    var x int
    x = 5
    x = "change x"
    fmt.Println(x)
}

유형이 다른 변수(문자열 "change x")로 정수 값x을 재할당한 후 프로그램에서 다음 오류를 표시했습니다.

./prog.go:10:6: cannot use "change x" (untyped string constant) as int value in assignment

그러나 x의 유형을 int에서 빈 인터페이스interface{}로 변경하면 프로그램이 성공적으로 실행되고 변수가 다시 할당됩니다.

func main() {
    var x interface{}
    x = 5
    fmt.Printf("x=%v of type :%T\n", x, x)
    x = "Fares"
    fmt.Printf("x=%v of type :%T", x, x)
}

x의 유형은 정수에서 문자열로 동적으로 변경되었으며 Go의 기존 유형으로 쉽게 재할당할 수 있습니다.

x=5 of type :int
x=Fares of type :string

이제 할당하지 않고 빈 인터페이스 변수를 선언하면 결과는 어떻게 될까요?
nil 값이 됩니다.

인터페이스를 사용한 다형성

다른 언어에서 다형성을 수행하려면 부모 클래스를 만들고 부모 클래스에서 상속하는 여러 자식 클래스를 만들어야 합니다.
그런 다음 부모 클래스 유형의 배열을 선언하고 하위 클래스를 인스턴스화하여 배열에 추가합니다.

GO에서는 상황이 다르게 진행됩니다. 인터페이스를 전역 사용자 정의 유형으로 처리할 수 있습니다. 위의 예에서 다형성을 구축하고 다음 코드 블록을 사용해 볼 수 있습니다.

type Speaker interface{
    Arabic()
    English()
    French()
}
type NativeSpeaker struct{
    Name string
}
type ForeignSpeaker struct{
    Name string
    Nationality string
}
func (NS NativeSpeaker) Arabic(){ /* code here */ }
func (NS NativeSpeaker) English(){ /* code here */ }
func (NS NativeSpeaker) French(){ /* code here */ }
func (FS foreignSpeaker) Arabic(){ /* code here */ }
func (FS ForeignSpeaker) English(){ /* code here */ }
func (FS ForeignSpeaker) French(){ /* code here */ }

func main() {
    listOfSpeakers := make([]Speaker, 0)
    Sp1 := NativeSpeaker{Name: "John"}
    Sp2 := ForeignSpeaker{Name: "Mohamed"}
    listOfSpeakers = append(listOfSpeakers, Sp1, Sp2)
    fmt.Println(listOfSpeakers)
}

보시다시피 스피커 인터페이스는 NativeSpeaker 및 ForeignSpeaker 사용자 정의 유형을 조합하는 전역 유형입니다. 이들은 Speak 인터페이스에서 선언된 것과 동일한 메서드 서명을 공유합니다.