看go代码，非常考验对go语言的理解程度。觉得费解的地方，肯定是有不熟悉的语法。

3，接口与实现

type Error interface {
	Error() string
	Stacktrace() Error
	Trace(offset int, format string, args ...interface{}) Error
	Data() interface{}
}

type A struct {
　　data  interface{}
　　msgtraces []msgtraceItem
　　stacktrace []uintptr
}
function newA(data interface{}) {
　　return &A{
　　　　data:  data
　　　　msgtraces: nil
　　　　stacktrace: nil
　　}
}

func (a A) Error() string {
　　return fmt.Sprintf("#{err}");
}

func (a A) Stacktrace() Error {
　　return a; // 因为a是实现Error接口的结构体的实例
}

func (a A) Trace() Error {
　　return a;
}

func (a A) Data() interface{} {
　　return a.data;
}

3，接口

Go 语言的接口设计是非侵入式的，接口编写者无须知道接口被哪些类型实现。而接口实现者只需知道实现的是什么样子的接口，但无须指明实现哪一个接口。编译器知道最终编译时使用哪个类型实现哪个接口，或者接口应该由谁来实现。

a := PhoneConnecter{"PhoneConnecter"}
a.Connect()
Disconnect(a)

func Disconnect(usb USB) {
    if pc, ok := usb.(PhoneConnecter); ok {
        fmt.Println("Disconnect", pc.name)
        return
    }
    fmt.Println("Unknown device")
}
// 改造为空接口
func Disconnect(usb interface{}) {
    switch v := usb.(type)
    case PhoneConnecter
        fmt.Println("Disconnect", v.name)
    defult:
        fmt.Println("Unknown device")
}

接口转换可以降级。

比如 type struct TVConnect {

　　name string

}

是不能强制转换为USB，因为没有实现USB。

1，结构体

结构体是不同数据类型的集合，聚合数据类型。数组是相同数据类型的集合。

go中没有类，继承，只保留了结构体及组合。

初始化的5种方法：

type struct Person {

　　name string

　　age int

　　sex string

　　address string

}

方法1：

var p1 Person

p2.name = ""

fmt.Printf(p2);

方法2：

p3: = Person{}

p3.name = ""

fmt.Printf(p3);

方法3：//常用

p4: = Person{

　　name: xx

}

fmt.Printf(p4);

方法4：

p5 := Person{"", } // 顺序不能写错

方法5：New // 指针类型

p1 := Person{"1", }

p2 := p1 // 深拷贝

p2.name = "2"

//结论是p1, p2两个空间。修改的时候两个互不干预。

var pp1 * Person

pp1 = &p1 // 浅拷贝

fmt.PrintLn(*pp1)

pp1.name = "3"

fmt.PrintLn(pp1) // &{}

fmt.PrintLn(p1) // {}

pp2 := new(Person) //指针类型

// (*pp2).name

pp2.name // 简写

结构体的指针

值类型：int，float，bool，string，array，struct

引用类型：slice，map，function，pointer

但常用指针： new ()，不是nil，空指针，指向了新分配的类型的内存空间，里面存储的零值。

结构体是值类型：

p1 := Person{name:"", age:"", sex:"", address:"北京市"}

p2 := p1

p1.name = "newName"

p1变了，但p2没变。

默认是深copy，如果想浅copy，定义指针。

pp1 := &p1

pp1.name = "王五"; //这样原始数据p1就被修改了。

内置的pp2:=new(Person)

结构体是值类型，往往借助于指针来操作（通过new），new之后并不是nil，而是开辟了一段内存空间，存储零值。

newStruct是构造函数

结构体嵌套

package main
import "fmt"
type A struct {
    ax, ay int
}
type B struct {
    A
    bx, by float32
}
func main() {
    b := B{A{1, 2}, 3.0, 4.0}
    fmt.Println(b.ax, b.ay, b.bx, b.by) // 嵌入结构体的成员，可以通过外部结构体的实例直接访问。
    fmt.Println(b.A)
}

 匿名结构体，匿名字段（一个结构体的字段没有字段名）

匿名结构体类比匿名函数，平常不常用。

 s2:= struct {

name string

age int

} {

name:"李四"

age:"19"

}

匿名结构体字段

type Worker struct {

string

int

}

w2:=Work{"li", 32}

w2.string

w2.int

匿名字段类型不能重复，否则冲突。

还可以把另一个结构体作为匿名字段。

结构体嵌套

最初始的理解是对的。

type Book struct {

bookName string

price float64

}

type Student struct {

name string

age int

book Book

}

b1 := Book{}

b1.bookName = "西游记"

b1.price = 45.8

s1 := Student{}

s1.name = ""

s1.age = 

s1.book = b1;

s1.book.bookName

s1.book.price

也可以

s2:=Student{name:"", age: 19, book: Book{bookName:"", price:89.,7}}

实际结构体的嵌套需要定义指针，而不是值复制。

book :=  Book{bookName:"", price:89.,7}

s2:=Student{name:"", age: 19, book: &book}

go中的面向对象

用结构体嵌套来实现类的继承。

提升字段：子结构体是匿名字段的时候。可以直接使用子结构体的字段，不需要多点一次子结构体的名字。

注：代码里非常常用。

总结：嵌套分为两种情况：一种是模拟继承，is a子类是特殊的父类。可以直接访问子类的字段。

k另一种情况是：模拟面向对象的聚合关系，has a，一个类拥有另一个类。不能直接访问子类的字段。