How to implement interface methods in Golang

The Go language provides an interface mechanism, which is an important means of code reuse and object-oriented programming. In Go, an interface type is a collection of signatures for a set of methods. Values ​​of interface types can store any value that implements these methods.

In Go language, an interface is a container used to store and transfer a collection of methods. Interfaces can decouple code to a high degree, improving code flexibility and scalability. The design of interfaces is a very important part of the Go language. An in-depth understanding of interface implementation methods is crucial to writing high-quality Go code.

Next we will introduce the interface method implementation in Golang.

1. Definition of interface in Golang

Go language stipulates in the interface definition that the interface is composed of a collection of methods. We can define an interface by defining a set of methods on the interface type:

type interfaceName interface {
method_1 (param1 type1, param2 type2) return_type
method_2 (param1 type1, param2 type2) return_type
…
method_n (param1 type1, param2 type2) return_type
}

The method set in the interface definition can be composed of one or more methods. Each method defines an operation and specifies the parameters and return type of the operation. The collection of methods of an interface is usually described with simple comments. If an interface contains only one method, then the interface is called a function type.

2. Interface implementation in Golang

In the Go language, to implement an interface you only need to implement all the methods in the interface. That is to say, when a type defines all the methods contained in the interface, the type automatically implements the interface. Since there is no explicit implementation syntax in the Go language, the set of interfaces implemented by a type is automatically determined by the type.

type InterfaceObject interface {
Func1() int
Func2() float64
}

type Impl1 struct {
Property1 int
}

func (impl Impl1) Func1() int {
return impl.Property1
}

func (impl Impl1) Func2() float64{
​​return float64(impl.Property1) / 0.618
}

func main() {
impl1 := Impl1{Property1:100}
var intf InterfaceObject = impl1
fmt.Printf("%d\n" , intf.Func1())
fmt.Printf("%.2f\n", intf.Func2())
}

For the interface implementation in go language, a specific The type of an interface is the data type that implements the interface, and object values ​​of this type can be assigned to the interface object.

3. Interface polymorphism in Golang

In Golang, each variable of a type that implements an interface is called an interface object. The variable type is the name of the interface, and the variable value is an instance of the interface. An instance or pointer of a type can be assigned to an interface variable. When you need to access a method in an interface object, the program will use the interface name as the method name in the interface instead of using the specific type.

type InterfaceObject interface {

Func1() int

}

type Impl1 struct {

Property1 int

}

func (impl Impl1) Func1() int {

return impl.Property1

}

func main() {

impl1 := Impl1{Property1:100}
var intf InterfaceObject = impl1
fmt.Printf("%d\n", intf.Func1())

}

For Golang’s interface polymorphism, we can see that when creating an interface object, the impl1 type is automatically converted to a value of the InterfaceObject type, and the Func1() method of InterfaceObject can be called.

4. Interface nesting in Golang

In the Go language, interface nesting is a mechanism for combining interface types. Nested interfaces combine the methods of multiple interfaces so that a certain type can satisfy the method requirements of these interfaces at the same time.

type Drawer interface {

Draw() string

}

type Closer interface {

Close() bool

}

type FileHandler interface {

Drawer
Closer

}

func main() {

fh := FileHandler{}
fmt.Print(fh.Draw())  //输出为空字符串
fmt.Print(fh.Close()) //输出false

}

In the above code, three interfaces Drawer, Closer and Filehandler are defined. Drawer and Closer are Two simple interfaces, and the Drawer and Closer interfaces are nested in FileHandler. By composing interfaces, we can define more complex interface types and make the implementation more flexible and extensible.

Summary

In Go language, interface is a very powerful and important programming tool. Through interface implementation, code reuse, flexibility and scalability can be better achieved, which is very common in actual development. Technically speaking, polymorphism, composition, design patterns, etc. can be achieved through the use of interfaces. Therefore, in-depth study of the use of Go language interfaces and method implementation is crucial to writing high-quality Go code

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