Interface do Linguagem Go (Interfaces)

O (operação de arquivo)

A interface Go é diferente de outras linguagens. Em Go, a interface é um tipo personalizado, usado para especificar um conjunto de uma ou mais assinaturas de métodos, e a interface é abstrata, portanto, não é permitido criar instâncias dessa interface. No entanto, você pode criar variáveis do tipo interface e atribuir valores específicos do tipo que têm os métodos necessários para essa interface. Em outras palavras, a interface é um conjunto de métodos e também um tipo personalizado.

Como criar uma interface?

Em Go, você pode usar a seguinte sintaxe para criar uma interface:
　　　　//type interface_name interface{
}

Assinatura do método

//Criar uma interface
Por exemplo:
　　　　//　Método
　　　　() int1type myinterface interface{
　　　　() int2fun64
}

Aqui, o nome da interface está entre as palavras-chave type e interface, e a assinatura do método está entre chaves. () float

Como implementar uma interface?

Em Go, para implementar uma interface, é necessário implementar todos os métodos declarados na interface. A interface Go é implementada implicitamente. Assim como outras linguagens, ela não contém nenhuma palavra-chave específica para implementar a interface. Veja o exemplo a seguir:

//　O programa Go explica como
//Implementar a interface
package main
import "fmt"
//Criar uma interface
type tank interface {
　　　　//　Método
　　　　Tarea() float64
　　　　Volume() float64
}
type myvalue struct {
　　　　radius float64
　　　　height float64
}
//Método de implementação
//Cadeia (Tank) interface
func (m myvalue) Tarea() float64　{
　　　　return　2*m.radius*m.height　+　2*3.14*m.radius*m.radius
}
func (m myvalue) Volume() float64　{
　　　　return　3.14　*　m.radius　*　m.radius　*　m.height
}
func main() {
　　　　//　Acesso usando a interface do barril
　　　　var t tank
　　　　t = myvalue{10,　14}
　　　　fmt.Println("A área do barril:", t.Tarea())
　　　　fmt.Println("A capacidade do barril:", t.Volume())
}

Saída:

A área do barril:　908
A capacidade do barril:　4396

Considerações

• O valor nulo da interface é nil.

• Quando a interface contém zero métodos, esse tipo de interface é chamado de interface vazia. Portanto, todos os tipos implementam a interface vazia.

  Sintaxe:

  interface{}

• Tipo de interface:A interface tem dois tipos, um estático e um dinâmico. O tipo estático é a interface em si, por exemplo, tank no exemplo abaixo. Mas a interface não tem valor estático, então ela sempre aponta para o valor dinâmico.
  A variável do tipo de interface, que contém o valor do tipo que implementa a interface, portanto, o valor deste tipo é chamado de valor dinâmico e o tipo é o tipo dinâmico. Também chamado de valor específico e tipo específico.

  Exemplo

  //Explicar os conceitos do programa Go
  //Valor dinâmico e tipo
  package main
  import "fmt"
  //Criação de interface
  type tank interface {
  　　　　//　Método
  　　　　Tarea() float64
  　　　　Volume() float64
  }
  func main() {
  　　　　var t tank
  　　　　fmt.Println("O valor da interface de tank é: ", t)
  　　　　fmt.Printf("O tipo de tank é: %T ", t)
  }

  Saída:

  O valor da interface de tank é: <nil>
  O tipo de tank é: <nil>

  No exemplo acima, há uma interface chamada tank. No exemplo presente,fmt.Println("O valor da interface de tank é: ", t) A sentença retorna o valor dinâmico da interface, enquanto a sentença fmt.Printf("O tipo de tank é: %T ", t) retorna o tipo dinâmico da interface, que é nil, porque aqui a interface não sabe quem está implementando.

• Assertivo de tipo:No Go, a assertivo de tipo é uma operação aplicada a valores de interface. Em outras palavras, a assertivo de tipo é o processo de extração de valores de interface.

  Sintaxe:
  

  a.(T)

  Aqui, a é o valor ou expressão da interface, T é o tipo de assertivo também conhecido como tipo. A assertivo de tipo é usado para verificar se o tipo dinâmico do operando coincide com o tipo assertivo. Se T for um tipo específico, a assertivo de tipo verifica se o tipo dinâmico fornecido de a coincide com T, aqui, se a verificação for bem-sucedida, a assertivo de tipo retorna o valor dinâmico de a. Caso contrário, se a verificação falhar, a operação gerará uma exceção panic. Se T for um tipo de interface, a assertivo de tipo verifica se o tipo dinâmico fornecido satisfaz T, aqui, se a verificação for bem-sucedida, não é extraído o valor dinâmico.

  Exemplo

  //Aserção de tipo　
  package main　
  　　
  import "fmt"
  　　
  func myfun(a interface{}) {　
  　　
  　　　　//Extrair o valor de a
  　　　　val := a.(string)　
  　　　　fmt.Println("valor: ", val)　
  }　
  func main() {　
  　　
  　　　　var val interface {　
  　　　　} = "w3codebox"
  　　　　　　
  　　　　myfun(val)　
  }

  Saída:

  valor: w3codebox

  No exemplo acima, se o valor forval := a。（string）a instrução é alterada paraval := a。（int）então o programa lançará exceção panic. Portanto, para evitar esse problema, usamos a seguinte sintaxe:

  value, ok := a.(T)

  Aqui, se o tipo de a for igual a T, o valor contém o valor dinâmico de a e ok é configurado como true. E se o tipo de a não for igual a T, ok é configurado como false e o valor contém o valor zero e o programa não lança exceção panic. Veja o programa a seguir:

  Exemplo

  package main
  import "fmt"
  func myfun(a interface{}) {
  　　　　value, ok := a.(float64)
  　　　　fmt.Println(value, ok)
  }
  func main() {
  　　　　var a1　interface {
  　　　　} =　98.09
  　　　　myfun(a1)
  　　　　var a2　interface {
  　　　　} = "w3codebox"
  　　　　myfun(a2)
  }

  Saída:

  98.09　true
  0 false

• Julgamento de tipo:No Go interface, o julgamento de tipo é usado para comparar o tipo específico do interface com os tipos fornecidos nas instruções case. É semelhante a uma declaração de tipo, mas com uma diferença, pois especifica o tipo em maiúsculas, não o valor. Você também pode comparar o tipo com o tipo de interface. Veja o exemplo a seguir:

  Exemplo

  package main
  import "fmt"
  func myfun(a interface{}) {
  　　　　//Uso de julgamento de tipo
  　　　　switch a.(type) {
  　　　　case int:
  　　　　　　　　fmt.Println("Tipo: int, valor: ", a.(int))
  　　　　case string:
  　　　　　　　　fmt.Println("\nTipo: string, valor: ", a.(string))
  　　　　case float64:
  　　　　　　　　fmt.Println("\nTipo: float64，valor: ", a.(float64))
  　　　　padrão:
  　　　　　　　　fmt.Println("\nTipo não encontrado")
  　　　　}
  }

  Saída:

  Tipo: string, valor: w3codebox
  Tipo: float64，valor:　　67.9
  Tipo não encontrado

• Uso da interface:Quando você deseja passar diferentes tipos de parâmetros em um método ou função, você pode usar uma interface, como a função Println(). Ou, quando vários tipos implementam a mesma interface, você também pode usar a interface.