Go-Sprachinterface (Interfaces)

Die Go-Sprache Schnittstelle ist anders als in anderen Sprachen. In der Go-Sprache ist die Schnittstelle ein benutzerdefinierter Typ, der zur Angabe einer Gruppe von einer oder mehreren Methodensignaturen verwendet wird, und die Schnittstelle ist abstrakt, daher ist es nicht erlaubt, eine Instanz der Schnittstelle zu erstellen. Aber man kann Variablen des Schnittstellen-Typs erstellen und kann dieser Variable spezifische Typen zuweisen, die die erforderlichen Methoden der Schnittstelle haben. Mit anderen Worten, die Schnittstelle ist sowohl eine Sammlung von Methoden als auch ein benutzerdefinierter Typ.

Wie wird eine Schnittstelle erstellt?

In der Go-Sprache kann man die folgenden Syntax verwenden, um eine Schnittstelle zu erstellen:

type interface_name interface{
　　　　//Methodensignatur
}

Zum Beispiel:

//Eine Schnittstelle erstellen
type myinterface interface{
　　　　//　Methode
　　　　fun1() int
　　　　fun2() float64
}

Hier ist der Name der Schnittstelle zwischen den Schlüsselwörtern type und interface enthalten, und die Methodensignatur zwischen den geschweiften Klammern.

Wie wird eine Schnittstelle implementiert?

Um in Go-Sprache eine Schnittstelle zu realisieren, müssen alle in der Schnittstelle deklarierten Methoden implementiert werden. Go-Sprache Schnittstelle wird implizit implementiert. Wie in anderen Sprachen, enthält sie keine spezifische Schlüsselwörter zur Implementierung der Schnittstelle. Wie im folgenden Beispiel gezeigt:

//　Erklärung in Golang-Programm, wie
//Schnittstelle implementieren
package　main
import　"fmt"
//Eine Schnittstelle erstellen
type tank interface {
　　　　//　Methode
　　　　Tarea() float64
　　　　Volume() float64
}
type myvalue struct {
　　　　radius float64
　　　　height float64
}
//Implementierungsmethode
//Kübel (Tank) Schnittstelle
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()　{
　　　　//　Zugriff auf das Interface des Behälters
　　　　var t tank
　　　　t = myvalue{10,　14}
　　　　fmt.Println("Der Flächeninhalt des Behälters:", t.Tarea())
　　　　fmt.Println("Der Fassungsvolumen des Behälters:", t.Volume())
}

Ausgabe:

Der Flächeninhalt des Behälters:　908
Der Fassungsvolumen des Behälters:　4396

Hinweise

• Der Nullwert des Interfaces ist nil.

• Wenn das Interface keine Methoden enthält, wird dieses Interface als leeres Interface bezeichnet. Daher implementieren alle Typen das leere Interface.

  Syntax:

  interface{}

• Interface-Typ:Das Interface hat zwei Typen, einen statischen und einen dynamischen. Der statische Typ ist das Interface selbst, z.B. tank im obigen Beispiel. Das Interface hat jedoch keinen statischen Wert, daher verweist es immer auf den dynamischen Wert.
  Variablen des Interface-Typs, die Werte der Typen enthalten, die das Interface implementieren, daher wird der Wert dieses Typs als dynamischer Wert bezeichnet, und der Typ ist der dynamische Typ. Sie werden auch als konkreter Wert und konkreter Typ bezeichnet.

  Beispiel

  //Erklärung der Konzepte von Go-Programmen
  //Dynamischer Wert und Typ
  package　main
  import　"fmt"
  //Interface erstellen
  type tank interface {
  　　　　//　Methode
  　　　　Tarea() float64
  　　　　Volume() float64
  }
  func　main()　{
  　　　　var t tank
  　　　　fmt.Println("Der Wert des tank Interface ist: ", t)
  　　　　fmt.Printf("Der Typ von tank ist: %T ", t)
  }

  Ausgabe:

  Der Wert des tank Interface ist: <nil>
  Der Typ von tank ist: <nil>

  Im obigen Beispiel gibt es ein Interface namens tank. In diesem Beispielfmt.Println("Der Wert des tank Interface ist: ", t) Das Statement gibt den dynamischen Wert des Interfaces zurück, während das Statement fmt.Printf("Der Typ von tank ist: %T ", t) den dynamischen Typ des Interfaces zurückgibt, d.h. nil, da das Interface hier nicht weiß, wer es implementiert.

• TypAssertion:In der Sprache Go wird der TypAssertion auf Interface-Werte angewendet. Mit anderen Worten, der TypAssertion ist ein Prozess zur Extraktion von Interface-Werten.

  Syntax:
  

  a.(T)

  Hier ist a der Wert oder Ausdruck des Interfaces, T ist der Typ, der auch als TypAssertion bezeichnet wird. Der TypAssertion wird verwendet, um zu überprüfen, ob der dynamische Typ des Operanden mit dem angegebenen Typ übereinstimmt. Wenn T ein konkreter Typ ist, überprüft der TypAssertion, ob der angegebene dynamische Typ von a gleich T ist. Wenn die Überprüfung erfolgreich durchgeführt wird, gibt der TypAssertion den dynamischen Wert von a zurück. Andernfalls tritt eine Panic-Exception auf, wenn die Überprüfung fehlschlägt. Wenn T ein Interface-Typ ist, überprüft der TypAssertion, ob der angegebene dynamische Typ mit T übereinstimmt. Wenn die Überprüfung erfolgreich durchgeführt wird, wird der dynamische Wert nicht extrahiert.

  Beispiel

  //Typische assertion　
  package　main　
  　　
  import　"fmt"
  　　
  func　myfun(a　interface{})　{　
  　　
  　　　　//Den Wert von a extrahieren
  　　　　val　:=　a.(string)　
  　　　　fmt.Println("Wert:　",　val)　
  }　
  func　main()　{　
  　　
  　　　　var　val　interface　{　
  　　　　}　=　"w3codebox"
  　　　　　　
  　　　　myfun(val)　
  }

  Ausgabe:

  Wert:　　w3codebox

  im obigen Beispiel, wennval：= a。（string）Der Befehl wird inval：= a。（int）wird das Programm eine panic-Exception werfen. Daher verwenden wir die folgende Syntax, um dieses Problem zu vermeiden:

  value,　ok　:=　a.(T)

  Hierbei enthält der Wert, wenn der Typ von a T ist, den dynamischen Wert von a und ok wird auf true gesetzt. Und wenn der Typ von a nicht T ist, wird ok auf false gesetzt und der Wert enthält den Nullwert, und das Programm wirft keine panic-Exception aus. Wie im folgenden Programm gezeigt:

  Beispiel

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

  Ausgabe:

  98.09　true
  0　false

• Typenbeurteilung:In Go-Schnittstellen wird die Typenbeurteilung verwendet, um den spezifischen Typ des Interfaces mit den in den case-Anweisungen angegebenen verschiedenen Typen zu vergleichen. Sie ähnelt der Typdeklaration, hat aber einen Unterschied, nämlich dass der Typ großgeschrieben wird, anstatt des Wertes. Man kann auch den Typ mit dem Interface-Typ vergleichen. Wie im folgenden Beispiel gezeigt:

  Beispiel

  package　main
  import　"fmt"
  func　myfun(a　interface{})　{
  　　　　//Typenbeurteilung verwenden
  　　　　switch　a.(type)　{
  　　　　case　int:
  　　　　　　　　fmt.Println("Typ:　int，Wert:",　a.(int))
  　　　　case　string:
  　　　　　　　　fmt.Println("\nTyp:　string，Wert:　",　a.(string))
  　　　　case　float64:
  　　　　　　　　fmt.Println("\nTyp:　float64，Wert:　",　a.(float64))
  　　　　default:
  　　　　　　　　fmt.Println("\nTyp nicht gefunden")
  　　　　}
  }

  Ausgabe:

  Typ:　string，Wert:　　w3codebox
  Typ:　float64，Wert:　　67.9
  Typ nicht gefunden

• Verwendung der Schnittstelle:Wenn Sie in einer Methode oder Funktion, in der verschiedene Arten von Parametern übermittelt werden sollen, eine Schnittstelle verwenden möchten, wie z.B. die Funktion Println(), oder wenn mehrere Typen dieselbe Schnittstelle implementieren, können Sie ebenfalls eine Schnittstelle verwenden.