How to create and set up interfaces in golang (a brief analysis of methods)

In Golang, interface is a type that describes the behavior of objects. By defining interfaces, we can standardize the functions and interaction methods of objects to facilitate the interaction of different types of objects.

In Golang, the method set of an interface is composed of a set of method definitions. The type that implements the interface must implement all methods of the interface. However, when implementing an interface, we do not need to explicitly declare to implement an interface, nor do we need to inherit a class or implement an interface. We only need to implement the method set of the interface. The interface is implemented in the form of dynamic dispatch, which has good flexibility and scalability.

So, how to create and set up interfaces in Golang? Next, we will introduce it from the following aspects.

1. Define interface

First, we need to define the interface, define the interface type by adding the type keyword to interface, and define the method set of the interface in brackets, for example :

type MyInterface interface {
    Method1() string
    Method2() int
}

The above code defines an interface type named MyInterface, which contains two methods Method1 and Method2. Note that the methods defined in the interface have no specific implementation bodies, only the method name and return value type.

2. Implementing the interface

Next, we need to implement the interface by defining a structure type that implements the interface method set, for example:

type MyStruct struct{}

func (m MyStruct) Method1() string{
    return "Method1 is called."
}

func (m MyStruct) Method2() int{
    return 100
}

The above code defines a structure type named MyStruct, which implements the two methods Method1 and Method2 of the MyInterface interface. It should be noted that the method that implements the interface needs to use the method name, parameter list and return value type that are exactly the same as those defined in the interface in order to be recognized as an implementation of the interface. In this example, the method set in the MyStruct type also implements the method set of MyInterface, that is, the MyInterface interface is implemented.

3. Using interfaces

Using interfaces is the most basic operation related to interfaces in Golang. By defining a variable of interface type, we can assign various values ​​to this variable. Types that implement different interfaces, for example:

var i MyInterface
i = MyStruct{}

fmt.Println(i.Method1())
fmt.Println(i.Method2())

The above code defines a variable i of type MyInterfce and assigns a variable of type MyStruct to it. Because the MyStruct type implements the MyInterface interface, i can access all methods defined in MyInterface. The output result is:

Method1 is called.
100

It should be noted that when we assign a variable of type MyStruct to a variable of type MyInterface i , actually assigns a copy of the MyStruct type value to the MyInterface type variable i, which is similar to the virtual function implementation in C. Therefore, be careful when using pointer types to implement interfaces, because when the object pointed to by a pointer type variable changes, it may affect the availability of the interface implementation.

4. Nesting of interfaces

In Golang, interfaces also support nesting, that is, nesting other interface types as method sets in the interface. For example:

type MyInterface1 interface {
    Method1() string
}

type MyInterface2 interface {
    MyInterface1
    Method2() int
}

type MyStruct struct{}

func (m MyStruct) Method1() string{
    return "Method1 is called."
}

func (m MyStruct) Method2() int{
    return 100
}

func main() {
    var i MyInterface2
    i = MyStruct{}

    fmt.Println(i.Method1())
    fmt.Println(i.Method2())
}

The above code defines a MyInterface2 interface, which defines a nested MyInterface1 interface and implements the methods of the MyInterface1 and MyInterface2 interfaces. The MyStruct type also implements these two interfaces, so it can be assigned to i and call methods.

5. Empty Interface

In Golang, if we don’t know the specific type of an object, but still want to operate on it, we can still use the interface to complete it . This is the concept of empty interface. An empty interface is a special type in Golang. Its method set is empty and can represent any type of object. For example:

var i interface{}
i = 1

fmt.Println(i)

The above code defines a variable i of type interface{}, and then assigns the integer 1 to it. Because the interface{} type can represent any type of object, we can output the value of i and get the correct result.

The above are the basic methods for creating and setting interfaces in Golang. Mastering the use of interfaces can make the code more flexible and scalable, and improve the readability and maintainability of the program.

The above is the detailed content of How to create and set up interfaces in golang (a brief analysis of methods). For more information, please follow other related articles on the PHP Chinese website!