面向对象(上)

类与函数

“A method is a function with an implicit first argument, called a receiver.”

方法是一个函数要有一个接收者。

func (r ReceiverType) funcName(parameters) (results)

面向结构：

package main
import "fmt"
func compare(a, b int) bool{
    return a < b
}
func main(){
    var a int = 1
    var b int = 2
    
    fmt.Printf("%v", compare(a, b))
}

返回true

类型和作用在它上面定义的方法必须在同一个包里定义，这就是为什么不能在 int、float 或类似这些的类型上定义方法。

所以要用struct把int 封装起来，在golang中，struct 就相当于class

面向对象：

package main
import "fmt"
type Integer struct{         //定义了一个Integer类
    value int                //成员变量叫value
}
func(a Integer) compare(b Integer) bool {          //以接收者的形式来定义的
    return a.value < b.value                       //在Integer类里面添加compare方法
}                                                  // 这个方法强加在Integer结构体上
                                                   //golang中面向对象
func main(){
    a := Integer{1}
    b := Integer{2}
    
    fmt.Printf("%v" , a.compare(b))
}

输出true.

类的初始化

point := new(Point)
point := &Point{} 
point := &Point{x:100 , y:100}          //前三种都是初始化指针变量

point := Point{}                   //直接初始化实例对象
package main
import "fmt"

type Point struct{
    px float32
    py float32               //x , y 坐标
}

func (point *Point) setXY(px , py float32){        // 设置
    point.px = px
    point.py = py      
}                                           //如果不是指针，则是拷贝，指针可以改变
                                            //方法设置在指针变量上，指针类型可以改变变量
func(point *Point) getXY()(float32,float32){        // 返回x,y 坐标的函数
    return point.px,point.py
}

type Integer struct{
    value int
}

func main(){
    point := new(Point)          
    point.setXY(1.43,2.78)
    px,py := point.getXY()
    fmt.Print(px,py)
}

输出结果：

1.43，2.78