Interfaces in der Sprache Go
unten:
Das Interface-Design von Go ist einfach und dennoch leistungsstark und ein wichtiges Werkzeug, um Polymorphismus und Entkopplung zu erreichen.
Interfaces ermöglichen es uns, verschiedene Typen an eine Reihe gemeinsamer Methoden zu binden und dadurch Polymorphismus und flexibles Design zu ermöglichen.
Interface-Merkmale
Implizite Implementierung:
- Go hat kein Schlüsselwort, um explizit zu deklarieren, dass ein Typ ein Interface implementiert.
- Solange ein Typ alle Methoden implementiert, die ein Interface erfordert, gilt der Typ automatisch als Implementierung dieses Interfaces.
Variablen vom Interface-Typ:
- Eine Interface-Variable kann jeden Wert speichern, der das Interface implementiert.
- Eine Interface-Variable besteht tatsächlich aus zwei Teilen:
- Dynamischer Typ: speichert den tatsächlichen Werttyp.
- Dynamischer Wert: speichert den konkreten Wert.
Nullwert-Interface:
- Der Nullwert eines Interfaces ist
nil。 - Der Wert einer nicht initialisierten Interface-Variable ist
nil, und es enthält weder einen dynamischen Typ noch einen Wert.
Leeres Interface:
- Definiert als
interface{}, kann jeden Typ repräsentieren.
Häufige Verwendungen von Interfaces
- PolymorphismusVerschiedene Typen, die dasselbe Interface implementieren, erreichen polymorphes Verhalten.
- EntkopplungDie Definition von Abhängigkeiten über Interfaces reduziert die Kopplung zwischen Modulen.
- Generalisierung: Verwendung des leeren Interfaces
interface{}repräsentiert jeden Typ.
Interface-Definition und -Implementierung
Interface-Definitionen verwenden das Schlüsselwortinterface, das Methodendeklarationen enthält.
Beispiel
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
/* Struct definieren */
type struct_name struct {
/* Variablen */
}
/* Schnittstellenmethoden implementieren */
func (struct_name_variable struct_name) method_name1() [return_type] {
/* Methodenimplementierung */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
/* Methodenimplementierung*/
}
Definiere eine einfache Schnittstelle:
type Shape interface {
Area() float64
Perimeter() float64
}Shapeist eine Schnittstelle, die zwei Methoden definiert:AreaundPerimeter。- Jeder Typ, der diese beiden Methoden implementiert, gilt als Implementierer der Schnittstelle.
ShapeSchnittstelle.
Schnittstelle implementieren:Typen implementieren eine Schnittstelle, indem sie alle von der Schnittstelle geforderten Methoden implementieren.
Beispiel
import (
"fmt"
"math"
)
// Schnittstelle definieren
type Shape interface {
Area() float64
Perimeter() float64
}
// Definiere eine Struktur
type Circle struct {
Radius float64
}
// Circle implementiert das Shape-Interface
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
return 2 * math.Pi * c.Radius
}
func main() {
c := Circle{Radius: 5}
var s Shape = c // Interface-Variablen können Typen speichern, die das Interface implementieren
fmt.Println("Fläche:", s.Area())
fmt.Println("Umfang:", s.Perimeter())
}
Führen Sie den obigen Code aus, die Ausgabe ist:
Area: 78.53981633974483 Perimeter: 31.41592653589793
Leeres Interface
Leeres Interfaceinterface{}Es ist ein spezielles Interface in Go, das die Obermenge aller Typen darstellt.
- Jeder Typ implementiert das leere Interface.
- Es wird häufig in Szenarien verwendet, in denen Daten beliebigen Typs gespeichert werden müssen, wie z. B. generische Container, generische Parameter usw.
Beispiel
import "fmt"
func printValue(val interface{}) {
fmt.Printf("Wert: %v, Typ: %T\n", val, val)
}
func main() {
printValue(42) // int
printValue("hallo") // string
printValue(3.14) // float64
printValue([]int{1, 2}) // Slice
}
Führen Sie den obigen Code aus, die Ausgabe ist:
Value: 42, Type: int Value: hello, Type: string Value: 3.14, Type: float64 Value: [1 2], Type: []int
Typzusicherung
Eine Typzusicherung wird verwendet, um den zugrunde liegenden Wert aus einem Interface-Typ zu extrahieren.
Grundlegende Syntax:
value := iface.(Type)
ifaceist eine Interface-Variable.Typeist der konkrete Typ, der zugesichert werden soll.- Wenn der Typ nicht übereinstimmt, wird ausgelöst
panic。
Beispiel
import "fmt"
func main() {
var i interface{} = "hello"
str := i.(string) // Typzusicherung
fmt.Println(str) // Ausgabe: hello
}
Typzusicherung mit Prüfung
Um panic zu vermeiden, kann eine geprüfte Typzusicherung verwendet werden:
value, ok := iface.(Type)
okEs ist ein boolescher Wert, der angibt, ob die Typzusicherung erfolgreich war.- Wenn die Typzusicherung fehlschlägt,
valueist der Nullwert,okistfalse。
Beispiel
import "fmt"
func main() {
var i interface{} = 42
if str, ok := i.(string); ok {
fmt.Println("String:", str)
} else {
fmt.Println("Not a string")
}
}
Führen Sie den obigen Code aus, die Ausgabe ist:
Not a string
Typswitch
Ein Typswitch ist ein Syntaxkonstrukt in Go, das verwendet wird, um unterschiedliche Logik basierend auf dem konkreten Typ einer Interface-Variablen auszuführen.
Beispiel
import "fmt"
func printType(val interface{}) {
switch v := val.(type) {
case int:
fmt.Println("Integer:", v)
case string:
fmt.Println("String:", v)
case float64:
fmt.Println("Gleitkommazahl:", v)
default:
fmt.Println("Unbekannter Typ")
}
}
func main() {
printType(42)
printType("Hallo")
printType(3.14)
printType([]int{1, 2, 3})
}
Führen Sie den obigen Code aus, die Ausgabe ist:
Integer: 42 String: hello Float: 3.14 Unknown type
Interface-Komposition
Interfaces können komplexere Verhaltensweisen durch Verschachtelung und Komposition beschreiben.
Beispiel
import "fmt"
type Reader interface {
Read() string
}
type Writer interface {
Write(data string)
}
type ReadWriter interface {
Reader
Writer
}
type File struct{}
func (f File) Read() string {
return "Daten lesen"
}
func (f File) Write(data string) {
fmt.Println("Daten schreiben:", data)
}
func main() {
var rw ReadWriter = File{}
fmt.Println(rw.Read())
rw.Write("Hallo, Go!")
}
dynamischer Wert und dynamischer Typ
Eine Interface-Variable enthält tatsächlich zwei Teile:
- Dynamischer Typ: der in der Interface-Variable gespeicherte konkrete Typ.
- Dynamischer Wert: der Wert des konkreten Typs.
Beispiel für dynamischen Wert und dynamischen Typ:
Beispiel
import "fmt"
func main() {
var i interface{} = 42
fmt.Printf("Dynamic type: %T, Dynamic value: %v\n", i, i)
}
Führen Sie den obigen Code aus, die Ausgabe ist:
Dynamic type: int, Dynamic value: 42
Nullwert eines Interfaces
Der Nullwert eines Interfaces ist nil.
Wenn sowohl der dynamische Typ als auch der dynamische Wert einer Interface-Variable nil sind, ist die Interface-Variable nil.
Beispiel für den Nullwert eines Interfaces:
Beispiel
import "fmt"
func main() {
var i interface{}
fmt.Println(i == nil) // Ausgabe: true
}
Übungsbeispiele
Die folgenden zwei Beispiele demonstrieren die Verwendung von Interfaces:
Beispiel 1
import (
"fmt"
)
type Phone interface {
call()
}
type NokiaPhone struct {
}
func (nokiaPhone NokiaPhone) call() {
fmt.Println("Ich bin Nokia, ich kann dich anrufen!")
}
type IPhone struct {
}
func (iPhone IPhone) call() {
fmt.Println("Ich bin iPhone, ich kann dich anrufen!")
}
func main() {
var phone Phone
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}
Im obigen Beispiel haben wir eine Schnittstelle definiert.Phone, die Schnittstelle enthält eine Methodecall(). Dann rufen wirmainIn der Funktion wird einePhone-Typ-Variable definiert, und ihr werden jeweils Werte alsNokiaPhoneundIPhone zugewiesen. Dann wird die Methodecall()aufgerufen, die Ausgabe sieht wie folgt aus:
I am Nokia, I can call you! I am iPhone, I can call you!
Das zweite Schnittstellenbeispiel:
Beispiel
import "fmt"
type Shape interface {
area() float64
}
type Rectangle struct {
width float64
height float64
}
func (r Rectangle) area() float64 {
return r.width * r.height
}
type Circle struct {
radius float64
}
func (c Circle) area() float64 {
return 3.14 * c.radius * c.radius
}
func main() {
var s Shape
s = Rectangle{width: 10, height: 5}
fmt.Printf("Rectangle area: %f\n", s.area())
s = Circle{radius: 3}
fmt.Printf("Circle area: %f\n", s.area())
}
Im obigen Beispiel haben wir ein Shape-Interface definiert, das eine Methode area() definiert, die einen Flächenwert vom Typ float64 zurückgibt. Dann haben wir zwei Structs definiert, Rectangle und Circle, die jeweils die Methode area() des Shape-Interface implementieren. In der Funktion main() haben wir zuerst eine Variable s vom Typ Shape definiert, dann ihr jeweils Instanzen von Rectangle und Circle zugewiesen und über die Methode area() ihre Flächen berechnet und ausgegeben. Die Ausgabe ist wie folgt:
矩形面积: 50.000000 圆形面积: 28.260000
Es ist zu beachten, dass eine Variable vom Interface-Typ einen Wert eines beliebigen Typs speichern kann, der das Interface implementiert. Im Beispiel haben wir der Variablen s vom Typ Shape sowohl Instanzen des Typs Rectangle als auch des Typs Circle zugewiesen und ihre Flächenberechnungsmethoden über die Methode area() aufgerufen.
Weitere Erweiterungen