golang interface implementation

Golang interface is a key concept in the Golang programming language. With the help of interface, polymorphic features can be achieved while maintaining code flexibility and reusability.

Through this article, we will learn the basic concepts and implementation methods of Golang interface.

1. What is Golang interface?

In Golang, interface is a convention that defines the set of methods that an object should have. An object can be said to "implement the interface" as long as it implements all methods defined in the interface.

The interface in Golang is very different from the interface in other programming languages ​​(such as Java). In Golang, an object can implement multiple interfaces at the same time, but in Java, it can only implement one.

2. The basic syntax of interface

The syntax for defining interface in Golang is as follows:

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

The way to define an interface is similar to that of defining a structure, but only in interface Contains method definitions, not implementations. The method of implementing interface is also very simple. Just create an object that implements the interface and implement the methods defined in the interface.

3. Interface implementation example

In order to better understand the specific implementation process of interface, we will use a simple example to demonstrate.

Suppose we have an interface named "Printer", which has only one method "Print", which is used to print a string. Then we can define this interface as follows:

type Printer interface {
    Print(s string)
}

Now, we need to create an object that implements this interface. Normally, we can use a structure to implement this interface, as shown below:

type ConsolePrinter struct {
}

func (cp *ConsolePrinter) Print(s string) {
    fmt.Println(s)
}

In the above code, we define a structure named "ConsolePrinter" and implement "Printer" "Print method defined in the interface. The implementation of the Print method is very simple, it simply prints its parameters on the console.

Now we have successfully created a structure that implements the "Printer" interface. Next, we need to use it in our program. As shown below:

func main() {
    var printer Printer = &ConsolePrinter{}
    printer.Print("Hello World")
}

In the above code, we first define an interface variable named "printer" and set its type to "Printer". Next, we assign an instance of the "ConsolePrinter" structure to the "printer" variable. Finally, we call the "Print" method of the "printer" object to print a string.

Now run the program, the output should be as follows:

Hello World

4. Summary

With the help of interface features, Golang can easily achieve polymorphism, And keep your code flexible and reusable.

In this article, we introduce how to define and implement Golang interface. We use a simple example to demonstrate the specific implementation process of interface and show how to use objects that implement interface in the program.

If you are learning the Golang programming language, interface is a very important concept. Learning and mastering the knowledge of interface will help you write more flexible and maintainable code.

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