写在前面
在学习 Go 语言之前，我自己是有一定的 Java 和 C++ 基础的，这篇文章主要是基于A tour of Go编写的，主要是希望记录一下自己的学习历程，加深自己的理解
Go 语言入门（二）方法和接口
方法
Go 语言中是没有「类」这个概念的，但我们可以为变量定义方法，例如对结构体定义方法，达到类似于类的情况。这里我们先对 Go 中的方法进行一个定义：
什么是方法
「方法」：一类带特殊的接收者参数的函数
对于方法，「接受者参数」位于func关键字和方法名之间：
// 定义一个结构体
type Vertex struct {
X, Y float64
}
// 这里有一个接受者参数 v
func (v Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func main() {
v := Vertex{3, 4}
// 我们可以直接调用 v 的 Abs() 方法
fmt.Println(v.Abs())
}当然，我们也可以直接将接受者 v 作为一个参数传入，那么这就是一个普通的函数了，它们可以实现相同的功能：
func Abs(v Vertex) float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}接受者参数
在上面，我们定义了一个「接受者参数」为结构体Vertex的Abs()方法，我们可以为任意类型的变量声明方法。
这里我们使用type关键字定义一个变量类型「MyFloat」：
type MyFloat float64
func (f MyFloat) Abs() float64 {
if f < 0 {
return float64(-f)
}
return float64(f)
}
func main() {
f := MyFloat(-math.Sqrt2)
fmt.Println(f.Abs())
}注意：只能为在同一包内定义的类型的接收者声明方法，而不能为其它包内定义的类型（包括 int 之类的内建类型）的接收者声明方法。
指针接受者
对于其它语言有所了解的话，我们知道在函数实际上是对参数的拷贝进行操作；又由于「指针」的存在，有「实参」和「形参」之分。
在 Go 中同样有这两者的存在，对于某种类型 T：
如果接受者参数的类型为
T，则是「形参」，函数中的修改不会修改原来的元素；如果接受者参数的类型为
*T，则是「实参」，可以在函数中直接修改它指向的元素，这样能够同步修改原元素。
看下面的例子：
type Vertex struct {
X, Y float64
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func (v *Vertex) Scale(f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func main() {
v := Vertex{3, 4}
// 对于方法，Go 可以自动在值和指针之间转换
v.Scale(10)
fmt.Println(v.Abs())
}当我们定义方法的时候，Go 语言会帮我们自动在值和指针之间；类似于上面，如果方法需求的是一个值，但我们传入的是指针，Go 也能够帮我们自动进行转换。但是使用函数时不会自动转换。
因此我们可以直接使用v.Scale(10)，这里的执行结果为 50；如果我们将Scale()方法的接受者参数改为v Vertext，那么Scale函数中传入的是形参，只是对拷贝进行修改，运行后 v 的元素值不变，执行结果为 5。
通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。（我们会在下面明白为什么。）
接口
不同于 Java 中的接口，在 Go 中，接口是一种抽象类型。它就像一种「约定」，所有的接口类型都能引用其提供的所有方法。
「接口类型」：由一组方法签名定义的集合
type Abser interface {
Abs() float64
}如何使用接口
如果一个类型实现了一个接口要求的所有方法，那么这个类型就实现了这个接口。
我们看下面代码的例子：
package main
import (
"fmt"
"math"
)
// 接口 Abser，包含方法 Abs()
type Abser interface {
Abs() float64
}
// MyFloat 实现了 Abs() 方法
type MyFloat float64
// 无需使用 implements 关键字
func (f MyFloat) Abs() float64 {
if f < 0 {
return float64(-f)
}
return float64(f)
}
// *Vertex 实现了 Abs() 方法
type Vertex struct {
X, Y float64
}
func (v *Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func main() {
var a Abser
f := MyFloat(-math.Sqrt2)
v := Vertex{3, 4}
a = f // a MyFloat 实现了 Abser
a = &v // a *Vertex 实现了 Abser
// 这里被注释的语句会报错
// v 是一个 Vertex（而不是 *Vertex），没有实现 Abser。
// a := v
fmt.Println(a.Abs())
fmt.Println(b.Abs())
}上例代码中，类型MyFloat和类型*Vertex都实现了Abs()方法，因此可以给接口类型Abser赋值；而Vertex未实现，如果用它来赋值则会报错。
同时，我们还可以从上面代码中看到，在实现Abser接口的方法时，我们并没有像 Java 中实现接口一样用implements关键字显式声明，这样也鼓励程序员对接口要有明确的定义。
接口值
「接口」作为一种抽象类型，它也是一个值，可以像其它值一样进行传递，也就是可以作为参数或是返回值。
下面我们定义一个接口I，类型*T和M实现了这个接口，然后我们将接口I作为参数传入函数desribe()中：
package main
import (
"fmt"
"math"
)
type I interface {
M()
}
// 实现 I 的类型 *T
type T struct {
S string
}
func (t *T) M() {
fmt.Println(t.S)
}
// 实现 I 的类型 F
type F float64
func (f F) M() {
fmt.Println(f)
}
func main() {
var i I
i = &T{"Hello"}
describe(i)
i.M()
i = F(math.Pi)
describe(i)
i.M()
}
// 打印传入接口的值和类型
func describe(i I) {
fmt.Printf("(%v, %T)\n", i, i)
}运行后，输出如下：
(&{Hello}, *main.T)
Hello
(3.141592653589793, main.F)
3.141592653589793可以看到，传入的接口参数会以底层的类型和值进行打印。
底层值为 nil 的接口值
如果接口的具体值为nil，然后调用这个接口的方法，在一些语言中（如 Java）将会触发「空指针异常」，但在 Go 中则能够正确打印出 nil。
注意：保存了nil具体值的接口自身并不为nil。
我们使用前例的接口I和类型*T，作出测试如下：
1.「接口具体值」为 nil
func main() {
var i I
var t *T
i = t
describe(i)
i.M()
}执行结果如下：
(<nil>, *main.T)
<nil>可以看到，在调用 i 的方法M()时，Go 能够正常地打印出<nil>值而不会报错。
2.「接口」自身为 nil
func main() {
var i I
describe(i)
i.M()
}执行上面的语句，describe()方法能够打印出(<nil>, <nil>)，表示接口自身为nil，自然值也为nil；而在对接口 i 进行方法调用时则会抛出异常（因为 Go 不知道应该调用哪个具体方法的类型）。
空接口
「空接口」：定义了 0 个方法的接口
interface{}空接口有什么作用呢？它能够接受任何类型的值（因为空接口对方法没有要求），因此我们可以用空接口来处理未知类型的值。例如，fmt.Print可接受类型为interface{}的任意数量的参数。
下面的例子可以有效地帮我们进行理解：
func main() {
var i interface{}
describe(i)
// 运行结果： (<nil>, <nil>)
i = 42k
describe(i)
// 运行结果： (42, int)
i = "hello"
describe(i)
// 运行结果： (hello, string)
}
func describe(i interface{}) {
fmt.Printf("(%v, %T)\n", i, i)
}上面的describe()函数便以空接口作为参数，因此可以接受任何类型（包括 nil）的值。
类型断言
「类型断言」：提供了访问接口值底层具体值的方式。
t := i.(T)该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。
若 i 并未保存 T 类型的值，该语句就会触发一个恐慌panic。
为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。
t, ok := i.(T)这个「双赋值」和映射中的很相似：
若 i 保存了一个 T，那么
t将会是其底层值，而ok为 true。否则，
ok将为false而 t 将为 T 类型的零值，程序并不会产生恐慌。
下面我们用一个例子总结一下接口的「类型断言」：
package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string)
fmt.Println(s)
// 执行结果： hello
s, ok := i.(string)
fmt.Println(s, ok)
// 执行结果： hello true
f, ok := i.(float64)
fmt.Println(f, ok)
// 执行结果： 0 false
f = i.(float64)
fmt.Println(f)
// 报错(panic)
}类型选择
「类型选择」：一种按顺序从几个类型断言中选择分支的结构。
Go 中套用swtich语句，能够针对给定接口值所存储的值的类型进行比较：
switch v := i.(type) {
case T:
// v 的类型为 T
case S:
// v 的类型为 S
default:
// 没有匹配，v 与 i 的类型相同
}类型选择中的声明与类型断言i.(T)的语法相同，只是具体类型T被替换成了关键字type。
此选择语句判断接口值 i 保存的值类型是 T 还是 S。
在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。
在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。
注意：「类型选择」只对接口类型适用，我们不能对其他类型的值来使用。
常用接口：Stringer
fmt包中定义的Stringer是最普遍的接口之一，它类似于 Java 中的toString()方法，我们可以通过实现它来自定义在如何输出调用者。
fmt包中具体定义如下：
type Stringer interface {
String() string
}下面我们通过实现Stringer接口，来自定义输出结构体Person的值：
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("Person: %v (%v years)", p.Name, p.Age)
}
func main() {
a := Person{"Arthur Dent", 42}
z := Person{"Zaphod Beeblebrox", 9001}
fmt.Println(a)
fmt.Println(z)
}输出结果如下：
Person: Arthur Dent (42 years)
Person: Zaphod Beeblebrox (9001 years)常用接口：error
Go 中用error值来表示错误状态。与fmt.Stringer类似，error类型是一个内建接口：
type error interface {
Error() string
}与fmt.Stringer类似，fmt包在打印错误值时也会满足我们实现（或者默认的）error，因此我们可以通过实现Error()方法来自定义需要打印的错误信息。
那么，如何获取是否产生了错误呢？Go 中用的还是熟悉的「双赋值」.
通常函数会返回一个error值，调用的它的代码可以判断这个错误是否等于nil来进行错误处理。
error为 nil 时，表示执行成功，没有错误error不为 nil 时，表示执行失败，产生了错误
i, err := strconv.Atoi("42")
if err != nil {
fmt.Printf("couldn't convert number: %v\n", err)
return
}
fmt.Println("Converted integer:", i)下面我们用一个例子来试试error接口，我们实现一个开方的函数，并让传入参数为负数的时候产生错误：
package main
import (
"fmt"
"math"
)
type ErrNegativeSqrt float64
func (e ErrNegativeSqrt) Error() string {
// 注意：这里要 float64(e)，不然会产生死循环
return fmt.Sprint(float64(e))
}
func Sqrt(x float64) (float64, error) {
if x < 0 {
return 0, ErrNegativeSqrt(x)
}
return math.Sqrt(x), nil
}
func main() {
fmt.Println(Sqrt(2))
fmt.Println(Sqrt(-2))
}运行结果如下：
1.4142135623730951 <nil>
0 -2这里需要解释一下为什么在Error()方法中不能直接打印e而要打印float64(e)：
因为fmt包在输出时也会试图匹配error，e 变量通过实现Error()的接口函数成为了error类型，在fmt.Sprint(e)时就会调用e.Error()来输出错误的字符串信息，也就是下面的代码是等价的：
func (e MyError) Error() string {
return fmt.Printf(e)
}
// e 是一个 error，上面的语句实际上是这样的
// 这也就产生来死循环
func (e MyError) Error() string {
return fmt.Printf(e.Error())
}常用接口：Reader
io包指定了io.Reader接口，它表示从数据流的末尾进行读取。
Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。
io.Reader接口有一个Read()方法：
func (T) Read(b []byte) (n int, err error)Read()方法做了两件事：
用数据填充给定的字节切片；
返回填充的「字节数」和「错误值」。
在遇到数据流的结尾时，它会返回一个io.EOF错误。
示例代码创建了一个strings.Reader并以每次 8 字节的速度读取它的输出：
package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("Hello, Reader!")
b := make([]byte, 8)
for {
n, err := r.Read(b)
fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
fmt.Printf("b[:n] = %q\n", b[:n])
if err == io.EOF {
break
}
}
}执行结果如下：
// 第一次循环
n = 8 err = <nil> b = [72 101 108 108 111 44 32 82]
b[:n] = "Hello, R"
// 第二次循环
n = 6 err = <nil> b = [101 97 100 101 114 33 32 82]
b[:n] = "eader!"
// 第三次循环，遇到 EOF 异常，表示读取完毕，结束循环
n = 0 err = EOF b = [101 97 100 101 114 33 32 82]
b[:n] = ""我们可以通过「A tour of Go」的在线练习来练习关于 Reader 接口的使用。
下面我们实现一个Reader类型，它产生一个 ASCII 字符 'A' 的无限流。
package main
import "golang.org/x/tour/reader"
type MyReader struct{}
// TODO: 给 MyReader 添加一个 Read([]byte) (int, error) 方法
func (r MyReader) Read(b []byte) (int, error) {
// 1.填充字节切片
b[0] = 'A'
// 2.返回填充的字符数和错误值
return 1, nil
}
func main() {
reader.Validate(MyReader{})
}常用接口：Image
image包定义了Image接口：
package image
type Image interface {
ColorModel() color.Model
Bounds() Rectangle
At(x , y int) color.Color
}注意: Bounds()方法的返回值「Rectangle」实际上是一个image.Rectangle，它在image包中声明。
color.Color和color.Model类型也是接口，但是通常因为直接使用预定义的实现image.RGBA和image.RGBAModel而被忽视了。这些接口和类型由image/color包定义。这里可以了解更多关于image包的信息。