Shulou(Shulou.com)05/31 Report--

This article focuses on "how to understand Go language Polymorphism and interface", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to understand Go Polymorphism and interface.

I. the meaning of polymorphism

For Java or C++, when we use variables, the type of variables is clear. But if we want it to be loose, for example, we use parent class pointers or references to call methods, but when executing, we can execute methods in subclasses according to the type of subclass. That is to say, the situation in which we call different results or functions in the same way is called polymorphism.

To take a very classic example, for example, cats, dogs and people are all mammals. All three classes have a say method, and we all know that cats, dogs and humans have different say. Cats may meow, dogs bark, and humans talk.

Class Mammal {public void say () {System.out.println ("do nothing")}} class Cat extends Mammal {public void say () {System.out.println ("meow");} class Dog extends Mammal {public void say () {System.out.println ("woof");}} class Human extends Mammal {public void say () {System.out.println ("speak");}}

This code should not be difficult for everyone to understand. These three classes are all subclasses of Mammal. Suppose we have a series of instances at this time, they are all instances of subclasses of Mammal, but there are all three types, and we want to call them all together with a loop. Although we receive variables using the parent class type of Mammal, we get the running results of each subclass when we call it.

Like this:

Class Main {public static void main (String [] args) {List mammals = new ArrayList (); mammals.add (new Human ()); mammals.add (new Dog ()); mammals.add (new Cat ()); for (Mammal mammal: mammals) {mammal.say ();}

I don't know if you have the essence of get, but we have created a List of the parent class and put instances of its subclasses into it. Then a loop is passed to receive it with the parent object and the say method is called. We hope that although we use a reference to the parent class to call the method, it can automatically call the method in the corresponding subclass according to the type of the subclass.

In other words, the result we should get is:

Speak

Woof

Meow

This feature is polymorphism, and to put it bluntly, we can define methods in the parent class and create different implementations in the subclass. However, the reference of the parent class is still used when the call is made, and the compiler will automatically do the internal mapping and conversion for us.

Abstract classes and interfaces

Of course, this implementation is feasible, but there is actually a small problem, which is that the say method in the Mammal class is redundant. Because we will only use its subclass, we will not use Mammal as a parent class. So there is no need to implement the say method in the parent class Mammal. Make a tag to indicate that there is a method that needs to be implemented when the subclass is implemented.

This is the source of abstract classes and abstract methods. We can make Mammal an abstract class and declare that say is an abstract method. Abstract classes cannot create instances directly, only instances of subclasses can be created, and abstract methods do not need to be implemented, just need to be marked with parameters and returned. The specific implementation is carried out in the subclasses. To put it bluntly, an abstract method is a tag that tells the compiler that all subclasses that inherit this class must implement abstract methods, and methods in the parent class cannot be called. That abstract class is the class that contains abstract methods.

We write the code after Mammal becomes an abstract class:

Abstract class Mammal {abstract void say ();}

Very simple, because we only need to define the parameters of the method, there is no need to implement the function of the method, the function of the method is implemented in the subclass. Because we mark the say method as an abstract method, all subclasses that inherit Mammal must implement this method, otherwise an error must be reported.

An abstract class is actually a marginal ball. We can define abstract methods in an abstract class, that is, we can only declare that they are not implemented, and we can also implement concrete methods in an abstract class. An instance of a non-abstract method subclass in an abstract class can be called directly, just as the subclass calls the normal method of the parent class. But what if we don't need a parent class implementation method, and all the methods in the extracted parent class we propose are abstract? In view of this situation, there is another concept in Java called interface, that is, interface. In essence, interface is an abstract class, but an abstract class with only abstract methods.

So the Mammal just now can also be written as:

Interface Mammal {void say ();}

After turning Mammal into interface, the implementation of the subclass is not much different, except that the extends keyword is replaced with implements. In addition, subclasses can inherit only one abstract class, but can implement multiple interfaces. In previous versions of Java, interface can only define methods and constants, but in later versions of Java8, we can also implement some default and static methods in interfaces.

The benefits of the interface are obvious, and we can use an instance of the interface to call all the classes that implement the interface. In other words, the interface and its implementation are a much broader inheritance relationship, which greatly increases flexibility.

Although the above is all the content of Java, but it is actually about object-oriented content, if you have not learned Java may seem a little bit difficult, but generally speaking, there is no problem, there is no need to detail the syntax details, get to the core essence on it.

The purpose of talking about such a long paragraph is to clarify some concepts in object-oriented, as well as the methods and ideas of the use of interfaces, which is the focus of this article, that is, the use and concept of interfaces in Go language.

III. Interfaces in Golang

There are interfaces in Golang, but its concept and usage are slightly different from those of Java. Their usage scenarios and implementation purposes are similar, essentially for abstraction. Some methods are extracted through the interface, and all classes that inherit this interface must have these methods, so we can use them to obtain instances of these classes through the interface, which greatly increases the flexibility.

But the interface in Java has a big problem is intrusiveness, to put it bluntly, it will reverse the relationship between supply and demand. As a simple example, suppose you write a crawler to crawl content from each web page. There are many types of content that crawlers crawl to, including pictures, text and videos. Suppose you want to abstract an interface in which you define some of the methods you specify to extract data. In this way, you can use this interface to call regardless of the format of the obtained data. This is also a scenario for the use of interfaces, but the problem is that the components that deal with images, text, and videos may be open source or third-party, not developed by you. It is useless for you to define an interface, and other people's code will not inherit it.

Of course, this can also be solved, for example, you can encapsulate a layer outside these third-party tool libraries to implement the interfaces you define. Of course it's OK, but it's obviously troublesome.

The interface in Golang solves this problem, that is, it completely removes the weakened inheritance relationship, as long as the methods defined in the interface correspond to each other, then the class can be considered to implement this interface.

Let's first create an interface, of course, through the type keyword:

Type Mammal interface {Say ()}

We define an interface for Mammal, which declares a Say function. In other words, any structure that owns this function can be received by this interface. As just now, we define three structures, Cat, Dog and Human, and implement their respective Say methods:

Type Dog struct {} type Cat struct {} func (d Dog) Say () {fmt.Println ("woof")} func (c Cat) Say () {fmt.Println ("meow")} func (h Human) Say () {fmt.Println ("speak")}

After that, we try to use this interface to receive objects of various structures, and then call their Say methods:

Func main () {var m Mammal m = Dog {} m.Say () m = Cat {} m.Say () m = Human {} m.Say ()}

Of course, the result is exactly what we expected:

At this point, I believe you have a deeper understanding of "how to understand Go Polymorphism and interface". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.