Go语言面向函数和接口编程
Posted ywzou
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言面向函数和接口编程相关的知识，希望对你有一定的参考价值。
Go语言仅支持封装,不支持继承和多态;没有类 class,用结构体 struct,主要是函数式编程和面向接口编程
一、方法
Go中方法就是一类带特殊的 接收者 参数的函数。方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。 可将方法理解为是个带接收者参数的函数。
func (接收者) 方法名称(参数) 放回值 {方法体}
值接收者和指针接收者要改变接收者是的时候必须使用指针接收者 结构过大也考虑使用指针接收者(性能、内存) 一致性：如果有指针接收者，最好都使用指正接收者 值接收者是Go特有特性。用于逻辑运算场景，不改变接收者的值 通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用
值接收者
func (node treeNode) print() {
fmt.Println(node.value)
}
指针接收者
func (node *treeNode) setValue(value int) {
node.value = value
}
通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用
示例
//定义一个简单的二叉树结构体
type treeNode struct {
value int
leftNode,rightNode *treeNode
}
//结构体的方法 接收者为值
func (node treeNode) print() {
fmt.Println(node.value)
}
//设置是 接收者为指针
func (node *treeNode) setValue(value int) {
node.value = value
}
//遍历二叉树
func (node *treeNode) traverse() {
if nil == node {
return
}
node.print()
node.leftNode.traverse()
node.rightNode.traverse()
}
//结构体创建 工厂函数
func createNode(value int) *treeNode {
return &treeNode{value:value}
}
//结构体创建演示
func StructDemo() {
//创建结构体 方式一
//var root treeNode
//创建结构体 方式二
root := treeNode{value:-1}
//创建结构体 方式三
//root := new(treeNode)
//赋值
root.leftNode = &treeNode{value:1}
root.rightNode = &treeNode{value:2}
root.leftNode.leftNode = createNode(11)
root.leftNode.rightNode = createNode(12)
root.rightNode.leftNode = createNode(21)
root.rightNode.rightNode = createNode(22)
fmt.Println(root)
//调用结构体方法
root.setValue(0)
root.print()
fmt.Println("===== 二叉树遍历 ====")
root.traverse()
}
二、接口
接口类型interface 是由一组方法签名定义的集合。接口类型的变量可以保存任何实现了这些方法的值。 类型通过实现一个接口的所有方法来实现该接口。不需要专门显式声明，所以就没有“implements”关键字;隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。 接口也是值,它们可以像其它值一样传递;接口值可以用作函数的参数或返回值。在内部，接口值可以看做包含值和具体类型的元组 (value,type);接口值保存了一个具体底层类型的具体值。接口值调用方法时会执行其底层类型的同名方法。
//接口interface
type iPerson interface {
say() string
}
//结构体
type Person struct {
name string
}
//实现接口方法
func (p Person) say() string {
return p.name + " say hello!"
}
func describe(i iPerson) {
fmt.Printf("(%v, %T)\n", i, i)
}
func InterDemo() {
var i iPerson
ps := Person{name:"张三"}
i = ps
fmt.Println(i.say())
describe(i)//({张三}, mi.Person)
//隐式实现
var i2 iPerson = Person{name:"李四"}
fmt.Println(i2.say())
describe(i2)//({李四}, mi.Person)
}
空接口指定了零个方法的接口值被称为 空接口,因为每个类型都至少实现了零个方法,所以空接口可保存任何类型的值；常被用来处理未知类型的值( 例如:fmt.Print)
var i interface{}
类型断言提供了访问接口值底层具体值的方式。
t := i.(T)
该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。若 i 并未保存 T 类型的值,则会panic
t, ok := i.(T)
若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true；否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生panic
类型选择是一种按顺序从几个类型断言中选择分支的结构，类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类（而非值），它们针对给定接口值所存储的值的类型进行比较；类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。
switch v := i.(type) { case T: // v 的类型为 T case S: // v 的类型为 S default: // 没有匹配，v 与 i 的类型相同 }
//类型选择
func do(i interface{}) {
switch v := i.(type) {
case int:
fmt.Printf("int类型 值等于%v \n", v)
case string:
fmt.Printf("string类型 值等于%v \n", v)
case iPerson:
fmt.Printf("iPerson类型 值等于%v \n", v)
default:
fmt.Printf("未知的类型%T!\n", v)
}
}
func InterDemo2() {
var i interface{} = "hello"
// 类型断言
s := i.(string)
fmt.Println(s) //hello
s, ok := i.(string)
fmt.Println(s, ok)//hello true
f, ok := i.(int)
fmt.Println(f, ok)//0 false
//f = i.(float64) // 报错(panic)
do(21)
do("hello")
do(true)
do(Person{name:"李四"})
}
以上是关于Go语言面向函数和接口编程的主要内容，如果未能解决你的问题，请参考以下文章