go基本理解

看了几天go，刚刚看了一个大佬的文章----golang之面向对象，https://studygolang.com/articles/3063，深受理解。。。

1、go语言中，可以给任意类型（包括内置类型，但是不包括指针类型）添加相应的方法。例如：

type Integer int         //type可以在此刻理解成typedef

func (a Integer) Less(b Integer) bool {

return a < b

}

func main() {

var a Integer = 1

if a.Less(2) {

fmt.Println("less then 2")

}

}       //go语言没有this指针，而是在定义成员方法时显示声明其所属对象

2、如果需要修改对象的值，可以传递对象的指针

func (a *Ingeger) Add(b Integer) {

     *a += b

}                   //go这里也是基于值传递

func main() {

     var a Integer = 1

      a.Add(3)

       fmt.Println("a =", a)     //  a = 4

} 如果Add方法不使用指针，则a返回的结果不变，因为go也是值传递

3、go语言没有构造函数的概念，通常使用一个全局函数来完成。

func NewRect(x, y, width, height float64) *Rect {

     return &Rect{x, y, width, height}

}   

func main() {

     rect1 := NewRect(1,2,10,20)

    fmt.Println(rect1.width)

}

4、go语言中提供组合的方式类似于C++中的继承。当一个struct类型在另一个struct类型中声明时，称这两个类有组合的关系。例如：

type Base struct {    //base类

     name string

}

func (base *Base) Set(myname string) {    //base类的set方法，无返回值，由base

     base.name = myname             //类型调用，参数为string类型

}

func (base *Base) Get() string {     //base类的get方法，返回值为string，由base

     return base.name           //类调用，无参数

}

type Derived struct {

     Base            //derived类组合来自base类型

     age int

}

func (derived *Derived) Get() (nm string, ag int) {

     return derived.name, derived.age    //derived改写了基类的get方法，此时派

}                                  //生类调用的get是其改写完成的

func main() {

     b := &Derived{}

    b.Set("sina")

     fmt.Println(b.Get())

}

看到这比较好奇，想知道go是否有C++中的多态，查了查。Go语言没有严格意义的多态，但是我们可以通过接口实现简单的多态，不，不是实现，是模拟。

type Human interface {

     sayHello()

}

type Chinese struct {

        name string

}

type English struct {

     name string

}

func (c *Chinese) sayHello() {

        fmt.Println(c.name, "said:hello word")

}

func (c *English) sayHello() {

        fmt.Println(c.name, "said:hello word")

}

func main() {

     c := Chinese{"chinese"}

     d := English{"english"}

     c.sayHello()

     d.sayHello()

}

5、当类型和被组合的类型包含同名成员时，会覆盖和继承。例：

type Base struct {

     name string

     age  int

}

func (base *Base) Set(myname string, myage int) {

     base.name = myname

     base.age = myage

}

type Derived struct {

     Base

     name string

}

func main() {

     b := &Derived{}

     b.Set("sina", 30)

     fmt.Println("b.name =", b.name, "\tb.Base.name =", b.Base.name)

     fmt.Println("b.age =", b.age, "\tb.Base.age =", b.Base.age)

}

结果显示：

 

其具体机构应该如下：

 

6、go语言中的数组和基本类型没有区别，都是很纯粹的值类型。

func main() {

    var a = [3]int{1, 2, 3}

    var b = a   //定义值传递，如果需要表达引用，则修改为var b = &a

    b[1]++      //如果定义引用，那么打印结果为1,3,3    1,3,3

    fmt.Println(a, b)

}    //打印结果为1,2,3     1,3,3