go语言之面向对象一

在Go语言中, 你可以给任意类型（包括内置类型，但不包括指针类型）添加相应的办法。示例如下：

type Integer int

 

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

        return a < b

 

func main(){

        var a Integer=1

        if a.Less(2){

                 fmt.Println(a,"less than 2")

        }

}

在代码中，我们为内置的int类型增加了一个新方法Less()。这样实现了后，就可以让整型像一个普通的类一样使用。对应的面向过程的方法如下：

func Integer_Less(a Integer, b Integer) bool {

    return a<b

}

那么当我们需要修改对象的值的时候，就需要用到指针引用。调用如下：

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

        *a+=b

}

如果不传入指针，那么得到的值和传入的时候是一样的，这一点Go和C语言一样，类型都是基于值传递的。要想修改变量的值，只能传递指针。

 

既然类型都可以有自己的办法，那么对于结构体来说也一样可以拥有自己的方法。示例如下：

type Rect struct{

        x,y float32

        width,height float64

}

func (r Rect) Area() float64{

        return r.width*r.height

}

 

func main(){

        var r Rect

        r.height=3

        r.width=4

        fmt.Println("the area is:",r.Area())

}

 

既然是面向对象，那么是否可以继承呢。答案是肯定的，Go里面也可以使用继承。但是和C++以及Java的方法不一样，采用了继承的方法。一般称为匿名组合。

type string1 struct{

        first string

}

 

type string2 struct{

        string1

        second string

}

这个string1在string2的位置是灵活可变的，可以放在second的后面也可以放在前面。Go语言很清晰的告诉你类的内存布局是怎样的。此外，在Go语言中还可以随心所欲的修改内存布局。下面的代码定义了一个Base类并且实现了Foo和Bar两个方法。然后定义了一个Foo类，该类从Base类继承并改写了Bar方法。如果没有改写的话，那么相应的方法就被继承。例如foo.Foo就和foo.Base.Foo调用是一致的

 

type Base struct{

        Name string

}

 

func(base *Base) Foo(){

}

 

func(base *Base) Bar(){

}

 

type Foo struct{

        Base

}

 

func(foo *Foo) Bar(){

        /*修改Bar实现*/

}

 

在c++和java中，对于继承都有很多关键字，比如private,public,protected. Go语言对关键字的增加非常谨慎。要是某个符号对其他包可见，需要将符号定义为以大写字母开头，否则无法访问。

package cal

 

type Garden struct{

        x,y float32

}

func main(){

        var g cal.Garden

        g.x=1

}

在cal包内申明了Garden，并且有x和y两个变量。在引用的时候会提示如下错误：

src\test.go:62:3: g.x undefined (cannot refer to unexported field or method x)

提示找不到x。如果改成下面的形式则可以通过g.X=1来访问

type Garden struct{

        X,Y float32

}