Go面向对象

Go行为的定义和实现

Go语言的面向对象 
Go的面向对象和其他语言有着极大的差别
GO语言不支持继承，Go语言接口的实现也使用了自己独特的方式 

Go对数据和行为的封装

package OOP

import (
	"fmt"
	"testing"
	"unsafe"
)

/*
	面向对象的非常重要的特性是继承，GO中不支持继承
	GO语言的接口实用的是和其他语言完全不一样的

	面向对象
	1.封装数据和行为
		封装成员
		type Employee struct {
			Id string
			Name string
			Age int
		}
*/

type Employee struct {
	Id string
	Name string
	Age int
}
//第一种定义方式在实例对应方法被调用时，实例的成员会进行值复制
func (e Employee) StringA() string {
	fmt.Printf("Address is %x\n",unsafe.Pointer(&e.Name))
	return fmt.Sprintf("ID:%s-Name:%s-Age:%d",e.Id,e.Name,e.Age)
}

//通常情况下为了避免内存拷贝我们使用第二种定义方式
func (e *Employee) StringB() string{
	fmt.Printf("Address is %x\n",unsafe.Pointer(&e.Name))
	return fmt.Sprintf("ID:%s-Name:%s-Age:%d",e.Id,e.Name,e.Age)
}

func TestOOP(t *testing.T) {
	e := Employee{"0","Bob",20}
	e1 := Employee{Name: "Mike",Age: 20}
	/*
		这里返回的引用/指针 相当于e := &Employee{}
		和其他语言的主要差异，通过实例的指针访问成员不需要->
	*/
	e2 := new(Employee)
	e2.Id = "123"
	e2.Age = 23
	e2.Name = "Rose"
	fmt.Println(e,e1,e2)
	t.Log(e,e1,e2)
	t.Logf("e is %T",e)			//OOP.Employee
	t.Logf("e2 is %T",e2)		//*OOP.Employee
	t.Logf("e is %T",&e)	//*OOP.Employee

}




func TestStructOperations(t *testing.T) {
	e := &Employee{"0","Bob",20}
	t.Log(e.StringB())
	fmt.Printf("Address is %x\n",unsafe.Pointer(&e.Name))
	//使用StringB引用不会复制新对象出现，使用StringA会产生新对象 调用实例，结构整体被复制了
}

核心问题

尽量不使用传递参数为非引用/指针的形式 
使用对象本身会导致对象复制的开销问题，使用指针/引用 不会导致额外的对象内存开销