Go 其五 到底是不是面向对象语言 -- 封装数据和行为， 接口， 自定义类型

　　关于Go是不是面向对象语言其实有很多争论，关于给出的解释是：Yes and no.

 

封装数据和行为
　　结构体定义

type Employee struct {
    Id string
    Name string
    Age int
}

　　

　　实例创建及初始化

e := Employee{"0", "Bob", 20}
e1 := Employee{Name: "Mike", Age: 30}
e2 := new(Employee) //注意这里返回的引用/指针, 相当于 e:= &Employee{}
e2.Id = "2" //与其他主要编程语言的差异：通过实例的指针访问成员不需要使用->
e2.Age = 22
e2.Name = "Rose"

　　

行为(方法)的定义

//第一种定义方式在实例对应方法被调用时，实例的成员会进行值复制
func (e Employee) String() string {
    return fmt.Sprintf("ID:%s-Name:%s-Age:%d", e.Id, e.Name, e.Age)
}

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

　　

Duck Type式接口实现
　　接口定义

type Programmer interface {
　　WriteHelloWorld() Code
}

　　

　　接口实现

type GoProgrammer struct {
}

func (p *GoProgrammer) WriteHelloWorld() Code {
    return "fmt.Println(\"Hello World!\")"
}

　　

 

Go接口
　　与其他主要编程语言的差异

1. 接口为非入侵性的，实现不依赖于接口的定义
2. 所以接口的定义可以包含在接口使用者包内

　　接口变量

var prog Coder = &GoProgrammer{}
// 以上prog是接口Coder的一个变量

　　

当prog被初始化之后它有两部分

prog

type GoProgrammer stuct { //类型
类型 --> }

数据 --> &GoProgrammer{} //具体的实现

　　

自定义类型

　　举例：
1. type IntConvertionFn func(n int) int
2. type MyPoint int

Go语言中接口的实现是不依赖于接口的定义的，是采用DockType的方式

 

　　接口

　　以上是笔者在进行Go语言面向对象方面知识所记录的笔记，可能会有一些凌乱。如果你和我的技术栈类似，可能会对Go中的接口定义以及实现，Duck Type等部分内容感到新奇。可以看看接口这部分的代码：

package interface_test

import (
	"testing"
)

type Programmer interface{
	WriteHelloWorld() string
}

type GoProgrammer struct{

}

func (g *GoProgrammer) WriteHelloWorld() string{
	return "fmt.Println(\"Hello World!\")"
}

/*注意这里，其实p定义的是接口Programmer，而p = new(GoProgrammer)
  是将接口Programmer的具体实现'GoProgrammer'作为p的实例
  这里没有使用传统的【接口定义，接口实现继承自接口定义，具体使用的地方利用接口定义通过容器或别的方式获取接口实现】的传统方法
  而是使用了DuckType.所以DuckType就是指，这个鸟虽然我不知道是什么，但是看起来脚上有蹼，扁嘴，像是鸭子，那么将当它是鸭子。(2333,这是老师的原话)
  对应上面就是接口GoProgrammer所对应的方法‘WriteHelloWorld’与Programmer中定义的方法看起来是一样的，那么我们就当GoProgrammer是Programmer的具体实现
*/

func TestClinet(t *testing.T){
	var p Programmer
	p = new(GoProgrammer)
	t.Log(p.WriteHelloWorld())
}

　　如上述代码，如果是以"C#"之类的语言来看，其实我们在TestClient中是定义了一个Programmer接口的变量p，而p的具体实现则是 “类” GoProgrammer 。但我们观察 “类” GoProgrammer，其实并不像C#中那样要继承自Programmer接口，只是这个方法定义的相同。这就是所谓的“Duck Type”.

 

　　自定义类型

　　而关于自定义类型，其实是可以自定义出一些“复杂”的类型，并利用这写类型来简化一些功能的实现.

package customer_type

import (
	"testing"
	"fmt"
	"time"
)

type IntConv func(op int) int

//通过自定义类型，让程序有更好的可读性，这里自定义了IntCov类型，这个类型是入参为一个int，返回一个int的函数
func timeSpent(inner func(op int) int) IntConv {
	return func(n int) int {
		start := time.Now()
		ret := inner(n)
		fmt.Println("time spent:", time.Since(start).Seconds())
		return ret
	}
}

func slowFun(op int) int{
	time.Sleep(time.Second *1)
	return op
}

func TestFn(t *testing.T) {
	// 计算函数运行时间
	tsSF := timeSpent(slowFun)
	t.Log(tsSF(10))
}

　　如上述代码，我们的自定义类型IntConv其实是一个参数为int，返回值为int的函数。而timeSpent方法的返回值是IntConv类型，作用是计算某个函数的运行时间。如果你仔细观察，其实会发现timeSpent不只返回值，参数其实也是IntConv类型，因此这个方法改写成如下是完全OK的。

func timeSpent(inner IntConv) IntConv {
	return func(n int) int {
		start := time.Now()
		ret := inner(n)
		fmt.Println("time spent:", time.Since(start).Seconds())
		return ret
	}
}

　　

　　而关于行为方法的定义，其实没什么好说的，只是要注意两种方式的不同，为了避免内存复制，尽量使用 " Employee"这种方式.

package encapsulation

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

type Employee struct {
	Id string
	Name string
	Age int
}

func TestCreateEmployeeObj(t *testing.T){
	e := Employee{"0", "Bob", 20}
    e1 := Employee{Name: "Mike", Age: 30}
    e2 := new(Employee) //注意这里返回的引用/指针, 相当于 e:= &Employee{}
    e2.Id = "2" //与其他主要编程语言的差异：通过实例的指针访问成员不需要使用->
    e2.Age = 22
	e2.Name = "Rose"
	t.Log(e)
	t.Log(e1)
	t.Log(e1.Id)
	t.Log(e2)
    //%T 代表输出类型
	t.Logf("e is %T", e) 	//输出 e is encapsulation.Employee
	t.Logf("e2 is %T", e2)  //输出 e2 is *encapsulation.Employee
}

//第一种定义方式在市里对应方法被调用时，实例的成员会进行值复制
func (e Employee) String() 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) String2() 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 TestStructOperations(t *testing.T) {
	e := Employee{"0", "Bob", 20}
	t.Log(e.String())
	fmt.Printf("Address is %x\n", unsafe.Pointer(&e.Name))
	/*
		输出为：
		Address is c000064520
			TestStructOperations: encap_test.go:45: ID:0-Name:Bob-Age:20
		Address is c0000644f0
	*/

	t.Log(e.String2())
	fmt.Printf("Address is %x\n", unsafe.Pointer(&e.Name))
	/*
		输出为：
		Address is c0000644f0
			TestStructOperations: encap_test.go:48: ID:0/Name:Bob/Age:20
		Address is c0000644f0
	*/

	//结论，第一种方式（func (e Employee) String() string）会有更大的内存开销，因为是把结构的数据copy了一份，而第二种方式（func (e *Employee) String2() string）引用了相同的地址。
}