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)引用了相同的地址。
}

  

 

你可能感兴趣的:(Go 其五 到底是不是面向对象语言 -- 封装数据和行为, 接口, 自定义类型)