Interfaccia (Interfaces) del linguaggio Go

Go language interfaces are different from those in other languages. In Go, an interface is a custom type that specifies a set of one or more method signatures, and it is abstract, so you are not allowed to create an instance of the interface. However, you can create a variable of the interface type and assign a specific type value that has the methods required by the interface. In other words, an interface is both a set of methods and a custom type.

How to create an interface?

In Go, you can create an interface using the following syntax:

type　interface_name　interface{
　　　　//方法签名
}

For example:

//创建一个接口
type　myinterface　interface{
　　　　// Metodi
　　　　fun1()　int
　　　　fun2()　float64
}

Here, the interface name is included between the type and interface keywords, and the method signature is included within the curly braces.

How to implement an interface?

In Go, to implement an interface, it is necessary to implement all the methods declared in the interface. Go language interfaces are implicitly implemented. Like other languages, it does not contain any specific keyword for implementing an interface. As shown in the following example:

//　Golang程序说明如何
//实现接口
package main
import "fmt"
//创建一个接口
type tank interface {
　　　　// Metodi
　　　　Tarea() float64
　　　　Volume() float64
}
type　myvalue　struct　{
　　　　radius　float64
　　　　height　float64
}
//实现方法
//桶的（Tank）接口
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() {
　　　　//　访问使用桶的接口
　　　　var t tank
　　　　t = myvalue{10, 14}
　　　　fmt.Println("Area del serbatoio: ", t.Tarea())
　　　　fmt.Println("Capacità del serbatoio: ", t.Volume())
}

Output:

Area del serbatoio: 908
Capacità del serbatoio: 4396

Precauzioni

• Il valore zero dell'interfaccia è nil.

• Quando l'interfaccia contiene zero metodi, questo tipo di interfaccia viene chiamato interfaccia vuota. Pertanto, tutti i tipi implementano l'interfaccia vuota.

  Sintassi:

  interface{}

• Tipo di interfaccia:L'interfaccia ha due tipi, uno statico e uno dinamico. Il tipo statico è l'interfaccia stessa, ad esempio tank nel seguente esempio. Tuttavia, l'interfaccia non ha un valore statico, quindi punta sempre al valore dinamico.
  La variabile del tipo di interfaccia contiene il valore del tipo che implementa l'interfaccia, quindi il valore di questo tipo viene chiamato valore dinamico, e il tipo è il tipo dinamico. Anche noto come valore specifico e tipo specifico.

  Esempio

  // Spiega i concetti del programma Go
  // Valore dinamico e tipo
  package main
  import "fmt"
  // Crea l'interfaccia
  type tank interface {
  　　　　// Metodi
  　　　　Tarea() float64
  　　　　Volume() float64
  }
  func main() {
  　　　　var t tank
  　　　　fmt.Println("Valore dell'interfaccia tank: ", t)
  　　　　fmt.Printf("Il tipo di tank è: %T ", t)
  }

  Output:

  Il valore dell'interfaccia tank è: <nil>
  Il tipo di tank è: <nil>

  Nell'esempio sopra, c'è un'interfaccia chiamata tank. In questo esempio,fmt.Println("Valore dell'interfaccia tank: ", t) La语句 restituisce il valore dinamico dell'interfaccia, mentre la语句 fmt.Printf("Il tipo di tank è: %T ", t) restituisce il tipo dinamico dell'interfaccia, che è nil, perché l'interfaccia qui non sa chi lo implementa.

• Asserta il tipo:In Go, l'asserta il tipo è un'operazione applicata ai valori dell'interfaccia. In altre parole, l'asserta il tipo è il processo di estrazione del valore dell'interfaccia.

  Sintassi:
  

  a.(T)

  Qui, a è il valore o l'espressione dell'interfaccia, T è anche noto come il tipo dell'asserta il tipo. L'asserta il tipo viene utilizzato per verificare se il tipo dinamico dell'operando corrisponde al tipo asserto. Se T è un tipo specifico, l'asserta il tipo verifica se il tipo dinamico di a corrisponde a T, qui, se la verifica è riuscita, l'asserta il tipo restituisce il valore dinamico di a. Altrimenti, se la verifica fallisce, l'operazione genererà un'eccezione panic. Se T è un tipo di interfaccia, l'asserta il tipo verifica se il tipo dinamico soddisfa T, qui, se la verifica è riuscita, non viene estratto il valore dinamico.

  Esempio

  // Asserta il tipo　
  package main　
  　　
  import "fmt"
  　　
  func myfun(a interface{}) {　
  　　
  　　　　// Estrae il valore di a
  　　　　val := a.(string)　
  　　　　fmt.Println("Valore: ", val)　
  }　
  func main() {　
  　　
  　　　　var val interface {　
  　　　　}= "w3codebox"
  　　　　　　
  　　　　myfun(val)　
  }

  Output:

  Il valore è: w3codebox

  Nell'esempio sopra, se viene impostatoval := a.(string)La statement viene modificata inval := a.(int)Se viene eseguita, il programma lancia un'eccezione panic. Pertanto, per evitare questo problema, utilizziamo la seguente sintassi:

  value, ok := a.(T)

  In questo caso, se il tipo di a è uguale a T, il valore contiene il valore dinamico di a e ok viene impostato su true. E se il tipo di a non è uguale a T, ok viene impostato su false e il valore contiene il valore zero, e il programma non lancia un'eccezione panic. Ecco il programma di esempio:

  Esempio

  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)
  }

  Output:

  98.09 true
  0 false

• Judgment di tipo:Nel contesto degli interfaccia Go, la judgment di tipo viene utilizzata per confrontare il tipo specifico dell'interfaccia con i diversi tipi forniti nelle istruzioni case. È simile a una dichiarazione di tipo, ma con la differenza che specifica il tipo in maiuscolo, non il valore. È anche possibile confrontare il tipo con il tipo di interfaccia. Ecco un esempio:

  Esempio

  package main
  import "fmt"
  func myfun(a interface{}) {
  　　　　// Utilizzo della judgment di tipo
  　　　　switch a.(type) {
  　　　　case int:
  　　　　　　　　fmt.Println("Tipo: int, valore: ", a.(int))
  　　　　case string:
  　　　　　　　　fmt.Println("\nTipo: string, valore: ", a.(string))
  　　　　case float64:
  　　　　　　　　fmt.Println("\nTipo: float64, valore: ", a.(float64))
  　　　　default:
  　　　　　　　　fmt.Println("\nTipo non trovato")
  　　　　}
  }

  Output:

  Tipo: string, valore: w3codebox
  Tipo: float64, valore: 67.9
  Tipo non trovato

• Uso dell'interfaccia:Quando si desidera passare diversi tipi di parametri in un metodo o una funzione, si può utilizzare l'interfaccia, come nel caso della funzione Println(). Oppure, si può utilizzare l'interfaccia quando più tipi implementano lo stesso interfaccia.