Go/面向对象特性/方法-封装

# 可以为任意自定义类型（结构体、基础数据类型）绑定方法，但不包括指针类型

# func (t T) f(paras) (rets)     //接收者 参数 返回值

# 方法总是绑定对象实例t，并隐式地将实例t作为第一实参

# 方法中若不使用t，可以省略

# t的类型可以是T或*T,但T不能是接口或指针

# 不支持方法重载

# 同一方法名绑定不同接收者类型，不视为重名

package main

import "fmt"

//面向过程普通函数
func add1(a,b int) (c int){
	c = a+b
	return
}

//面向过程方法
//给自定义类型绑定方法
type long int
func (tmp long)add2(a long) long{
	return tmp+a
}

func main() {
	//匿名函数
	c := func (a int,b int)(c int){
		c = a+b
		return
	}(1,2)
	fmt.Println(c)

	var l long = 10
	l = l.add2(3)
	fmt.Println(l)
}

type T *int
func (t T) f(a int) int{	//无效接收者类型，编译不通过
	return a + int(*t)
}

type T2 int
func (t *T2) f(a int) int{	//编译通过
	return a + int(*t)
}

package main

import "fmt"

type Stu struct{
	name string
	age int
}

type Sstu struct{
	phone int
	addr string
	Stu
	sex byte
}

func main() {
	s := Stu{}
	ps := &s
	fmt.Printf("Stu  %p %+v \n",ps,s)

	//方法继承与重写
	ss := Sstu{Stu:Stu{name:"aaa"},sex:'m'}
	ss.Stu.test_p()					//Stu  0xc000052460 {name:aaa age:0}
	ss.test_p()				//继承	//Stu  0xc000052460 {name:aaa age:0}
	ss.test()				//重写

	//方法集
	s.test()		//值传递
	s.test_p()		//地址传递
	ps.test_p()		//地址传递
	ps.test()		//值传递

	//方法值  保存方法地址
	f := s.test
	f()
	f = s.test_p
	f()

	//方法表达式
	ff := (*Stu).test_p
	ff(&s)
}

func (s Stu) test(){
	fmt.Printf("Stu  %p %+v \n",&s,s)
}

func (ps *Stu) test_p(){
	fmt.Printf("*Stu  %p %+v \n",ps,*ps)
}

//方法重写
func (ss Sstu) test(){
	fmt.Printf("Sstu  %p %+v \n",&ss,ss)
}