Go语言之Go 语言方法

Go 语言方法

go 语言方法定义

方法介绍
在 Go 语言中有一个概念和函数极其相似,叫做方法 。Go 语言的方法其实是作用在接收者(receiver)上的一个函数,接收者是某种非内置类型的变量。因此方法是一种特殊类型的函数。

接收者类型可以是(几乎)任何类型,不仅仅是结构体类型:任何类型都可以有方法,甚至可以是函数类型,可以是 int、bool、string 或数组的别名类型。但是接收者不能是接口类型。

方法的声明和普通函数的声明类似,只是在函数名称前面多了一个参数,这个参数把这个方法绑定到这个参数对应的类型上。

方法定义
首先声明一个自定义类型Test

type Test struct{}

方法参数 receiver 类型可以是 Test 或 *Test。类型 Test不能是接口或指针。

第一种,定义一个无参数、无返回值的方法

func (t Test) method() {
}
func (t *Test) method() {

}

第二种,定义一个单参数、无返回值的方法

func (t Test) method(i int) {
}
func (t *Test) method(i int) {

}

第三种,定义一个多参数、无返回值的方法

func (t Test) method(x, y int) {

}
func (t *Test) method(x, y int) {

}

第四种,定义一个无参数、单返回值的方法

func (t Test) method() (i int) {
    return
}
func (t *Test) method() (i int) {
    return
}

第五种,定义一个多参数、多返回值的方法

func (t Test) method(x, y int) (z int, err error) {
    return
}
func (t *Test) method(x, y int) (z int, err error) {
    return
}

方法和函数的关系

方法是特殊的函数,定义在某一特定的类型上,通过类型的实例来进行调用,这个实例被叫接收者。

接收者必须有一个显式的名字,这个名字必须在方法中被使用。 接收者类型必须在和方法同样的包中被声明。

注意: Go语言不允许为简单的内置类型添加方法,下面定义的方法是非法的。

package main

import (
    "fmt"
)

//方法不能是内置数据类型
func (a int) Add(b int) {
    fmt.Println(a + b)
}

编译错误:

cannot define new methods on non-local type int

我们可以用Go语言的type,来定义一个和int具有同样功能的类型。这个类型不能看成是int类型的别名,它们属于不同的类型,不能直接相互赋值。

合法的方法定义如下:

package main

import (
    "fmt"
)

type myInt int

func (a myInt) Add(b myInt) {
    fmt.Println(a + b)
}

func main() {
    var x, y myInt = 3, 6
    x.Add(y)
}

函数与方法的区别

1、对于普通函数,接收者为值类型时,不能将指针类型的数据直接传递,反之亦然。
2、对于方法(如struct的方法),接收者为值类型时,可以直接用指针类型的变量调用方法,反过来同样也可以。

Go 语言方法规则

根据调用者不同,方法分为两种表现形式:方法(method value)、方法表达式(method expression)。

两者都可像普通函数那样赋值和传参,区别在于 方法 (method value)绑定了实例,而方法表达式(method expression)必须显式传参。

直接调用

直接调用,类型 T 和 *T 上的方法集是互相继承的。

package main

import (
    "fmt"
)

type T struct {
    int
}

func (t T) testT() {
    fmt.Println("接受者为 T ")
}

func (t *T) testP() {
    fmt.Println("接受者为 *T ")
}

func main() {
    t1 := T{1}
    fmt.Printf("t1 is : %v\n", t1)
    t1.testT()
    t1.testP()

    t2 := &t1
    fmt.Printf("t2 is : %v\n", t2)
    t2.testT()
    t2.testP()
}

直接调用,类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 T 和 *T 上的方法集是互相继承的。

package main

import (
    "fmt"
)

type ST struct {
    T
}

type SP struct {
    *T
}

type T struct {
    int
}

func (t T) testT() {
    fmt.Println("类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 T 方法")
}
func (t *T) testP() {
    fmt.Println("类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 *T 方法")
}

func main() {
    st1 := ST{T{1}}
    st2 := &st1
    fmt.Printf("st1 is : %v\n", st1)
    st1.testT()
    st1.testP()
    fmt.Printf("st2 is : %v\n", st2)
    st2.testT()
    st2.testP()

    sp1 := SP{&T{1}}
    sp2 := &sp1
    fmt.Printf("sp1 is : %v\n", sp1)
    sp1.testT()
    sp1.testP()
    fmt.Printf("sp2 is : %v\n", sp2)
    sp2.testT()
    sp2.testP()
}

隐式传递调用

接受者隐式传递,类型 T 和 *T 上的方法集是互相继承的。

package main

import (
    "fmt"
)

type T struct {
    string
}

func (t T) testT() {
    fmt.Println("接受者为 T ")
}

func (t *T) testP() {
    fmt.Println("接受者为 *T ")
}

func main() {
    t := T{"oldboy"}
    methodValue1 := t.testT
    methodValue1()
    methodValue2 := (&t).testT
    methodValue2()
    methodValue3 := t.testP
    methodValue3()
    methodValue4 := (&t).testP
    methodValue4()
}

接受者隐式传递,类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 T 和 *T 上的方法集是互相继承的。

package main

import (
    "fmt"
)

type ST struct {
    T
}

type SP struct {
    *T
}

type T struct {
    string
}

func (t T) testT() {
    fmt.Println("类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 T 方法")
}
func (t *T) testP() {
    fmt.Println("类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 *T 方法")
}

func main() {
    st1 := ST{T{"oldboy"}}
    methodValue1 := st1.testT
    methodValue1()
    methodValue2 := (&st1).testT
    methodValue2()
    methodValue3 := st1.testP
    methodValue3()
    methodValue4 := (&st1).testP
    methodValue4()

    sp1 := SP{&T{"oldboy"}}
    methodValue5 := sp1.testT
    methodValue5()
    methodValue6 := (&sp1).testT
    methodValue6()
    methodValue7 := sp1.testP
    methodValue7()
    methodValue8 := (&sp1).testP
    methodValue8()
}

显式传递调用

接受者显示传值,类型 T 的可调用方法集包含接受者为 T 的所有方法,不包含接受者为 *T 的方法。类型 *T 的可调用方法集包含接受者为 *T 或 T 的所有方法集。

package main

import (
    "fmt"
)

type T struct {
    string
}

func (t T) testT() {
    fmt.Println("接受者为 T ")
}

func (t *T) testP() {
    fmt.Println("接受者为 *T ")
}

func main() {
    t := T{"oldboy"}
    expression1 := T.testT
    expression1(t)
    expression2 := (*T).testT
    expression2(&t)

    // expression3 := T.testP
    // expression3(t)
    expression4 := (*T).testP
    expression4(&t)

}

接受者显示传值,类型 S 包含匿名字段 *T ,则 S 和 *S 方法集包含 T 和 *T 上的方法集是互相继承的。
类型 S 包含匿名字段 T ,类型 S 的可调用方法集包含接受者为 T 的所有方法,不包含接受者为 *T 的方法。类型 *S 的可调用方法集包含接受者为 *T 或 T 的所有方法集。

package main

import (
    "fmt"
)

type ST struct {
    T
}

type SP struct {
    *T
}

type T struct {
    string
}

func (t T) testT() {
    fmt.Println("类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 T 方法")
}
func (t *T) testP() {
    fmt.Println("类型 S 包含匿名字段 *T 或 T ,则 S 和 *S 方法集包含 *T 方法")
}

func main() {
    st1 := ST{T{"oldboy"}}
    expression1 := ST.testT
    expression1(st1)
    expression2 := (*ST).testT
    expression2(&st1)
    // expression3 := ST.testP
    // expression3(st1)
    expression4 := (*ST).testP
    expression4(&st1)

    sp1 := SP{&T{"oldboy"}}
    expression5 := SP.testT
    expression5(sp1)
    expression6 := (*SP).testT
    expression6(&sp1)
    expression7 := SP.testP
    expression7(sp1)
    expression8 := (*SP).testP
    expression8(&sp1)
}

Go 语言方法应用

匿名字段

Go语言支持只提供类型,而不写字段名的方式,也就是匿名字段,也称为嵌入字段。

当匿名字段是一个struct的时候,那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。

Go语言匿名字段可以像字段成员那样访问匿名字段方法,编译器负责查找。

package main

import "fmt"

type Student struct {
    id   int
    name string
}

type Course struct {
    Student
}

func (self *Student) ToString() string {
    return fmt.Sprintf("Student: %p, %v", self, self)
}

func main() {
    c := Course{Student{1, "oldboy"}}
    fmt.Printf("Course: %p\n", &c)
    fmt.Println(c.ToString())
}

运行结果:

Class: 0xc0420023e0
User: 0xc0420023e0, &{1 oldboy}

Go 语言不像其它面相对象语言一样可以写个类,然后在类里面写一堆方法,但其实Go语言的方法很巧妙的实现了这种效果:我们只需要在普通函数前面加个接受者(receiver,写在函数名前面的括号里面),这样编译器就知道这个函数(方法)属于哪个struct了。

继承复用

Go语言中没有继承,但是可以依靠组合来模拟继承和多态。

通过匿名字段,可获得和继承类似的复用能力。依据编译器查找次序,只需在外层定义同名方法,就可以实现。

package main

import "fmt"

type Student struct {
    id   int
    name string
}

type Course struct {
    Student
    title string
}

func (self *Student) ToString() string {
    return fmt.Sprintf("Student: %p, %v", self, self)
}

func (self *Course) ToString() string {
    return fmt.Sprintf("Course: %p, %v", self, self)
}

func main() {
    c := Course{Student{1, "oldboy"}, "Golang"}

    fmt.Println(c.ToString())

    fmt.Println(c.Student.ToString())
}

运行结果:

Course: 0xc04207e060, &{{1 oldboy} Golang}
Student: 0xc04207e060, &{1 oldboy}

自定义ERROR
错误是可以用字符串描述自己的任何东西。 可以由预定义的内建接口类型 error,和其返回字符串的方法 Error 构成。

type error interface {
Error() string
}

当用 fmt 包的多种不同的打印函数输出一个 error 时,会自动的调用该方法。

package main

import (
    "fmt"
    "os"
    "time"
)

type PathError struct {
    path       string
    op         string
    createTime string
    message    string
}

func (p *PathError) Error() string {
    return fmt.Sprintf("path=%s \nop=%s \ncreateTime=%s \nmessage=%s", p.path,
        p.op, p.createTime, p.message)
}

func Open(filename string) error {

    file, err := os.Open(filename)
    if err != nil {
        return &PathError{
            path:       filename,
            op:         "read",
            message:    err.Error(),
            createTime: fmt.Sprintf("%v", time.Now()),
        }
    }

    defer file.Close()
    return nil
}

func main() {
    err := Open("/oldboy/golang.go")
    switch v := err.(type) {
    case *PathError:
        fmt.Println("get path error,", v)
    default:
    }
}
posted @ 2020-03-27 10:09  Sunny_Boy_H  阅读(135)  评论(0编辑  收藏  举报