go的面向对象[转]

乃可当旁的自定义类型中定义任意多的method,接下吃咱看一个扑朔迷离一点底例证

package main
import "fmt"

const(
    WHITE = iota
    BLACK
    BLUE
    RED
    YELLOW
)

type Color byte

type Box struct {
    width, height, depth float64
    color Color
}

type BoxList []Box //a slice of boxes

func (b Box) Volume() float64 {
    return b.width * b.height * b.depth
}

func (b *Box) SetColor(c Color) {
    b.color = c
}

func (bl BoxList) BiggestsColor() Color {
    v := 0.00
    k := Color(WHITE)
    for _, b := range bl {
        if b.Volume() > v {
            v = b.Volume()
            k = b.color
        }
    }
    return k
}

func (bl BoxList) PaintItBlack() {
    for i, _ := range bl {
        bl[i].SetColor(BLACK)
    }
}

func (c Color) String() string {
    strings := []string {"WHITE", "BLACK", "BLUE", "RED", "YELLOW"}
    return strings[c]
}

func main() {
    boxes := BoxList {
        Box{4, 4, 4, RED},
        Box{10, 10, 1, YELLOW},
        Box{1, 1, 20, BLACK},
        Box{10, 10, 1, BLUE},
        Box{10, 30, 1, WHITE},
        Box{20, 20, 20, YELLOW},
    }

    fmt.Printf("We have %d boxes in our set\n", len(boxes))
    fmt.Println("The volume of the first one is", boxes[0].Volume(), "cm³")
    fmt.Println("The color of the last one is",boxes[len(boxes)-1].color.String())
    fmt.Println("The biggest one is", boxes.BiggestsColor().String())

    fmt.Println("Let's paint them all black")
    boxes.PaintItBlack()
    fmt.Println("The color of the second one is", boxes[1].color.String())

    fmt.Println("Obviously, now, the biggest one is", boxes.BiggestsColor().String())
}

点的代码通过const定义了有的常量,然后定义了有打定义类型

  • Color作为byte的别名
  • 概念了一个struct:Box,含有三独长宽高字段和一个颜料属性
  • 概念了一个slice:BoxList,含有Box

然后因点的自定义类型为接收者定义了一些method

  • Volume()定义了收信人为Box,返回Box的容量
  • SetColor(c Color),把Box的颜料改变吧c
  • BiggestsColor()定在以BoxList上面,返回list里面容量最充分的颜色
  • PaintItBlack()把BoxList里面有Box的颜色全部化黑色
  • String()定义在Color上面,返回Color的具体颜色(字符串格式)

上面的代码通过文字描述出来以后是勿是坏简单?我们一般解决问题且是由此问题的叙述,去写相应的代码实现。

指南针作为receiver

现叫咱回过头来看看SetColor这个method,它的receiver是一个针对性Box的指针,是的,你得利用*Box。想想也啥要动用指针而无是Box本身吗?

咱定义SetColor的真目的是想念转是Box的水彩,如果未传Box的指针,那么SetColor接受之实在是Box的一个copy,也就是说method内对此颜色值的修改,其实只有图被Box的copy,而休是当真的Box。所以我们得传入指针。

此间可以将receiver当作method的率先独参数来拘禁,然后成前面函数讲解的传值和传引用便不难理解

此地而可能会咨询了那SetColor函数里面应该这么定义*b.Color=c,而不是b.Color=c,因为咱们用读取到指针相应的价。

若是指向之,其实Go里面这简单种植方法还是不易的,当您用指针去拜谒相应的字段时(虽然指针没有外的字段),Go知道你而透过指针去抱这价值,看到了吧,Go的筹划是匪是越来越引发你了。

唯恐细心的读者见面问这样的题目,PaintItBlack里面调用SetColor的时刻是匪是应有写成(&bl[i]).SetColor(BLACK),因为SetColor的receiver是*Box,而不是Box。

乃还要说对的,这有限种方式还足以,因为Go知道receiver是指针,他活动帮你改变了。

啊尽管是说:

一旦一个method的receiver是*T,你可以以一个T类型的实例变量V上面调用这个method,而无需&V去调用这个method

类似的

设若一个method的receiver是T,你可在一个*T类型的变量P上面C++调用这个method,而未待
*P去调用这个method

之所以,你不用担心若是调用的指针的method还是免是指针的method,Go知道你如做的全体,这对于生多年C/C++编程经验的同桌来说,真是解决了一个不胜酷之痛苦。

method继承

面前一章节我们学了字段的连续,那么您也会见发觉Go的一个神奇之处在,method也是可持续的。如果匿名字段实现了一个method,那么带有这个匿名字段的struct也能够调动用该method。让咱来拘禁下是事例

package main
import "fmt"

type Human struct {
    name string
    age int
    phone string
}

type Student struct {
    Human //匿名字段
    school string
}

type Employee struct {
    Human //匿名字段
    company string
}

//在human上面定义了一个method
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}

    mark.SayHi()
    sam.SayHi()
}

method重写

面的例证中,如果Emplyee想使实现和谐之SayHi,怎么收拾?简单,和匿名字段闯一样的道理,我们好以Emplyee上面定义一个method,重写了匿名字段的法子。请圈下的例证

package main
import "fmt"

type Human struct {
    name string
    age int
    phone string
}

type Student struct {
    Human //匿名字段
    school string
}

type Employee struct {
    Human //匿名字段
    company string
}

//Human定义method
func (h *Human) SayHi() {
    fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

//Employee的method重写Human的method
func (e *Employee) SayHi() {
    fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
        e.company, e.phone) //Yes you can split into 2 lines here.
}

func main() {
    mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
    sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}

    mark.SayHi()
    sam.SayHi()
}

面的代码设计的是这么之良,让人口无自觉的吧Go的规划惊呆!

经过这些情节,我们得计划有中心的面向对象的次第了,但是Go里面的面向对象是这般之简易,没有另外的私、公有关键字,通过轻重写来落实(大写开头的吗共有,小写起来的吧个人),方法呢一如既往适用是规则。