Go —面向对象基础（接口）

GO语言接口、面向对象个人学习总结

接口

接口和方法的关系

实际项目开发过程中，应当是先创建接口，再根据接口实现对应的方法

type Humaner interface {
	SayHi()
}

方法：

• 方法声明：没有值，没有具体的实现过程
• 方法定义：有值，并且有具体的实现过程

定义

接口规定一种规则，若想要使用这个接口就必须满足这种规则，如上述定义中该接口类型为SayHi()方法类型，只使用于实现SayHi()的功能，使用的过程中也需要注意

接口名命名规则

接口名儿末尾一般以er结尾

接口的使用

type Humaner interface {
	SayHi()
}

type person struct {
	name string
	sex string
	age int
}

type student struct {
	person
	score int
}

func (stu *student)SayHi(){
	fmt.Printf("大家好我叫%s是个%s生,今年%d岁,这次考了%d分",stu.name,stu.sex,stu.age,stu.score)
}

func main(){
	var stu student=student{person{"LiLei","男",18},98}
	var i Humaner		//接口类型的变量（数据类型）
	i=&stu				//将结构体的地址传递给接口类型的变量
	i.SayHi()			//对象中方法调用
}

接口到方法的实现流程

声明方法过程中需注意：

1. 声明的方法与对象中的方法必须一致
2. 两者通过结构体的地址找到对应绑定的方法
3. 接口中声明的方法必须实现

多态

定义一个普通函数，用接口作为函数参数

type Cser interface {
	Socket()		//声明方法1
	Encryption()	//声明方法2
}

type framework struct {
	name string
	data string
}

type CK1 struct {
	framework
	SCD string
}

func (ck1 *CK1)Socket(){			//方法1实现
	fmt.Printf("%s正在请求连接,发送%s\n",ck1.name,ck1.data)
}

func (ck1 *CK1)Encryption(){		//方法2实现
	fmt.Printf("对%s进行加密中....",ck1.SCD)
}


func Connect(i Cser){
	i.Socket()
	i.Encryption()
}

func main(){
	var c1 CK1=CK1{framework{"断背山信息科技","联网数据"},"加密照片"}
	/*
	var i Cser
	i=&c1
	Connect(i)
	*/
	Connect(&c1)	//一步到位！
}

多态的实现方便了多个功能和方法的使用，同时简化增删方法的过程以应对需求功能的变化

例如：多态实现计算机的简单应用

type Operater01 interface {
	Add() int
	//Sub() int
}
type oper struct {
	num01 int
	num02 int
}
type add struct {
	oper
}
type sub struct {
	oper
}
func (a add)Add()int{
	return a.num01+a.num02
}
func (s sub)Sub()int{
	return s.num01-s.num02
}
func Getrut(i Operater01)int{
	return i.Add()
	//return i.Sub()
}
func main(){
	var a add=add{oper{10,5}}
	v:=Getrut(&a)
	fmt.Println(v)
}
//可以直接在多态中实现减法功能的增加和移除

接口的继承与转换

直接通过代码展示：

//接口的继承与转换

type Humaner03 interface {		//子集
	SayHello()
}

type Person03 interface {		//超集
	Humaner03
	Sing(name string)
}

type person03 struct {			//父类
	name string
	age int
	sex string
}

type student03 struct {			//子类1
	person03
	score int
}

type teacher03 struct {			//子类2
	person03
	subject string
}


func (stu *student03)SayHello(){
	fmt.Printf("Hello everyone,my name is %s and %d years old,i am a %s,I get %d point this test!\n",stu.name,stu.age,stu.sex,stu.score)
}

func (tea *teacher03)SayHello(){
	fmt.Printf("Hello everyone,my name is %s and %d years old,i am a %s,I teache %s!\n",tea.name,tea.age,tea.sex,tea.subject)
}

func (tea *teacher03)Sing(name string){
	fmt.Printf("I will sing the song %s",name)
}

func main(){
	var i Humaner03
	var p Person03
	var stu =student03{person03{"Lilei",18,"boy"},99}
	var tea =teacher03{person03{"HanMeiMei",26,"girl"},"English"}

	i=&stu
	i.SayHello()

	//p=&stu	Error：student中没有对Sing()方法进行实现

	p=&tea
	p.SayHello()
	p.Sing("可惜不是你")

	
}

接口的转换

	i=p		p中可以满足i中方法的实现
	p=i		Error：i不可以满足p

空接口

定义接口类型，可以储存各个类型的数据

func main(){
    var i interface		//可以给i赋值任何类型的数据
}

接口类型默认为nil（void*万能指针类型），被赋值后为interface{}类型会根据存储的数据变化，类型随之变化

类型断言

用于断言接口的数据类型

func main(){
    var slice []interface{}
    slice=append(slice,0,3.14,"HelloWorld",[]int{1,2,3},map[int]string{101:"罗罗诺阿.索隆"})
    for _,v:=range slice{
        data,ok:=v.(string)		//打印string类型的数据
        if ok{
            fmt.Println(data)
        }
    }
}

类

描述一个对象，通常会用到属性和方法（函数），故而将两者抽象出类的概念

严格意义上来说，GO语言中没有类的概念，但是我们可以将结构体化作类，因为在结构体中可以添加属性（成员），方法（函数）

工厂模式

直接将数据和需求交给工厂，由工厂自己判断需要找到那个对象进行方法的调用

代码如下：实现计算器功能

//工厂模式实现计算的功能

type Operation struct {
	num1 float64
	num2 float64
}
type GetResulter interface {
	GetResult() float64
}
type OperationAdd struct {
	Operation
}
func (a *OperationAdd)GetResult()float64{	//	方法 加法
	return a.num1+a.num2
}
type OperationSub struct {
	Operation
}
func (a *OperationSub)GetResult()float64{	//	方法 减法
	return a.num1-a.num2
}
type OperationMul struct {
	Operation
}
func (a *OperationMul)GetResult()float64{	//	方法 乘法
	return a.num1*a.num2
}
type OperationDiv struct {
	Operation
}
func (a *OperationDiv)GetResult()float64{	//	方法 除法
	return a.num1/a.num2
}
type OperationFactory struct {				//	创建工厂对象目的为了绑定一个方法
}
func (o *OperationFactory)CreatOption(option string,num1 float64,num2 float64)float64{
			var result float64
	switch option {							//通过需求找到“*”对象，实现乘法
	case "+":{
		add:=&OperationAdd{Operation{num1,num2}}
		result=OperationWho(add)
	}
	case "-":{
		sub:=&OperationSub{Operation{num1,num2}}
		result=OperationWho(sub)
	}
	case "*":{
		mul:=&OperationMul{Operation{num1,num2}}
		result=OperationWho(mul)
	}
	case "/":{
		div:=&OperationDiv{Operation{num1,num2}}
		result=OperationWho(div)
	}
	}
	return result
}
func OperationWho(i GetResulter )float64{	//多态函数
	return i.GetResult()
}
func main() {
	var opfactory OperationFactory
	s:=opfactory.CreatOption("*",2,5)
	fmt.Println(s)
}

总结

1. 创建接口——声明方法
   创建对象
   对象1（结构体）——>绑定方法（函数）
   对象2（结构体）——>绑定方法（函数）

2. 创建多态函数，接口作为参数，调用接口中的方法

   注：具体调用哪个方法，通过传递的对象地址进行判断

3. 创建工厂

4. main函数，初始化一个工厂，提出要求（传递参数）

（技术点或知识点有误，欢迎指出）