一、#方法# 两种语言使用的对比
1.1 python:
因为python是支持面向对象编程的，所以我们可以先定义类，在类中绑定属性(数据)，再通过数据封装(定义访问数据的函数)，也即类的方法。最终实例化后实现了方法的使用。
- 定义Person类
- 绑定firstname和lastname属性
- 定义类中的函数printme，打印firstname和lastname
- 实例化后，调用printme方法
#默认继承object类
class Person(object):
#通过__init__方法强制绑定必要的属性，self表示创建实例的本身
def __init__(self,firstname,lastname):
self.firstname=firstname
self.lastname=lastname
def printme(self):
print("person name: "+self.firstname+" "+self.lastname)
#初始化实例并调用方法
p=Person('michael','hu')
p.printme()
【 python代码1 】
1.2 golang:
由于golang没有类概念，不能使用面向对象的方法。所以先要定义结构体(可理解为python中通过init绑定的一组数据属性的集合)，再定义方法(比函数多了接收者)
- 定义结构体Person，包含firstname,lastname属性
- 定义Print方法，传入接受者为Person类型指针
- 使用结构体初始化变量，变量使用Print方法
package main
import "fmt"
//自定义Person结构体
type Person struct{
firstname string
lastname string
}
//(p *Person)是Print方法的接收者，p名称可以自定义理解为python中self，p通常定义为指针节省内存
func (p *Person) Printme() {
fmt.Println("person name is :",p.firstname,p.lastname)
}
func main(){
//使用结构体Person初始化p，此处传递的是地址
p:=&Person{firstname:"michael",lastname:"hu",}
//调用方法Print，指针p会自动解引用
p.Printme()
}
【 golang代码1 】
小结：
python先把类实例化，再调用实例化后的方法
golang是先实例化结构体，再使用相同实例的方法
二、python的多态和golang的多态
2.1 python:
子类可以继承主类，子类可复用主类方法或增加方法或改写方法。分别调用主类或者子类可实现对应的方法但没必要重复调用，而使用多态就是使用统一的接口来调用这些类的方法，这里的接口就是定义一个函数，
多态的使用方法：
- 先定义一个函数，函数的参数为类
- 实例化，并传入类，使用方法。当传入的参数为主类或者其下的子类，函数会根据对应的类类型(类类型可理解为class封装的数据类型)调用对应主或子类的方法。
继续在【python代码1】增加以下内容：
#定义子类Animal，继承于Person类，改写了print方法，这里把绑定属性也一起改了
class Animal(Person):
def __init__(self,animals,sex):
self.animals=animals
self.sex=sex
def printme(self):
print(f'animal type is: {self.animals}, sex is:{self.sex}')
#定义函数showme作为多态的接口,根据传入的类调用不同的类方法
def showme(livers):
livers.printme()
#传入Person类，调用Person类里的方法
showme(Person('michael','hu'))
#返回person name: michael hu
#传入Animal子类，调用Animal类里的方法
showme(Animal('cat','male'))
#返回animal type is: cat, sex is:male
【python代码2】
- 鸭子类型: 定义的类如果不是继承于主类，只要类里函数使用了相同的名称。就可以使用多态性。
继续在【python代码2】增加以下内容：
#非继承于Person类
class Car(object):
#定义相同名称print函数
def printme("this is my car")
#实例化使用相同的方法
c=showname(Car())
c.printme()
2.2 golang
golang的多态特性是用接口interface来实现，类似于python定义了函数，在函数里调用类
- 定义接口，接口调用方法
- 初始化结构体，初始化接口
- 结构体变量赋值给接口
- 接口调用方法，根据不同的结构体接口调用对应的方法
继续在【golang代码1】增加以下内容：
//定义接口Namer，调用方法Printme
type Namer interface{
Printme()
}
//定义结构体Animal
type Animal struct{
animals string
sex string
}
//定义方法Printme，传入的接受者类型是Animal指针类型
func(a *Animal) Printme(){
fmt.Printf("Anilmal is: %s, sex is:%s",a.animals,a.sex)
}
//另外一种初始化结构体的简略写法
a:=&Animal{"cat","sex"}
//使用接口Namer初始化变量aa，并赋值a
var aa Namer=a
//使用接口Namer初始化变量pp，并赋值p
var pp Namer=p
//根据传入的接受者调用对应的方法
aa.Printme()
pp.Printme()
另外可以把接口定义为切片类型，初始化后的的结构体赋值给切片，如下：
//初始化切片定义类型为接口
who:=[]Namer{p,a}
for k,_:=range(who){
who[k].Printme()
}
小结：
python 定义函数，函数的形参为类。实例化对应的类后，函数调用对应的类方法
golang 定义接口，接口里定义了方法。初始化对应的结构体后的变量传递给接口，接口再调用对应的方法。
