이음매

1.1 인터페이스란?

대상 세계를 향한 인터페이스의 일반적인 정의는'인터페이스 정의 대상의 행위'이다.그것은 대상이 무엇을 해야 하는지만 지정한다.이런 행위를 실현하는 방법(세부 사항을 실현하는 것)은 대상을 겨냥한 것이다.
Go에서 인터페이스는 메소드 서명 세트입니다.인터페이스의 모든 방법에 대해 유형을 정의할 때, 이를 실현 인터페이스라고 부른다.OOP과 매우 비슷합니다.인터페이스는 유형이 가져야 할 방법을 지정하고 유형은 이러한 방법을 어떻게 실현하는지 결정한다.
그것 은 모든 공통성 을 지닌 방법 을 함께 정의하였으며, 그 어떠한 다른 유형 도 이러한 방법 을 실현하기만 하면 이 인터페이스 를 실현하였다
인터페이스는 하나의 방법을 정의합니다. 만약에 어떤 대상이 어떤 인터페이스의 모든 방법을 실현한다면, 이 대상은 이 인터페이스를 실현합니다.

1.2 인터페이스의 정의 문법

인터페이스 정의

/*   */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/*   */
type struct_name struct {
   /* variables */
}

/*   */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /*   */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /*  */
}

코드 예:

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

I am Nokia, I can call you!
I am iPhone, I can call you!

인터페이스는 임의의 대상에 의해 실현될 수 있다

한 대상이 임의의 여러 개의interface

를 실현할 수 있다

임의의 유형이 모두 빈 인터페이스 (우리가 이렇게 정의:인터페이스 {})를 실현했다. 즉, 0개의method를 포함하는 인터페이스

1.3 인터페이스 값

package main

import "fmt"

type Human struct {
    name  string
    age   int
    phone string
}
type Student struct {
    Human  // 
    school string
    loan   float32
}
type Employee struct {
    Human   // 
    company string
    money   float32
} //Human Sayhi 
func (h Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s
", h.name, h.phone)
} //Human Sing 
func (h Human) Sing(lyrics string) {
    fmt.Println("La la la la...", lyrics)
} //Employee Human SayHi 
func (e Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s
", e.name,
        e.company, e.phone) //Yes you can split into 2 lines here.
}

// Interface Men Human,Student Employee 
//  
type Men interface {
    SayHi()
    Sing(lyrics string)
}

func main() {
    mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
    paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
    sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
    Tom := Employee{Human{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
    // Men i
    var i Men
    //i Student
    i = mike
    fmt.Println("This is Mike, a Student:")
    i.SayHi()
    i.Sing("November rain")
    //i Employee
    i = Tom
    fmt.Println("This is Tom, an Employee:")
    i.SayHi()
    i.Sing("Born to be wild")
    // slice Men
    fmt.Println("Let's use a slice of Men and see what happens")
    x := make([]Men, 3)
    //T ， interface 
    x[0], x[1], x[2] = paul, sam, mike
    for _, value := range x {
        value.SayHi()
    }
}

    This is Mike, a Student:
    Hi, I am Mike you can call me on 222-222-XXX
    La la la la... November rain
    This is Tom, an Employee:
    Hi, I am Sam, I work at Things Ltd.. Call me on 444-222-XXX
    La la la la... Born to be wild
    Let's use a slice of Men and see what happens
    Hi, I am Paul you can call me on 111-222-XXX
    Hi, I am Sam, I work at Golang Inc.. Call me on 444-222-XXX
    Hi, I am Mike you can call me on 222-222-XXX

그럼 인터페이스 안에 도대체 어떤 값을 저장할 수 있을까요?만약에interface 변수를 정의한다면, 이 변수 안에 이interface를 실현하는 임의의 유형의 대상을 저장할 수 있습니다.예를 들어 위의 예에서 우리는 Men interface 유형의 변수 m을 정의했다. 그러면 m에 Human, Student 또는 Employee 값을 저장할 수 있다.
물론 지침을 사용하는 방식도 가능하다
단, 인터페이스 대상은 실현 대상의 속성을 호출할 수 없습니다
interface 함수 매개 변수
인터페이스 변수는 이 인터페이스 유형을 임의로 실현할 수 있는 대상을 가지고 있습니다. 이것은 함수 (method 포함) 를 작성하는 데 추가적인 사고를 제공합니다. 인터페이스 파라미터를 정의해서 함수가 각종 유형의 파라미터를 받아들일 수 있는지 여부입니다.
인터페이스 포함

package main

import "fmt"

type Human interface {
    Len()
}
type Student interface {
    Human
}

type Test struct {
}

func (h *Test) Len() {
    fmt.Println(" ")
}
func main() {
    var s Student
    s = new(Test)
    s.Len()
}

package test

import (
    "fmt"
)

type Controller struct {
    M int32
}

type Something interface {
    Get()
    Post()
}

func (c *Controller) Get() {
    fmt.Print("GET")
}

func (c *Controller) Post() {
    fmt.Print("POST")
}

package main

import (
    "fmt"
    "test"
)

type T struct {
    test.Controller
}

func (t *T) Get() {
    //new(test.Controller).Get()
    fmt.Print("T")
}
func (t *T) Post() {
    fmt.Print("T")
}
func main() {
    var something test.Something
    something = new(T)
    var t T
    t.M = 1
    //  t.Controller.M = 1
    something.Get()
}

T

Controller는 모든Something 인터페이스 방법을 실현했다. 구조체 T에서 Controller 구조체를 호출할 때 T는 자바의 계승에 해당하고 T는 Controller를 계승하기 때문에 T는 모든Something 인터페이스의 방법을 다시 쓰지 않아도 된다. 왜냐하면 부모 구조기가 이미 인터페이스를 구현했기 때문이다.
만약 Controller가 Something 인터페이스 방법을 실현하지 않았다면 T는 Something의 방법을 호출하려면 모든 방법을 실현해야 한다.something = new(test.Controller)인 경우 는 Controller의 Get 메서드를 호출합니다.
T는 Controller 구조체에 정의된 변수를 사용할 수 있습니다.

총결산

인터페이스 대상은 인터페이스 구현 대상의 속성을 호출할 수 없습니다