Exemplos de Interfaces Golang

Exemplo 1: interface vazia de Golang

Comece com a interface vazia{}, chamada de interface em Go. Indica um tipo que pode armazenar qualquer tipo de valor. A seguir está o código-fonte para a interface vazia em Go:

Aqui, fornecemos o código onde a interface “MarksCalculator” não possui nenhuma assinatura de método especificada porque está vazia. Como resultado, ele não fornece nenhuma funcionalidade. A seguir, temos a função main() dessa interface vazia onde é declarada uma variável “m” do tipo MarksCalculator. Como a interface está vazia, “m” pode conter qualquer valor de qualquer tipo. Nesse caso, “m” não foi inicializado, portanto, possui valor zero para seu tipo, que é “nil” para interfaces. Quando “m” é impresso usando “fmt.Println”, ele gera “nil” para o console.

A saída recuperada é “nil” conforme esperado do código-fonte anterior:

Exemplo 2:  Implementação Golang da interface

Esta seção demonstra a implementação da interface Golang. Um tipo deve oferecer a implementação para cada método especificado em uma interface para implementá-lo em Go. A seguir, é fornecido o código-fonte para a implementação da interface:

Aqui, o código define uma interface chamada “Vowels” que especifica um único método SearchVowels() que retorna uma fatia do rune(type int32). Uma interface permite que qualquer tipo que implemente essa assinatura de método seja atribuído a uma variável do tipo de interface. Em seguida, um novo tipo “MyStr” é declarado, que é um alias para a string de tipo subjacente. Isso significa que “MyStr” herda todos os métodos de string, mas é um tipo distinto.

Depois disso, implementamos o método SearchVowels() para o tipo “MyStr”. Este método varre a string de entrada caractere por caractere e verifica se cada caractere é uma vogal (“a”, “e”, “i”, “o” ou “u”). Se um caractere for uma vogal, ele será anexado à fatia da vogal.

Dentro da função main(), uma variável “NewString” do tipo “MyStr” é criada com o valor “GoLang Interfaces”. A seguir, é declarada uma variável “v1” do tipo “Vogals”. Como “MyStr” implementa o método SearchVowels() que é definido na interface “Vowels”, o “NewString” pode ser atribuído a “v1”.

A saída exibe toda a matriz de vogais encontradas na string especificada:

Exemplo 3: interface de longarina Golang

Além disso, o Golang possui a interface “Stringer” predefinida no pacote “fmt”. Ele permite que um tipo personalizado controle sua representação de string quando formatado com o verbo “%v” nas funções de impressão do pacote “fmt”. A seguir está o código de exemplo para a interface stringer de Go:

Aqui, o código primeiro importa o pacote necessário que é “fmt” para imprimir no console. Em seguida, definimos um struct tipo “Aluno” com dois campos: “Nome” e “Graduação”. Essa estrutura representa as informações de um aluno. Além disso, um método String() para o tipo “Student” é criado. Este método possui um receptor do tipo “Aluno” e retorna uma string. O método “String()” é um método especial em Go usado para personalizar a representação de string de um objeto quando ele é impresso. Nesse caso, o método “String()” formata e retorna uma string que inclui o nome e a graduação do aluno.

Em seguida, temos a função main() onde duas variáveis, s1 e s2 do tipo “Aluno”, são declaradas e inicializadas com as informações do aluno. Por fim, o código usa a função fmt.Println() para imprimir os valores de s1 e s2. Como o método String() é definido para o tipo “Student”, Go automaticamente chama esse método ao imprimir o objeto “Student”. O método String() formata as informações do aluno usando a função “fmt.Sprintf()” e retorna a string formatada.

A saída a seguir imprime o objeto do tipo “Student” da interface stringer:

Exemplo 4: Interface de chave do tipo Golang

Em seguida, vem a interface de troca de tipo do Go. Uma opção de tipo é uma estrutura de controle que nos permite inspecionar o tipo dinâmico de um valor de interface. Siga o código-fonte da interface do tipo switch:

Aqui, o código fornecido define uma função “MyFunction” que recebe um parâmetro “F1” do tipo “interface{}”. Isso indica que “F1” pode aceitar um valor de qualquer tipo. Dentro da função, uma instrução switch é usada com “F1.(type)” para verificar o tipo do valor que é passado para “MyFunction”. A sintaxe “.(type)” é usada em uma opção de tipo para obter o tipo dinâmico subjacente de um valor de interface. Observe que os casos de switch aqui lidam com três tipos específicos: “int”, “string” e “float64”. Se o tipo “F1” corresponder a um desses casos. Ele imprime o tipo e o valor correspondentes usando as declarações de tipo (F1.(int), F1.(string), F1.(float64)). Se o tipo “F1” não corresponder a nenhum dos casos definidos, é executado o caso padrão que imprime “O tipo não é válido”.

Depois disso, dentro da função main(), “MyFunction” é chamado três vezes com valores diferentes: uma string, um float64 e um booleano (que não é tratado na instrução switch).

A saída exibe a demonstração da interface do switch com as afirmações do tipo:

Exemplo 5: Interfaces Múltiplas Golang

Além disso, Go oferece múltiplas interfaces que permitem fornecer diferentes conjuntos de comportamentos dependendo do contexto. Esse recurso é chamado de “múltiplas interfaces” ou “composição de interface”. O código a seguir demonstra a implementação de múltiplas interfaces:

Aqui, definimos duas interfaces: “birds” e “avians”. A interface 'birds' declara dois métodos: breath() e fly(). Enquanto a interface “avians” declara o método feed(). Em seguida, a estrutura “dove” implementa todos os métodos das interfaces “birds” e “avians”. Ele fornece as implementações para breath(), fly() e feed().

Em seguida, declaramos a variável “b” do tipo “birds” dentro da função main(). Uma instância de uma “pomba” é criada e atribuída a “b” usando a atribuição b = d. Como “dove” implementa todos os métodos da interface “birds”, esta atribuição é válida.

Em seguida, os métodos breath() e fly() são chamados em “b” que é do tipo “birds”. Da mesma forma, uma variável “a” do tipo “avians” é declarada e atribuída com a instância “dove” de “d”. Como “dove” implementa o método feed() que é definido na interface “avians”, essa atribuição também é válida. O método feed() é chamado em “a” que é do tipo “avians”. Como “a” contém a instância “dove”, o método feed() que é implementado pelo “dove” é executado.

A saída mostra que os métodos das interfaces são executados corretamente:

Conclusão

Aprendemos o básico das interfaces Go e fornecemos exemplos práticos para ilustrar seu uso. Ao definir interfaces e implementá-las com diferentes tipos, podemos criar programas flexíveis e extensíveis.