Merge commit '7587f3bc775860e49f9345afca6ae5e3916cbb30' into ja

Author: ernix

ebook/02.6.md

@@ -5,13 +5,13 @@ Go语言里面设计最精妙的应该算interface，它让面向对象，内容
 ### 什么是interface
 简单的说，interface是一组method的组合，我们通过interface来定义对象的一组行为。
 
-我们前面一章最后一个例子中Student和Employee都能Sayhi，虽然他们的内部实现不一样，但是那不重要，重要的是他们都能`say hi`
+我们前面一章最后一个例子中Student和Employee都能SayHi，虽然他们的内部实现不一样，但是那不重要，重要的是他们都能`say hi`
 
 让我们来继续做更多的扩展，Student和Employee实现另一个方法`Sing`，然后Student实现方法BorrowMoney而Employee实现SpendSalary。
 
-这样Student实现了三个方法：Sayhi、Sing、BorrowMoney；而Employee实现了Sayhi、Sing、SpendSalary。
+这样Student实现了三个方法：SayHi、Sing、BorrowMoney；而Employee实现了SayHi、Sing、SpendSalary。
 
-上面这些方法的组合称为interface(被对象Student和Employee实现)。例如Student和Employee都实现了interface：Sayhi和Sing，也就是这两个对象是该interface类型。而Employee没有实现这个interface：Sayhi、Sing和BorrowMoney，因为Employee没有实现BorrowMoney这个方法。
+上面这些方法的组合称为interface(被对象Student和Employee实现)。例如Student和Employee都实现了interface：SayHi和Sing，也就是这两个对象是该interface类型。而Employee没有实现这个interface：SayHi、Sing和BorrowMoney，因为Employee没有实现BorrowMoney这个方法。
 ### interface类型
 interface类型定义了一组方法，如果某个对象实现了某个接口的所有方法，则此对象就实现了此接口。详细的语法参考下面这个例子
 
@@ -51,7 +51,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 	// Employee重载Human的Sayhi方法
 	func (e *Employee) SayHi() {
 		fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
-			e.company, e.phone) //Yes you can split into 2 lines here.
+			e.company, e.phone) //此句可以分成多行
 	}
 
 	//Student实现BorrowMoney方法
@@ -83,7 +83,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 		SpendSalary(amount float32)
 	}
 
-通过上面的代码我们可以知道，interface可以被任意的对象实现。我们看到上面的Men interface被Human、Student和Employee实现。同理，一个对象可以实现任意多个interface，例如上面的Student实现了Men和YongChap两个interface。
+通过上面的代码我们可以知道，interface可以被任意的对象实现。我们看到上面的Men interface被Human、Student和Employee实现。同理，一个对象可以实现任意多个interface，例如上面的Student实现了Men和YoungChap两个interface。
 
 最后，任意的类型都实现了空interface(我们这样定义：interface{})，也就是包含0个method的interface。
 
@@ -92,7 +92,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 
 因为m能够持有这三种类型的对象，所以我们可以定义一个包含Men类型元素的slice，这个slice可以被赋予实现了Men接口的任意结构的对象，这个和我们传统意义上面的slice有所不同。
 
-让我们来看一下下面这个例子
+让我们来看一下下面这个例子:
 
 	package main
 	import "fmt"
@@ -115,7 +115,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 		money float32
 	}
 
-	//Human实现Sayhi方法
+	//Human实现SayHi方法
 	func (h Human) SayHi() {
 		fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
 	}
@@ -128,7 +128,7 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 	//Employee重载Human的SayHi方法
 	func (e Employee) SayHi() {
 		fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
-			e.company, e.phone) //Yes you can split into 2 lines here.
+			e.company, e.phone)
 		}
 
 	// Interface Men被Human,Student和Employee实现
@@ -162,15 +162,15 @@ interface类型定义了一组方法，如果某个对象实现了某个接口
 		//定义了slice Men
 		fmt.Println("Let's use a slice of Men and see what happens")
 		x := make([]Men, 3)
-		//T这三个都是不同类型的元素，但是他们实现了interface同一个接口
+		//这三个都是不同类型的元素，但是他们实现了interface同一个接口
 		x[0], x[1], x[2] = paul, sam, mike
 
 		for _, value := range x{
 			value.SayHi()
 		}
 	}
 
-通过上面的代码，你会发现interface就是一组抽象方法的集合，它必须由其他非interface类型实现，而不能自我实现， go 通过interface实现了duck-typing:即"当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。
+通过上面的代码，你会发现interface就是一组抽象方法的集合，它必须由其他非interface类型实现，而不能自我实现， Go通过interface实现了duck-typing:即"当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子"。
 
 ### 空interface
 空interface(interface{})不包含任何的method，正因为如此，所有的类型都实现了空interface。空interface对于描述起不到任何的作用(因为它不包含任何的method），但是空interface在我们需要存储任意类型的数值的时候相当有用，因为它可以存储任意类型的数值。它有点类似于C语言的void*类型。
@@ -273,9 +273,9 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 			}
 		}
 
-	是不是很简单啊，同时你是否注意到了多个ifs里面，还记得我前面介绍流程里面讲过，if里面允许初始化变量。
+	是不是很简单啊，同时你是否注意到了多个if里面，还记得我前面介绍流程时讲过，if里面允许初始化变量。
 
-	也许你注意到了，我们断言的类型越多，那么ifelse也就越多，所以才引出了下面要介绍的switch。
+	也许你注意到了，我们断言的类型越多，那么if else也就越多，所以才引出了下面要介绍的switch。
 - switch测试
 
 	最好的讲解就是代码例子，现在让我们重写上面的这个实现
@@ -323,7 +323,7 @@ interface的变量可以持有任意实现该interface类型的对象，这给
 	这里有一点需要强调的是：`element.(type)`语法不能在switch外的任何逻辑里面使用，如果你要在switch外面判断一个类型就使用`comma-ok`。
 
 ### 嵌入interface
-Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。
+Go里面真正吸引人的是它内置的逻辑语法，就像我们在学习Struct时学习的匿名字段，多么的优雅啊，那么相同的逻辑引入到interface里面，那不是更加完美了。如果一个interface1作为interface2的一个嵌入字段，那么interface2隐式的包含了interface1里面的method。
 
 我们可以看到源码包container/heap里面有这样的一个定义
 
@@ -333,7 +333,7 @@ Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Str
 		Pop() interface{} //a Pop elements that pops elements from the heap
 	}
 
-我们看到sort.Interface其实就是嵌入字段，把sort.Interface的所有method给隐式的包含进来了。也就是下面三个方法
+我们看到sort.Interface其实就是嵌入字段，把sort.Interface的所有method给隐式的包含进来了。也就是下面三个方法：
 
 	type Interface interface {
 		// Len is the number of elements in the collection.
@@ -345,7 +345,7 @@ Go里面真正吸引人的是他内置的逻辑语法，就像我们在学习Str
 		Swap(i, j int)
 	}
 
-另一个例子就是io包下面的 io.ReadWriter ，他包含了io包下面的Reader和Writer两个interface。
+另一个例子就是io包下面的 io.ReadWriter ，它包含了io包下面的Reader和Writer两个interface：
 
 	// io.ReadWriter
 	type ReadWriter interface {
@@ -374,7 +374,7 @@ Go语言实现了反射，所谓反射就是动态运行时的状态。我们一
 	fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
 	fmt.Println("value:", v.Float())
 
-最后，反射的话，那么反射的字段必须是可修改的，我们前面学习过传值和传引用，这个里面也是一样的道理，反射的字段必须是可读写的意思是，如果下面这样写，那么会发生错误
+最后，反射的话，那么反射的字段必须是可修改的，我们前面学习过传值和传引用，这个里面也是一样的道理。反射的字段必须是可读写的意思是，如果下面这样写，那么会发生错误
 
 	var x float64 = 3.4
 	v := reflect.ValueOf(x)