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

 1 package main

 import (
     "fmt"
     "sort"
 )

 type SortableStrings []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 []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 []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 []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 []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 []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{"", "", ""}
     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 []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{"", "", ""}
     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 []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{"", "", ""}
     ss.Sort() //值变量可以访问接收器是值类型的方法
     fmt.Println("Sortable Strings", ss)

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

     _, 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>\n",
         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>\n",
         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)

 }