go语言学习初探（三）面向对象编程

继承

package main

import (
    "fmt"
)

type Integer int

func (a Integer) Less(b Integer) bool {
    return a > b
}

func main() {
    var integer Integer = 1
    fmt.Println(integer.Less(0))
}
// print -> true

指针运算符 *

package main

import (
    "fmt"
)

type Person struct {
    Id   string
    Name string
}

func main() {
    p1 := Person{"1", "张三"}
    p2 := &p1
    p1.Id = "2"
    fmt.Println(p1, *p2)
}
// print -> {2 张三} {2 张三}

取址符 &

package main

import (
    "fmt"
)

type Person struct {
    Id   string
    Name string
}

func main() {
    p1 := Person{"1", "张三"}
    p2 := &p1
    p1.Id = "2"
    fmt.Println(p1, p2)
}
// print -> {2 张三} &{2 张三}

   &取址可以让p1与p2共享同一块数据内存，从而在修改的时候p1与p2的结果相同。

非取址

package main

import (
    "fmt"
)

type Person struct {
    Id   string
    Name string
}

func main() {
    p1 := Person{"1", "张三"}
    p2 := p1
    p1.Id = "2"
    fmt.Println(p1, p2)
}
// print -> {2 张三} {1 张三}

   Go 语言的基本类型在赋值的时候，实际上是值传递，包括复合类型，这点与其他的面向对象语言方式不同，需要在开发的时候额外注意。

数组切片

package main

import (
    "fmt"
)

func main() {
    a1 := []int{1, 2, 3}
    a2 := a1
    a1[0] = 10
    fmt.Println(a1, a2)
}
// print -> [10 2 3] [10 2 3]

map

package main

import (
    "fmt"
)

func main() {
    m1 := map[string]string{"1": "hi"}
    m2 := m1
    m1["1"] = "ok"
    fmt.Println(m1, m2)
}
// print -> map[1:ok] map[1:ok]

channel

inteface

interface 接口

package main

import (
    "fmt"
)

type Person struct {
    Name string
}

func (p *Person) Find() {
    fmt.Println("find person")
}

type IFind interface {
    Find()
}

type IString interface {
    String()
}

func main() {
    var f IFind = new(Person)
    f.Find()
}
// print -> find person

package main

import (
    "fmt"
)

type Integer int

func (a Integer) Less(b Integer) bool {
    return a < b
}

func (a Integer) Add(b Integer) {
    a += b
}

type LessAdder interface {
    Less(b Integer) bool
    Add(b Integer)
}

func main() {
    var a Integer = 1
    var b LessAdder = a
    fmt.Println(a, b)
}
// print -> 1 1