1 类型系统
1.1给类型添加方法
// 为类型添加方法 type Integer int // 定义一个新类型Integer, 它与int类型相同 func (a Integer) Less(b Integer) bool { // 给Integer类型添加新方法 less, less 方法输入一个整数，返回布尔值 return a < b // 当前整数a调用less方法要传入一个整数b, 如果a<b，返回true }
如果我们想在方法中修改对象，这种时候必须就要用到指针
func (a *Integer) Add (b Integer) { *a += b } func main() { a := Integer(10) a.Add(5) fmt.Println("a is : ", a) }
1.2 值语义和引用语义
b = a b.Modyfy() // 如果a的值收到影响则a为引用类型，否则为值类型
值类型的数据：
- 基本数据类型
- 符合类型： 数组， 结构体， 指针
// 数组想表达引用 var a = [3]int{1,2,3} var b = &a b[1]++ fmt.Println(a, *b)
类似引用类型的数据：
- 数组切片 ： 指向数组的一个区间
- map ： 键值对
- channel ： 执行体间的通信设施
- 接口 ： 对一组满足某个契约的类型的抽象
1.3 结构体
定义矩阵类型
type Rect struct {。 // 定义矩形类型 x, y float64 width, height float64 } func (r *Rect) Area() float64{ //定义成员方法计算矩形面积 return r.width * r.height }
2. 初始化
初始化Rect类型的实例
rect1 := new(Rect) rect2 := &Rect{} rect3 := &Rect{0, 0, 100, 200} rect4 := {100, height:200}
3 匿名组合
type Base struct { // 定义Base类 Name string } func (base *Base) Par() { // Base类实现Par方法和Run方法 fmt.Println("par in Base") } func (base *Base) Run() { fmt.Println("run in base") } type Foo struct { // Foo类继承Base类 Base } func (foo *Foo) Run() { // Foo类重写Run方法，先执行Base的Run方法在执行自己的代码 foo.Base.Run() fmt.Println("run in foo") } func main() { foo := new(Foo) // 实例化一个foo对象，该对象有继承自父类的Par方法和自己的Run方法 foo.Par() foo.Run() }
4.接口
4.1 非侵入式接口
go语言中，一个类只需要实现了接口要求的所有函数，我们就说这个类实现了该接口
例如：
type File struct{ } func (f *File) Read (buf []byte) (n int, err error){ return } func (f *File) Write(buf []byte) (n int, err error) { return } func (f *File) Seek (buf []byte) (n int, err error) { return } func (f *File) Close () (e error) { return } type IFile interface { Read(buf []byte)(n int, err error) } type IReader interface { Read(buf []byte)(n int, err error) Write(buf []byte)(n int, err error) Close(buf []byte)(n int, err error) } func main() { var file1 IFile = new(File) fmt.Println(file1) }
我们定义了一个File类，并实现了Read, Write, Seek, Close等方法。我们有IFile，IReader接口，尽管File类没有从这些接口继承，甚至不知道这些接口的存在，但是File类实现了这些接口，可以进行赋值
4.2 接口赋值
接口赋值的两种情况：
1. 将对象赋值给接口
2. 将一个接口赋值给另一个接口
type Integer1 int func (a Integer1)Less(b Integer1) bool { return a < b } func (a *Integer1)Add(b Integer1) { *a += b } type Lessadd interface { Less(b Integer1) bool Add(b Integer1) } type Less interface { Less(b Integer1) bool } func main() { int1 := Integer1(5)
// 将对象赋值给接口 var ld Lessadd = &int1 //注意这两种情形的区别，因为Integer1类Add方法中我们要改变自身需要传递指针，所以在给接口赋值时也要传递指针。否则编译不通过 var ll Less = int1 // 这里不需要传递指针 fmt.Println(int1, ld.Less(6), ll) }
在go语言中，只要两个接口拥有相同的方法列表，次序不同不要紧，那么他们就是等同的，可以相互赋值
package one type ReaderWriter interface { Read(buf []byte) (n int, err error) Write(buf []byte) (n int, err error) }
package two type IStream interface{ Write(buf []byte)(n int, err error) Read(buf []byte)(n int, err error) }
两个包中分别有两个接口，这两个接口有同样的方法列表，只是次序不同，他们可以相互赋值
func main() { var f1 two.IStream = new(File) var f2 one.ReaderWriter = f1 var f3 two.IStream = f2 fmt.Println(f1, f2, f3) }
接口赋值并不要求两个接口完全的等价，只要A的方法列表B包含在的方法列表中，那么B的对象即可赋值给A接口
package main import "fmt" type Animal interface{ Speaking() string } type Cat struct{} func (c *Cat) Speaking()string { return "喵喵喵" } type Sheep struct {} func (s Sheep)Speaking()string { return "咩咩咩" } type Zhangbin struct {} func (z Zhangbin)Speaking()string { return "汪汪汪" } func main() { var animals = []Animal{&Cat{}, Sheep{}, Zhangbin{}} // 注意这里必须使用指针来实例化cat对象，因为cat的指针有speaking方法，而cat对象本身不具备speaking方法 fmt.Println(animals) }
4.3 接口查询
type Writer interface { Write(buf []byte)(n int, err error) } func main() { var f1 two.IStream = new(File) var f2 one.ReaderWriter = f1 var f3 two.IStream = f2 var f4 Writer = f1 // IStream实现了Write方法，所以可以赋值给Writer //var f5 two.IStream = f4 // 因为Writer没有实现Read方法，所以不能赋值给IStream fmt.Println(f1, f2, f3, f4, f5) }
var file1 Writer = ... if file5, ok := file1.(two.IStream);ok { ... } // if语句查询file1接口指向的对象实例是否实现了two.IStream接口
type File struct {} // 创建File类， 这个类实现了 Write, Read, Close方法 func (f *File)Write() { return } func (f *File)Read() { return } func (f *File)Close() { return } type WR interface{ // WR接口 Write() Read() } type W interface { // W接口 Write() } func main() { var wr1 W = new(File) _, ok := wr1.(WR) // 查看wr1指向的对象是否实现了了WR接口 fmt.Println(wr1, ok) }
查询接口所指向的对象实例是否为某个类型
var file1 Writer = ... if file6, ok := file1.(*File); ok { ... }
4.4 类型查询
type File struct {} func (f *File)Write() { return } func (f *File)Read() { return } func (f *File)Close() { return } type WR interface{ Write() Read() } type W interface { Write() } func main() { var wr1 WR = new(File) _, ok := wr1.(WR) fmt.Println(wr1, ok) switch wr1.(type){ // 类型查询语句 case W: fmt.Println("type is W") case WR: fmt.Println("is WR") } }
4.5 接口组合
type ReadWriter interace { // ReadWriter接口将Reader接口和Writer接口组合起来
Reader
Writer
}
4.6 Any类型
go语言中任何对象实例都满足空接口interface{}, 所以interface{} 看起来像是可以指向任何对象的Any类型
var v1 interface{} = 1 var v2 interface{} = "abc" var v3 interface{} = &v2 var v4 interface{} = struct{ X int }{1} var v5 interface{} = &struct{ X int }{1}
当函数可以接受任意的对象实例时， 我们会将其声明为interface{}
func Printf(fmt string, args ...interface{}) func Println(args ...interface{})