How to implement golang interface

In golang, you can use the "type interface type name interface{method name 1 (parameter list 1) return value list 1 method name 2 (parameter list 2) return value list 2...}" statement to declare the interface ; When the first letter of the "method name" is capitalized, and when the first letter of the "interface type name" is also capitalized, this method can be accessed by code outside the package where the interface is located.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

The Go language is not a "traditional" object-oriented programming language: it does not have the concepts of classes and inheritance.

But the Go language has a very flexible interface concept, through which many object-oriented features can be achieved. Many object-oriented languages ​​have similar interface concepts, but the unique thing about the interface type in Go language is that it satisfies implicit implementation. That is, it is not necessary to define all satisfying interface types for a given concrete type; simply having the required methods is enough.

This design allows you to create a new interface type that satisfies existing concrete types without changing the definitions of these types; this is the case when the types we use come from packages that are not under our control. Design is especially helpful.

Interface types are abstractions and generalizations of the behavior of other types; because interface types are not bound to specific implementation details, through this abstract method we can make our functions more flexible and functional adaptability.

The interface is a cooperation agreement agreed by both parties. The interface implementer does not need to care about how the interface will be used, and the caller does not need to care about the implementation details of the interface. An interface is a type and an abstract structure that does not expose the format, type and structure of the data contained.

Format of interface declaration

Each interface type consists of several methods. The formal code of the interface is as follows:

type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    …
}

Explanation of each part:

• Interface type name: Use type to define the interface as a custom type name. When naming Go language interfaces, er is usually added after the word. For example, the interface with writing operations is called Writer, the interface with string function is called Stringer, the interface with closing function is called Closer, etc.

• Method name: When the first letter of the method name is capitalized, and the first letter of the interface type name is also capitalized, this method can be used by code outside the package where the interface is located. access.

• Parameter list, return value list: Parameter variable names in the parameter list and return value list can be ignored, for example:

type writer interface{
    Write([]byte) error
}

Common interfaces and writing methods in development

Many packages provided by the Go language have interfaces, such as the Writer interface provided in the io package:

type Writer interface {
    Write(p []byte) (n int, err error)
}

This interface can call the Write() method to write a byte array ([]byte), and the return value tells the number of bytes written (n int) and possible errors (err error).

Similarly, there is an interface that displays an object in the form of a string. As long as the type of this interface is implemented, when the String() method is called, the string corresponding to the object can be obtained. It is defined in the fmt package as follows:

type Stringer interface {
    String() string
}

Stringer interface is used very frequently in Go language, and its function is similar to the ToString operation in Java or C# language.

The number of methods in each interface of the Go language is not very large. Go language hopes to accurately describe its own functions through an interface, and expand simple interfaces into complex interfaces through the embedding and combination of multiple interfaces. Later sections in this chapter describe how to extend interfaces using composition.

【Related recommendations: Go video tutorial, Programming teaching】

The above is the detailed content of How to implement golang interface. For more information, please follow other related articles on the PHP Chinese website!