Go learning (IV. interface oriented)

4.1 Interface

go Language supports interfaces , Because the current programming logic is basically based on interfaces .

4.1.1 Interface definition and usage

Let's take a look at the definition of the interface ：

//  Definition of interface 
type Retiever interface {
    
    Get(url string) string     //  The interface is full of functions 
} 

The interface definition is relatively simple , Then let's see how it works ：

Let's start with main.go：

package main

import (
	"fmt"
	"./mock"
	"./real"
)

type Retiever interface {
    
	Get(url string) string
}

func download(r Retiever) string {
    
	return r.Get("http://www.imooc.com")
}

func main() {
    
	var r Retiever    //  This defines an interface variable 
	r = mock.Retiever{
    "this is test"}   //  Then directly assign this object to r
//  because go No inheritance, no polymorphism , So as long as the interface contains the same function, it can be directly assigned , It seems to be really convenient 
	fmt.Println(download(r))   //  Function call 

	r = real.Retiever{
    }
	fmt.Println(download(r))
}

Now let's see mock.go

package mock

type Retiever struct {
    
	Contents string
}

func (r Retiever)Get(url string) string {
        //  Is a simple implementation get Method 
	return r.Contents
}

4.1.2 Summary of the interface

go The interface of is not c++ Inheritance , either java The implementation of the , Is an implicit implementation , As long as the functions in the interface are implemented , You can assign a value to the type of this interface , Although it is written quickly , But will it be chaotic ？ We need to see this in the future .

4.1.3 The value type of the interface

Learn from this teacher , Also learn about the values of interface types , This is where we are c++ I never thought about it in my study , This will be done later c++ When , You can analyze .

func main() {
    
	var r Retiever
	r = mock.Retiever{
    "this is test"}
	//fmt.Println(download(r))

	fmt.Printf("%T %v\n", r, r)


	r = real.Retiever{
    }
	//fmt.Println(download(r))

	fmt.Printf("%T %v\n", r, r)
}

Next, let's look at a wave of printing ：

mock.Retiever {
    this is test}   //  There are really types , But they are all value types 
real.Retiever {
     0s}

Change it to see if you can change it to a pointer type ：

func (r *Retiever)Get(url string) string {
    
	return r.Contents
}

Change the receiver here , Then it can be changed to pointer type .

r = &mock.Retiever{
    "this is test"}
//fmt.Println(download(r))

fmt.Printf("%T %v\n", r, r)

in addition go The language gets the type of this variable as follows ：r.(type)

We can also go through r To get the corresponding value ：

real := r.(real.Retiever)
fmt.Println(real.TimeOut)

4.1.4 go Any type of language

go Languages have an arbitrary type ,interface{}.

Can be regarded as go The generics of languages .

type Queue []interface{
    }		//  Define a slice of any type 

func (q *Queue) push(Value interface{
    }) {
    
	*q = append(*q, Value)
}

var q Queue
q.push(1)
q.push("adv")

fmt.Println(q)   //  Called function 

4.1.5 Interface combination

type Retiever interface {
    
	Get(url string) string
}

type Post interface {
    
	Post(url string, from map[string]string)
}

type all interface {
    
	Retiever
	Post
}

This is the combination of interfaces , It's quite simple , And then implement the class , You need to implement both interface functions , Talent .

4.1.6 Common system interfaces

Stringer() adopt fmt.Println Print

Reader()

Writer()

Common system interfaces , It needs to be programmed later , Familiar again .