实证与虚无,抽象和具象，Go lang1.18入门精炼教程，由白丁入鸿儒，Go lang接口(interface)的使用EP08

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

package main

import (
	"fmt"
)

type Phone interface {
	call()
}

type Android struct {
}

func (android Android) call() {
	fmt.Println("I am Android")
}

type Ios struct {
}

func (ios Ios) call() {
	fmt.Println("I am Ios")
}

func main() {
	var phone Phone

	phone = new(Android)
	phone.call()

	phone = new(Ios)
	phone.call()

}

I am Android
I am Ios

package main

import "fmt"

type Human struct {
	name  string
	age   int
	phone string
}
type Student struct {
	Human  //匿名字段
	school string
	loan   float32
}
type Employee struct {
	Human   //匿名字段
	company string
	money   float32
} //Human实现Sayhi方法
func (h Human) SayHi() {
	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
} //Human实现Sing方法
func (h Human) Sing(lyrics string) {
	fmt.Println("。。。。。。。。", lyrics)
} //Employee重写Human的SayHi方法
func (e Employee) SayHi() {
	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
		e.company, e.phone) //Yes you can split into 2 lines here.
}

type Men interface {
	SayHi()
	Sing(lyrics string)
}

func main() {
	mike := Student{Human{"Mike", 10, "1"}, "MIT", 0.00}
	paul := Student{Human{"Paul", 20, "2"}, "Harvard", 100}
	sam := Employee{Human{"Sam", 30, "3"}, "Golang Inc.", 1000}
	Tom := Employee{Human{"Tom", 40, "4"}, "Things Ltd.", 5000}
	//定义Men类型的变量i
	var i Men
	//i能存储Student
	i = mike
	fmt.Println("This is Mike, a Student:")
	i.SayHi()
	i.Sing("song")
	//i也能存储Employee
	i = Tom
	fmt.Println("This is Tom, an Employee:")
	i.SayHi()
	i.Sing("song")
	//定义了slice Men
	fmt.Println("Let's use a slice of Men and see what happens")
	x := make([]Men, 3)
	//T这三个都是不同类型的元素，但是他们实现了同一个接口
	x[0], x[1], x[2] = paul, sam, mike
	for _, value := range x {
		value.SayHi()
	}
}

This is Mike, a Student:
Hi, I am Mike you can call me on 1
。。。。。。。。 song
This is Tom, an Employee:
Hi, I am Tom, I work at Things Ltd.. Call me on 4
。。。。。。。。 song
Let's use a slice of Men and see what happens
Hi, I am Paul you can call me on 2
Hi, I am Sam, I work at Golang Inc.. Call me on 3
Hi, I am Mike you can call me on 1

package main

import "fmt"

type Human interface {
	Len()
}
type Student interface {
	Human
}

type Test struct {
}

func (h *Test) Len() {
	fmt.Println("10个")
}
func main() {
	var s Student
	s = new(Test)
	s.Len()
}

10个

class PsyDuck():
    def gaga(self):
        print("这是可达鸭")


# 使用的对象和方法
class DoningdDuck():
    def gaga(self):
        print("这是唐老鸭")


# 被调用的函数
def duckSay(func):
    return func.gaga()


# 限制调用方式
if __name__ != '__main__':
    print("must __main__")

if __name__ == "__main__":

    # 实例化对象
    duck = PsyDuck()
    person = DoningdDuck()
    # 调用函数
    duckSay(duck)
    duckSay(person)

这是可达鸭
这是唐老鸭

package main

import "fmt"

//定义一个鸭子接口
//Go 接口是一组方法的集合，可以理解为抽象的类型。它提供了一种非侵入式的接口。任何类型，只要实现了该接口中方法集，那么就属于这个类型。
type Duck interface {
	Gaga()
}

//假设现在有一个可达鸭类型
type PsyDuck struct{}

//可达鸭声明方法-满足鸭子会嘎嘎叫的特性
func (pd PsyDuck) Gaga() {
	fmt.Println("this is PsyDuck")
}

//假设现在有一个唐老鸭类型
type DonaldDuck struct{}

//唐老鸭声明方法-满足鸭子会嘎嘎叫的特性
func (dd DonaldDuck) Gaga() {
	fmt.Println("this is DoningdDuck")
}

//要调用的函数 - 负责执行鸭子能做的事情,注意这里的参数,有类型限制为Duck接口
func DuckSay(d Duck) {
	d.Gaga()
}

func main() {
	//提示开始打印
	fmt.Println("duck typing")

	//实例化对象
	var pd PsyDuck    //可达鸭类型
	var dd DonaldDuck //唐老鸭类型

	//调用方法
	DuckSay(pd) //因为可达鸭实现了所有鸭子的函数,所以可以这么用
	DuckSay(dd) //因为唐老鸭实现了所有鸭子的函数,所以可以这么用
}

duck typing
this is PsyDuck
this is DoningdDuck