golang interfaces and methods

Golang interfaces and methods

Golang (or Go) is an open source programming language developed by Google. It provides an efficient programming experience through its unique concurrency model and garbage collector. Interfaces and methods in Golang are one of its core concepts and are very important to master the Golang programming language.

Interface in Golang

Interface is a way to achieve polymorphism. It defines a set of program code specifications. In the Go language, they are called interface types. They define a set of methods but do not provide implementations. Even without explicitly declaring a specific interface type, a Go program can still check whether a type meets the requirements of a specific interface.

In Golang, interfaces are very important. If you want to use Golang, then you must understand the definition and implementation of Golang interfaces. The following are some examples of Golang interface definitions:

package main

import "fmt"

type Interface1 interface {
    method1() string
}

type Interface2 interface {
    method2() int
}

type Interface3 interface {
    Interface1
    Interface2
    method3() bool
}

type Struct1 struct {
    name string
}

type Struct2 struct {
    age int
}

func (s1 *Struct1) method1() string {
    return s1.name
}

func (s2 *Struct2) method2() int {
    return s2.age
}

func (s3 *Struct1) method3() bool {
    return true
}

func main() {
    s1 := Struct1{name: "John"}
    s2 := Struct2{age: 30}

    var iInterface1 Interface1 = &s1
    var iInterface2 Interface2 = &s2
    var iInterface3 Interface3 = &s3

    fmt.Println(iInterface1.method1())
    fmt.Println(iInterface2.method2())
    fmt.Println(iInterface3.method3())
}

In this example, we define 3 interfaces, namely Interface1, Interface2 and Interface3 . Among them, Interface3 inherits Interface1 and Interface2. We also defined two structures Struct1 and Struct2, and implemented the methods of the corresponding interfaces for them. In the main() function, we use these interfaces to call their methods.

Methods in Golang

Methods are functions associated with a specific type that can access data of that type. In Golang, methods are a way of restricting functions to a specific type. They can be used to represent a type of behavior that can be called by other objects. Methods can be value methods or pointer methods, depending on whether they modify the receiver's value.

The following is an example of method definition in Golang:

package main

import "fmt"

type Struct1 struct {
    name string
}

func (s1 Struct1) method1() string {
    return s1.name
}

func (s1 *Struct1) method2() {
    s1.name = "Jane"
}

func main() {
    s1 := Struct1{name: "John"}

    fmt.Println(s1.method1())

    s1.method2()
    fmt.Println(s1.method1())
}

In this example, we define a type of Struct1 and define two methods for itmethod1() and method2(). Note that the receiver of method2() is a pointer to a structure, so it can modify the value of the structure. In the main() function, we create a Struct1 object and call these two methods respectively.

Interface nesting and type assertion

In Golang, interfaces can also be nested like structures. Nesting of interfaces can be used to combine the capabilities of multiple interfaces. Golang also provides type assertion operators for converting interfaces into values ​​of other types.

The following is an example of nesting and type assertion of Golang interfaces:

package main

import "fmt"

type Interface1 interface {
    method1() string
}

type Interface2 interface {
    method2() int
}

type Struct1 struct {
    name string
}

func (s1 *Struct1) method1() string {
    return s1.name
}

func (s1 *Struct1) method2() int {
    return len(s1.name)
}

func main() {
    s1 := Struct1{name: "John"}

    var iInterface1 Interface1 = &s1
    var iInterface2 Interface2 = iInterface1.(Interface2)

    fmt.Println(iInterface2.method2())
}

In this example, we define Interface1 and Interface2 interface, and implements two methods method1() and method2() for the Struct1 structure. In the main() function we cast a Struct1 object to the Interface1 interface and cast it again to Interface2 interface. Then we call its method2() method and output the result.

Summary

In Golang, interfaces and methods are one of the most important concepts. They provide a more efficient programming experience in Golang. By using interfaces, we can express abstract behavior independent of type. Also using methods, we can limit functions to specific types and work with various data and data types in a more direct way. Therefore, understanding the concepts of interfaces and methods is an important foundation for Golang programming.

The above is the detailed content of golang interfaces and methods. For more information, please follow other related articles on the PHP Chinese website!