go Interface advanced

Value receiver and pointer receiver

In the basic part of the interface , We use value receivers to implement interfaces . Again , You can also use pointer receivers to implement interfaces , However, when using the pointer receiver to implement the interface , There are also some details to pay attention to .

func main() {
    
    tduck := TDuck{
    " Donald Duck ", 3}
    pduck := PDuck{
    " Duckling ", 2}
    //  Whether it is the interface implemented by the value receiver or the interface implemented by the pointer receiver , Values can be called 
    tduck.eat()  //  Donald Duck   Eat something 
    pduck.eat()  //  Duckling   Eat something 
    //  Whether it is the interface implemented by the value receiver or the interface implemented by the pointer receiver , Pointers can be used to call 
    tduck1.eat()  //  Donald Duck   Eat something 
    pduck1.eat()  //  Duckling   Eat something  
    
    //  Use the interface type to call 
   	//  The interface implemented by the value receiver , Values and pointers can call 
    var duck Duck = tduck
    var duck1 Duck = &tduck
    duck.eat()   //  Donald Duck   Eat something 
    duck1.eat()  //  Donald Duck   Eat something 
	//  If it is the interface implemented by the pointer receiver , You cannot directly give the value to the interface , You need to assign the pointer to the interface type 
    // var duck2 Duck = pduck  Report errors 
    var duck3 Duck = &pduck
    duck3.eat()  //  Duckling   Eat something 
} 

type Duck interface {
    
   eat()
}

type TDuck struct {
    
   name string
   age  int
}

type PDuck struct {
    
   name string
   age  int
}
//  Value recipient 
func (t TDuck) eat() {
    
   fmt.Println(t.name, " Eat something ")
}
//  Pointer receiver 
func (t *PDuck) eat() {
    
   fmt.Println(t.name, " Eat something ")
}

Implement multiple interfaces

Types can implement multiple interfaces .

func main() {
    
	tduck := TDuck{
    " Donald Duck 1 Number ",5}
	var animal Animal = tduck
	var duck Duck = tduck
	tduck.run()  //  Donald Duck 1 Number   Rattle and run 
	tduck.eat()  //  Donald Duck 1 Number   Eat something 
    //  be not in Animal1 Methods in interfaces , You can't get it , Through type assertion , Type selection 
	animal.run() //  Donald Duck 1 Number   Rattle and run 
    
	duck.eat()   //  Donald Duck 1 Number   Eat something 
}

type Animal interface {
    
	run()
}

type Duck interface {
    
	eat()
}

type TDuck struct {
    
	name string
	age  int
}
func (t TDuck) eat() {
    
	fmt.Println(t.name, " Eat something ")
}
func (t TDuck) run()  {
    
	fmt.Println(t.name, " Rattle and run ")
}

type TDuck At the same time Animal and Duck Interface , therefore TDuck An object of type can have all the implemented methods and properties , The interface object can only execute its corresponding method .

Also because of this feature , Different functions , The types that can be received are different , But they can all pass the same specific type , That must be because of this specific type , Implemented multiple interfaces

Nesting of interfaces

Even though Go The language does not provide an inheritance mechanism , However, other interfaces can be nested , Create a new interface .

func main() {
    
	nb := Nb{
    "lxx",2}
	var man Man = nb
	var woman Woman = nb
	var people People = nb
	man.makeMoney()  //  Earning skills 
	woman.spendMoney()  //  Spending skills 
	fmt.Println(people)  // {lxx 2}
}


type Man interface {
    
	makeMoney()
}

type Woman interface {
    
	spendMoney()
}

type People interface {
    
	Man
	Woman
}

type Nb struct {
    
	name string
	age int
}

func (n Nb) makeMoney()  {
    
	fmt.Println(" Earning skills ")
}

func (n Nb) spendMoney()  {
    
	fmt.Println(" Spending skills ")
}

As shown in the above code ,Nb People can both makeMoney It will be spendMoney,makeMoney yes Man Interface method ,spendMoney yes Woman Interface method ,Nb Type implements two interfaces at the same time , It will come true People Interface .