python vs golang #方法及多态# 的使用对比

一、#方法# 两种语言使用的对比

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】增加以下内容：

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： 定义接口，接口里定义了方法。初始化对应的结构体后的变量传递给接口，接口再调用对应的方法。