17.1. 프로그램언어 고(Go)의 인터페이스 생성과 활용

by

프로그램언어 고(Go)의 인터페이스 생성방법

고(Go)언어의 인터페이스 생성방법을 설명드리겠습니다.

고(Go)언어에서 인터페이스는 메소드의 집합을 정의하는 것입니다. 인터페이스를 정의할 때는 ‘type’ 키워드 뒤에 인터페이스 이름을 정의하고, 중괄호 안에 메소드 시그니처를 정의합니다.

type 인터페이스이름 interface {
    메소드1(인자1 타입1, 인자2 타입2) 반환형
    메소드2(인자1 타입1) 반환형 
}

인터페이스에 정의된 메소드들은 반드시 구현하는 구조체에서 구현해야 합니다. 

type 구조체명 struct {

}

func (s *구조체명) 메소드1(인자1 타입1, 인자2 타입2) 반환형 {
    //메소드 구현
}

func (s *구조체명) 메소드2(인자1 타입1) 반환형 {
   //메소드 구현
}

위처럼 인터페이스에서 정의한 메소드 시그니처들을 구조체가 구현하면 그 구조체는 그 인터페이스를 구현한 것입니다. 인터페이스 타입의 변수에 구현한 구조체의 인스턴스를 할당할 수 있습니다.

var 인터페이스변수 인터페이스타입 = 구조체인스턴스

이렇게 하면 인터페이스 변수를 통해 구현한 구조체의 메소드를 호출할 수 있습니다. 인터페이스는 구조체들의 일관된 메소드 집합을 정의할 수 있다는 장점이 있습니다.

지금까지 고(Go)언어의 인터페이스 생성방법에 대해 예제코드와 함께 쉽게 설명해드렸습니다. 더 궁금하신 점이 있다면 언제든지 문의주세요.

프로그램언어 고(Go)에서의 인터페이스 활용 예제

프로그램언어 고(Go)에서 인터페이스는 다른 객체 지향 언어와 비슷하게 사용됩니다. 인터페이스를 정의하고 그 인터페이스를 구현하는 구조체를 만들 수 있습니다.

예를 들어 다음과 같이 Reader 인터페이스를 정의할 수 있습니다.

type Reader interface {
    Read(b []byte) (n int, err error)
}

이 인터페이스는 Read 메서드를 가지고 있습니다. 이 인터페이스를 구현하는任意的 구조체는 Read 메서드를 제공해야 합니다.

예를 들어 다음과 같이 StringReader 구조체를 만들어 볼 수 있습니다.

type StringReader struct {
    s string
}

func (r *StringReader) Read(b []byte) (n int, err error) {
    copy(b, r.s)
    return len(r.s), io.EOF
}

StringReader는 Reader 인터페이스를 구현했습니다. Read메서드를 제공하고 있기 때문입니다.

이제 이 StringReader를 Reader 인터페이스 타입의 변수로 사용할 수 있습니다.

var r Reader = &StringReader{"hello"}
b := make([]byte, 5)
n, err := r.Read(b)
fmt.Println(n, err, b)

위와 같이 Reader 인터페이스 타입으로 StringReader 구조체를 사용할 수 있습니다. 인터페이스를 사용하면 구현부분과 사용부분을 분리할 수 있어 유연성이 높아집니다.

프로그램언어 고(Go)에서의 인터페이스 메서드 구현 방법

고(Go)언어에서 인터페이스 메서드를 구현하는 방법은 다음과 같습니다.

인터페이스는 메서드의 시그너처(signature)만 정의하고, 구현은 구현하는 구조체나 타입에서 해야 합니다. 예를 들어 다음과 같은 인터페이스가 있다고 할 때,

type Reader interface {
    Read(b []byte) (n int, err error)
}

Read() 메서드의 시그너처만 정의되어 있고 실제 로직은 구현되어 있지 않습니다. 이 인터페이스를 구현하는 타입은 다음과 같이 Read() 메서드를 반드시 구현해야 합니다.

type File struct {
    // ...
}

func (f *File) Read(b []byte) (n int, err error) {
    // 실제 로직 구현
}

File 구조체가 Reader 인터페이스를 구현하기 위해서는 반드시 Read() 메서드를 가지고 있어야 하며, 시그너처도 정확히 일치해야 합니다.

인터페이스 메서드를 구현할 때 주의할 점은, 인터페이스에서 정의한 시그너처를 정확히 구현하는 것입니다. 시그너처가 일치하지 않으면 인터페이스를 구현했다고 볼 수 없습니다.

이러한 인터페이스와 구조체의 결합은, 인터페이스 타입으로 선언된 변수에 구현된 구조체의 인스턴스를 할당할 수 있게 해줍니다. 즉, 동일한 인터페이스를 구현한 다양한 타입을 통일된 방식으로 다룰 수 있다는 장점이 있습니다.

이상으로 고(Go)언어의 인터페이스 메서드 구현 방법에 대한 설명을 마치겠습니다. 예제 코드와 함께 충분한 설명을 제공했기를 바랍니다. 더 궁금한 점이 있으시면 언제든 질문해 주세요.

프로그램언어 고(Go)에서의 인터페이스와 구조체의 관계

프로그램언어 고(Go)에서 인터페이스와 구조체의 관계에 대해 설명드리겠습니다.

고(Go)에서 인터페이스는 메서드 시그니처들의 집합을 정의합니다. 인터페이스를 구현하는 구조체는 그 인터페이스에서 정의한 메서드들을 반드시 구현해야 합니다.

예를 들어, 다음과 같이 Reader 인터페이스를 정의할 수 있습니다.

type Reader interface {
    Read(b []byte) (n int, err error)
}

Reader 인터페이스는 Read 메서드의 시그니처만 정의할 뿐, 구현은 제공하지 않습니다.

그리고 Reader 인터페이스를 구현하는 구조체는 다음과 같이 정의할 수 있습니다.

type File struct {
    // ...
}

func (f *File) Read(b []byte) (n int, err error) {
    // Read 메서드 구현 
}

File 구조체는 Reader 인터페이스에서 정의한 Read 메서드를 실제로 구현하고 있습니다. 이를 통해 File은 Reader 인터페이스를 구현했다고 할 수 있습니다.

인터페이스 변수에 구조체 인스턴스를 할당할 수 있으며, 이 인터페이스 변수를 통해 그 구조체에서 구현한 메서드들을 호출할 수 있습니다.

var r Reader = &File{} 
r.Read() // File의 Read 메서드가 호출됨

이러한 인터페이스와 구조체의 관계를 통해 고(Go)는 추상화와 다형성을 구현할 수 있게 됩니다. 인터페이스 타입으로 선언된 변수에 그 인터페이스를 구현하는 다양한 구조체를 할당할 수 있기 때문입니다.

프로그램언어 고(Go)에서의 인터페이스에 대한 베스트 프랙티스

Go언어에서 인터페이스는 타입의 일종으로, 구현해야 할 메서드의 시그니처(signature)를 정의합니다. 인터페이스를 사용하는 주요 이유는 다음과 같습니다.

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

1. 구조체의 동작을 정의하기 위해
위처럼 Reader, Writer 인터페이스를 정의하고, 이를 구현하는 구조체를 만들면 동일한 인터페이스를 가진 타입들을 동일하게 취급할 수 있습니다.

2. 의존성 주입(Dependency Injection)을 위해
인터페이스 타입을 받는 함수나 메서드는 해당 인터페이스를 구현하는 타입이라면 어떤 것이든 받을 수 있습니다. 이를 의존성 주입으로 사용할 수 있습니다.

func StoreData(r Reader) {
    // ...
}

StoreData 함수는 Reader 인터페이스 타입을 받기 때문에, 이 인터페이스를 구현하는 어떤 타입의 값이라도 전달받을 수 있습니다.

3. 테스트 용이성을 위해
인터페이스를 구현하는 가짜 객체(mock object)를 만들어 테스트에 사용할 수 있습니다.

Go에서 인터페이스를 사용할 때 주의할 점은 인터페이스도 하나의 타입이라는 것입니다. 따라서 인터페이스 타입끼리는 서로 타입 변환이 불가합니다.

또한 값에 대한 정보를 갖고 있지 않기 때문에 인터페이스에는 함수만 정의할 수 있습니다. 변수나 상수를 정의할 수 없습니다.

이외에도 인터페이스 내부의 메서드들은 반드시 공개(public)로 선언되어야 합니다.

인터페이스 베스트 프랙티스로는 인터페이스와 구현체를 분리하고, 가능하면 인터페이스만 받아서 사용하는 것을 권장합니다. 이로써 해당 타입에 대한 의존성을 줄이고 테스트 용이성을 높일 수 있습니다.

Leave a Comment