Go(三)面向对象

封装数据和行为

数据封装

结构定义

type Employee struct {
    Id string
    Name string
    Age int
}

field后面没有逗号

实例创建及初始化

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

检验一下类型

    t.Logf("e is %T", e)
    t.Logf("e2 is %T", e2)

=== RUN TestCreateEmployeeObj
--- PASS: TestCreateEmployeeObj (0.00s)
func_test.go:79: e is fun_test.Employee
func_test.go:80: e2 is *fun_test.Employee
PASS

行为（方法）定义

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

两种方式定义行为：

// 第一种定义方式在实例对应方法被调用时，实例成员会进行值复制
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)
}

接口

定义交互协议

Java

如果把AClient和接口A打包在一起为packageA，Almpl打包为B

那么A和B 是相互依赖的

一般是接口独立在一个package中，解决循环依赖

Go

Duck Type式接口实现

没有显示表明实现接口，只是实现了接口的方法WriteHelloWorld()

type Programmer interface {
    WriteHelloWorld() string
}

type GoProgrammer struct {

}

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

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

=== RUN TestClient
--- PASS: TestClient (0.00s)
func_test.go:117: fmt.println("Hello World")
PASS

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

1.接口为非入侵性，实现不依赖于接口定义

2.所以接口的定义可以包含在接口使用者包内

接口变量

自定义类型

1.type IntConvertionFn func(n int) int

2.type MyPoint int

func timeSpent(inner func(op int)int) func(opt int) int  {
    return func(n int) int {
        start := time.Now()
        ret := inner(n)

        fmt.Println("time spent:", time.Since(start).Seconds())
        return ret
    }
}

参数特别长，自定义一个类型

type IntConv func(op int) int 

func timeSpent(inner IntConv) func(opt int) int  {
    return func(n int) int {
        start := time.Now()
        ret := inner(n)

        fmt.Println("time spent:", time.Since(start).Seconds())
        return ret
    }
}

扩展和复用

争议最大的一块

Go不支持继承

Java代码

class Pet {
    public void speak(){
        System.out.print("...");
    }
    public void speakTo(String name){
        this.speak();
        System.out.println(name);
    }
}

class Dog extends Pet{
    @Override
    public void speak(){
        System.out.println("Wang!");
    }
}

public class InheritanceTest{

    private void makePetSpeak(Pet p){
        p.speak();
        System.out.println("\nPet speak.");
    }

    @Test
    public void  testSubClassAccess(){
        Pet aDog = new Dog();
        aDog.speak();
        aDog.speakTo("Chao");
    }
    @Test
    public void testLSP(){
        Dog aDog = new Dog();
        makePetSpeak(aDog);
    }
}

makePetSpeak()的参数是Pet类型，接收子类Dog类型是可以的，且会调用Dog的speak

在Go中做同样的事情

使用内嵌

没有继承

dog只能再重写个不同的SpeakTo方法

type Pet struct {

}

func (p *Pet)Speak()  {
	fmt.Print("...")
}

func (p *Pet)SpeakTo(host string)  {
	p.Speak()
	fmt.Println(" ", host)
}

type Dog struct {
	p *Pet
}

func (d *Dog)Speak()  {
	fmt.Println("Wang")
}

func (d *Dog)SpeakTo(host string)  {
	d.Speak()
	//d.p.SpeakTo(host)
   fmt.Println(" ", host)
}

func TestDog(t *testing.T){
   dog := new(Dog)
   dog.SpeakTo("chao")

}

　　

多态

想支持多态，要使用接口

空接口与断言

1.空接口可以表示任何类型

2.通过断言来将空接口转换为定制类型

v, ok := p.(int) // ok=true 时则为转换成功

func DoSomething(p interface{})  {
    if i, ok := p.(int); ok{
        fmt.Println("Integer", i)
        return
    }
    if s, ok := p.(string); ok{
        fmt.Println("string", s)
        return
    }
    fmt.Println("Unknow Type")
}

func TestEmptyInterfaceAssertion(t *testing.T)  {
    DoSomething(10)
    DoSomething("10")
}

=== RUN TestEmptyInterfaceAssertion
Integer 10
string 10
--- PASS: TestEmptyInterfaceAssertion (0.00s)
PASS

用switch可以简化上面代码

func DoSomething(p interface{})  {
    switch v := p.(type) {
    case int:
        fmt.Println("Integer", v)
    case string:
        fmt.Println("String", v)
    default:
        fmt.Println("Unknown Type")
    }
}

func TestEmptyInterfaceAssertion(t *testing.T)  {
    DoSomething(10)
    DoSomething("10")
}

Go接口最佳实践