参考书籍:
《go语言程序设计》
好书链接
每个函数声明都包含一个名字,一个形参列表,一个可选的返回列表以及函数体:
func name(parameter-list)(result-list){
body
}
形参列表:指定另一组变量的参数名和参数类型,这些局部变量都由调用者提供的提供的实参传递而来的。
返回列表:指定了函数返回值的类型。当函数返回一个未命名的返回值或者没有返回值的时候,返回列表的圆括号可以忽略。
func FanOne(x float64) float64 {
return math.Sqrt(x*x)
}
fmt.Println(FanOne(3)) // 3
这里的x
就是形参
,3
就是传入函数的实参
// 定义一个求两数之和的函数
func add(a,b int) int {
return a + b
}
func main() {
sum := add(1,2)
fmt.Println(sum)
}
在 Go 语言中,结构体就像是类的一种简化形式,那么面向对象程序员可能会问:类的方法在哪里呢?在 Go 中有一个概念,它和方法有着同样的名字,并且大体上意思相同:Go 方法是作用在接收者(receiver)上的一个函数,接收者是某种类型的变量。因此方法是一种特殊类型的函数。
接收者类型可以是(几乎)任何类型,不仅仅是结构体类型:任何类型都可以有方法,甚至可以是函数类型,可以是 int、bool、string 或数组的别名类型。但是接收者不能是一个接口类型,因为接口是一个抽象定义,但是方法却是具体实现;如果这样做会引发一个编译错误:invalid receiver type…
。
最后接收者不能是一个指针类型,但是它可以是任何其他允许类型的指针。
一个类型加上它的方法等价于面向对象中的一个类。一个重要的区别是:
在 Go 中,类型的代码和绑定在它上面的方法的代码可以不放置在一起,它们可以存在在不同的源文件,唯一的要求是:它们必须是同一个包的。
类型 T(或 *T)上的所有方法的集合叫做类型 T(或 *T)的方法集(method set)。
因为方法是函数,所以同样的,不允许方法重载,即对于一个类型只能有一个给定名称的方法。但是如果基于接收者类型,是有重载的:具有同样名字的方法可以在 2 个或多个不同的接收者类型上存在,比如在同一个包里这么做是允许的:
func (a *denseMatrix) Add(b Matrix) Matrix
func (a *sparseMatrix) Add(b Matrix) Matrix
别名类型没有原始类型上已经定义过的方法。
定义方法的一般格式如下:
func (recv receiver_type) methodName(parameter_list) (return_value_list) {
...
}
在方法名之前,func 关键字之后的括号中指定 receiver。
如果 recv
是receiver
的实例,Method1
是它的方法名,那么方法调用遵循传统的object.name
选择器符号:recv.Method1()
。
如果recv
是一个指针,Go 会自动解引用。
如果方法不需要使用 recv 的值,可以用 _ 替换它,比如:
func (_ receiver_type) methodName (parameter_list) (return_value_list) {
...
}
recv 就像是面向对象语言中的 this 或 self,但是 Go 中并没有这两个关键字。随个人喜好,你可以使用 this 或 self 作为 receiver 的名字。下面是一个结构体上的简单方法的例子:
package main
import "fmt"
type TwoInts struct {
a int
b int
}
func main() {
two1 := new(TwoInts)
two1.a = 12
two1.b = 10
fmt.Printf("The sum is: %d\n", two1.AddThem())
fmt.Printf("Add them to the param: %d\n", two1.AddToParam(20))
two2 := TwoInts{3, 4}
fmt.Printf("The sum is: %d\n", two2.AddThem())
}
func (tn *TwoInts) AddThem() int {
return tn.a + tn.b
}
func (tn *TwoInts) AddToParam(param int) int {
return tn.a + tn.b + param
}
输出:
The sum is: 22
Add them to the param: 42
The sum is: 7
方法是可以重载的,这里的话就有那么一点面向对象内味了~
比如
func (a *aaa) Fan(){
}
func (a *bbb)Fan(){
}
这种是可以的~
Go 语言不是一种 “传统” 的面向对象编程语言:它里面没有类和继承的概念。
接口是golang中实现多态性的好途径。接口类型是对其他类型行为的概括与抽象,对于一个具体的类型,无需声明它实现了哪些接口,只提供接口所必须的方法即可。
之前介绍的类型都是具体类型。go语言中还有一种类型称为接口类型。接口是一种抽象类型,他并没有暴露所含数据的布局或者内部结构,当然也没有那些数据的基本操作,它所提供的仅仅是一些方法而已,如果你拿到了一个接口,你无从知道他是什么,但是你能知道的仅仅是它能做什么,或者更精确地讲,仅仅是它提供了哪些方法。
接口定义了一组方法(方法集),但是这些方法不包含(实现)代码:它们没有被实现(它们是抽象的)。接口里也不能包含变量。
通过如下格式定义接口:
type Namer interface {
Method1(param_list) return_type
Method2(param_list) return_type
...
}
上面的 Namer
是一个 接口类型。
(按照约定,只包含一个方法的)接口的名字由方法名加 er
后缀组成,例如 Printer
、Reader
、Writer
、Logger
、Converter
等等。还有一些不常用的方式(当后缀 er
不合适时),比如 Recoverable
,此时接口名以 able
结尾,或者以 I
开头(像 .NET
或 Java
中那样)。
Go 语言中的接口都很简短,通常它们会包含 0 个、最多 3 个方法。
不像大多数面向对象编程语言,在 Go 语言中接口可以有值,一个接口类型的变量或一个 接口值 :var ai Namer
,ai
是一个多字(multiword)数据结构,它的值是 nil
。它本质上是一个指针,虽然不完全是一回事。指向接口值的指针是非法的,它们不仅一点用也没有,还会导致代码错误。
类型(比如结构体)可以实现某个接口的方法集;这个实现可以描述为,该类型的变量上的每一个具体方法所组成的集合,包含了该接口的方法集。实现了 Namer
接口的类型的变量可以赋值给 ai
(即 receiver
的值),方法表指针(method table ptr)就指向了当前的方法实现。当另一个实现了 Namer
接口的类型的变量被赋给 ai
,receiver
的值和方法表指针也会相应改变。
类型不需要显式声明它实现了某个接口:接口被隐式地实现。多个类型可以实现同一个接口。
实现某个接口的类型(除了实现接口方法外)可以有其他的方法。一个类型可以实现多个接口。
接口类型可以包含一个实例的引用, 该实例的类型实现了此接口(接口是动态类型)。
即使接口在类型之后才定义,二者处于不同的包中,被单独编译:只要类型实现了接口中的方法,它就实现了此接口。
所有这些特性使得接口具有很大的灵活性。
第一个例子:
package main
import "fmt"
type Shaper interface {
Area() float32
}
type Square struct {
side float32
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
func main() {
sq1 := new(Square)
sq1.side = 5
var areaIntf Shaper
areaIntf = sq1
// shorter,without separate declaration:
// areaIntf := Shaper(sq1)
// or even:
// areaIntf := sq1
fmt.Printf("The square has area: %f\n", areaIntf.Area())
}
输出:
The square has area: 25.000000
上面的程序定义了一个结构体 Square
和一个接口 Shaper
,接口有一个方法 Area()
。
在 main()
方法中创建了一个 Square
的实例。在主程序外边定义了一个接收者类型是 Square
方法的 Area()
,用来计算正方形的面积:结构体 Square
实现了接口 Shaper
。
所以可以将一个 Square
类型的变量赋值给一个接口类型的变量:areaIntf = sq1
。
现在接口变量包含一个指向 Square
变量的引用,通过它可以调用 Square
上的方法 Area()
。当然也可以直接在 Square
的实例上调用此方法,但是在接口实例上调用此方法更令人兴奋,它使此方法更具有一般性。接口变量里包含了接收者实例的值和指向对应方法表的指针。
这是 多态 的 Go 版本,多态是面向对象编程中一个广为人知的概念:根据当前的类型选择正确的方法,或者说:同一种类型在不同的实例上似乎表现出不同的行为。
如果 Square
没有实现 Area()
方法,编译器将会给出清晰的错误信息:
cannot use sq1 (type *Square) as type Shaper in assignment:
*Square does not implement Shaper (missing Area method)
如果 Shaper
有另外一个方法 Perimeter()
,但是Square
没有实现它,即使没有人在 Square
实例上调用这个方法,编译器也会给出上面同样的错误。
扩展一下上面的例子,类型 Rectangle
也实现了 Shaper
接口。接着创建一个 Shaper
类型的数组,迭代它的每一个元素并在上面调用 Area()
方法,以此来展示多态行为:
package main
import "fmt"
type Shaper interface {
Area() float32
}
type Square struct {
side float32
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
type Rectangle struct {
length, width float32
}
func (r Rectangle) Area() float32 {
return r.length * r.width
}
func main() {
r := Rectangle{5, 3} // Area() of Rectangle needs a value
q := &Square{5} // Area() of Square needs a pointer
// shapes := []Shaper{Shaper(r), Shaper(q)}
// or shorter
shapes := []Shaper{r, q}
fmt.Println("Looping through shapes for area ...")
for n, _ := range shapes {
fmt.Println("Shape details: ", shapes[n])
fmt.Println("Area of this shape is: ", shapes[n].Area())
}
}
输出:
Looping through shapes for area ...
Shape details: {5 3}
Area of this shape is: 15
Shape details: &{5}
Area of this shape is: 25
在调用 shapes[n].Area()
这个时,只知道 shapes[n]
是一个 Shaper
对象,最后它摇身一变成为了一个 Square
或 Rectangle
对象,并且表现出了相对应的行为。
也许从现在开始你将看到通过接口如何产生 更干净、更简单 及 更具有扩展性 的代码。在 11.12.3 中将看到在开发中为类型添加新的接口是多么的容易。
下面是一个更具体的例子:有两个类型 stockPosition
和 car
,它们都有一个 getValue()
方法,我们可以定义一个具有此方法的接口 valuable
。接着定义一个使用 valuable
类型作为参数的函数 showValue()
,所有实现了 valuable
接口的类型都可以用这个函数。
package main
import "fmt"
type stockPosition struct {
ticker string
sharePrice float32
count float32
}
/* method to determine the value of a stock position */
func (s stockPosition) getValue() float32 {
return s.sharePrice * s.count
}
type car struct {
make string
model string
price float32
}
//使用方法去获取车的值
func (c car) getValue() float32 {
return c.price
}
/* contract that defines different things that have value */
type valuable interface {
getValue() float32
}
func showValue(asset valuable) {
fmt.Printf("Value of the asset is %f\n", asset.getValue())
}
func main() {
var o valuable = stockPosition{"GOOG", 577.20, 4}
showValue(o)
o = car{"BMW", "M3", 66500}
showValue(o)
}
输出:
Value of the asset is 2308.800049
Value of the asset is 66500.000000
小生凡一,期待你的关注
联系客服