Go语言——值方法 & 指针方法

 1 package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func main() {
    _, ok1 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)
}

自定义类型SortableStrings实现了接口sort.Interface中3个开放函数。自定义接口Sortable，除了包含sort.Interface的3个函数外，增加的Sort没有被SortableStrings实现。所以SortableStrings只实现了一个接口，即sort.Interface

---

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    _, ok1 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)
}

对自定义类型SortableStrings增加方法Sort，其实现是调用sort.Sort函数，该函数接受一个类型为sort.Interface的参数值，并利用这个值的Len,Less,Swap方法进行排序。

---

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self *SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    _, ok1 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)
}

接口Sortable中有4个函数需要实现，虽然SortableStrings实现了4个函数，但是Sort版的实现，接收器是指针类型。SortableStrings{}是值类型，不能访问基本类型SortableStrings接收器是指针的方法（即Sort），相当于SortableStrings{}只实现了Len、Less、Swap 3个函数，少实现一个函数，所以不是Sortable类型

---

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self *SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    _, ok1 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(&SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)
}

&SortableStrings{}是SortableStrings{}的指针类型，可以访问到基本类型SortableStrings中的4个函数。所以是Sortable的一个实现

---

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self *SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    _, ok1 := interface{}(&SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(&SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)
}

&SortableStrings{}是SortableStrings{}的指针类型。指针类型可以访问基本类型中接收器为值（或者指针）的类型。

---

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self *SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    ss := SortableStrings{"2", "3", "1"}
    ss.Sort()
    fmt.Println("Sortable Strings", ss)
    _, ok1 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)

    _, ok3 := interface{}(&SortableStrings{}).(sort.Interface)
    fmt.Println("ok3", ok3)

    _, ok4 := interface{}(&SortableStrings{}).(Sortable)
    fmt.Println("ok4", ok4)
}

---

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self *SortableStrings) Len() int {
    return len(self)
}

func (self *SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self *SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self *SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    ss := SortableStrings{"2", "3", "1"}
    ss.Sort()
    fmt.Println("Sortable Strings", ss)
    _, ok1 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(SortableStrings{}).(Sortable)
    fmt.Println("ok2", ok2)

    _, ok3 := interface{}(&SortableStrings{}).(sort.Interface)
    fmt.Println("ok3", ok3)

    _, ok4 := interface{}(&SortableStrings{}).(Sortable)
    fmt.Println("ok4", ok4)
}

---

上面关于“XX可以访问OO”的描述中，“访问“一词用的不准确。值变量可以访问接收器是指针类型的方法，指针变量也可以访问接收器是值类型的方法

package main

import (
    "fmt"
    "sort"
)

type SortableStrings [3]string

type Sortable interface {
    sort.Interface
    Sort()
}

func (self SortableStrings) Len() int {
    return len(self)
}

func (self SortableStrings) Less(i, j int) bool {
    return self[i] < self[j]
}

func (self SortableStrings) Swap(i, j int) {
    self[i], self[j] = self[j], self[i]
}

func (self *SortableStrings) Sort() {
    sort.Sort(self)
}

func main() {
    ss := SortableStrings{"2", "3", "1"}
    ss.Sort() //值变量可以访问接收器是值类型的方法
    fmt.Println("Sortable Strings", ss)

    fmt.Println("ss  : self[0] < self[1]", ss.Less(0, 1))
    fmt.Println("&ss : self[0] < self[1]", (&ss).Less(0, 1)) //指针变量可以访问接收器是值类型的方法

    _, ok1 := interface{}(ss).(sort.Interface)
    fmt.Println("ok1", ok1)

    _, ok2 := interface{}(ss).(Sortable)
    fmt.Println("ok2", ok2)

    _, ok3 := interface{}(&ss).(sort.Interface)
    fmt.Println("ok3", ok3)

    _, ok4 := interface{}(&ss).(Sortable)
    fmt.Println("ok4", ok4)

    _, ok5 := interface{}(SortableStrings{}).(sort.Interface)
    fmt.Println("ok5", ok5)

    _, ok6 := interface{}(SortableStrings{}).(Sortable)
    fmt.Println("ok6", ok6)

    _, ok7 := interface{}(&SortableStrings{}).(sort.Interface)
    fmt.Println("ok7", ok7)

    _, ok8 := interface{}(&SortableStrings{}).(Sortable)
    fmt.Println("ok8", ok8)
}

所以上面”访问“一词用的不准确。值变量可以访问接收器是值类型的方法  还是  指针变量可以访问接收器是值类型的方法，都是编译器帮我们做了部分转换工作。

 http://play.golang.org/p/KG8-Qb7gqM

package main

import (
    "log"
)

type User struct {
    Name  string
    Email string
}

func (u *User) Notify() error {
    log.Printf("User: Sending User Email To %s<%s>
",
        u.Name,
        u.Email)

    return nil
}

type Notifier interface {
    Notify() error
}

func SendNotification(notify Notifier) error {
    return notify.Notify()
}

func main() {
    user := User{
        Name:  "AriesDevil",
        Email: "ariesdevil@xxoo.com",
    }

    SendNotification(user)
}

“值类型(或 指针类型)是否是该接口类型的实现呢？”

User的值类型变量不是 接口 Notifer的实现。也就是

_, ok1 := interface{}(user).(Notifier)
fmt.Println("ok1", ok1)                //false

_, ok2 := interface{}(&user).(Notifier)
fmt.Println("ok2", ok2)               //true
SendNotification(user)

上文报错，是因为user不是Notifier的实现，也就不能赋值给 SendNotification(notify Notifier)的notify.调用函数，参数就涉及到传值，只有相同类型或者其实现才可能相互赋值。如果不是调用函数，某一类型的值或者指针直接调用自己的方法（接收器是值或者指针）都是可以的

package main

import (
    "fmt"
    "log"
)

type User struct {
    Name  string
    Email string
}

func (u *User) Notify() error {
    log.Printf("User: Sending User Email To %s<%s>
",
        u.Name,
        u.Email)

    return nil
}

func (u User) NameString() {
    u.Name = "Bob"
    fmt.Println("Name", u.Name)
}

func (u *User) EmailString() {
    u.Email = "Bob@hotmail.com"
    fmt.Println("Email", u.Email)
}

type Notifier interface {
    Notify() error
    NameString()
    EmailString()
}

func SendNotification(notify Notifier) error {
    return notify.Notify()
}

func main() {
    user := User{
        Name:  "AriesDevil",
        Email: "ariesdevil@xxoo.com",
    }

    user.NameString()
    user.EmailString()
    fmt.Println("Name", user.Name)
    fmt.Println("Email", user.Email)

    (&user).NameString()
    (&user).EmailString()
    fmt.Println("Name", (&user).Name)
    fmt.Println("Email", (&user).Email)

    _, ok1 := interface{}(user).(Notifier)
    fmt.Println("ok1", ok1) //false

    _, ok2 := interface{}(&user).(Notifier)
    fmt.Println("ok2", ok2) //true

    //SendNotification(user)

}