Go语言面组合式向对象编程基础总结

转自：http://blog.csdn.net/yue7603835/article/details/44282823

Go语言的面向对象编程简单而干净,通过非侵入式接口模型,否定了C/C++ Java C#等传统面向对象编程语言的复杂度的必要性,我们发现在Go中即使简单的组合也能达到传统面向对象语言的效果,而且耦合度非常低,按照Go的作者之一也就是C语言的作者之一说的一句话:Go是更好的C语言。
1、Go中任意类型Any即 interface{}类型,也就是空接口,可以赋值为任意类型
2、可以为其他类型 内置类型 不包括指针类型添加相应的方法 但是注意的一点是一定要用别名。。进行包装
记住想要 为类型 添加新的方法 那么请把类型定义别名,别名和原来的类型就不一样了成了新类型
在Go中只能对非本地类型添加方法......也就是int不能添加方法 需要 type Int int 才可以为Int添加方法

package main
import(
"fmt"
)
type Integer int
func (a Integer) Less(b Integer)bool {
return a<b
}
func main(){
var a Integer=1
r:=a.Less(2)
fmt.Println(r)
}
/////用法2 组合之指针
package main
import(
"fmt"
)
type Integer int
func (a *Integer) Less(b Integer)bool {
*a-=10
return *a<b
}

type Int int
func (a *Int) LessIne(b Int)bool{
return *a<b
}
func main(){
var a Integer=1
var aa int=10
a=Integer(aa)
r:=a.Less(2)
fmt.Println(r)
}

3、go中不存在this指针,通过语法糖显式传递对象
在Go语言中没有隐藏的this指针”这句话的含义是：
 方法施加的目标（也就是“对象” ）显式传递，没有被隐藏起来；
 方法施加的目标（也就是“对象” ）不需要非得是指针，也不用非得叫this。
4、用type定以后的别名类型就是新类型了 只有强制转换才能使用

package main
import(
"fmt"
)
type Integer int
func (a Integer) Less(b Integer)bool {
return a<b
}
func main(){
var a Integer=1
var aa int=10
a=Integer(aa)  //不强制转换会编译出错的
r:=a.Less(2)
fmt.Println(r)
}

5、Go中的值语义和引用
channel map本质是指针 因为复制他们没有意义 ........数组切片 []type 本质上是值类型 interface接口非常重要
值语义和引用语义的差别在于赋值，比如下面的例子：

b = a
b.Modify()

如果b的修改不会影响a的值，那么此类型属于值类型。如果会影响a的值，那么此类型是引用
类型。
Go语言中的大多数类型都基于值语义，包括：
 基本类型，如byte、int、bool、float32、float64和string等；
 复合类型，如数组（array） 、结构体（struct）和指针（pointer）等。
Go语言中类型的值语义表现得非常彻底。我们之所以这么说，是因为数组。
如果读者之前学过C语言，就会知道C语言中的数组比较特别。通过函数传递一个数组的时
候基于引用语义， 但是在结构体中定义数组变量的时候基于值语义 （表现在为结构体赋值的时候，
该数组会被完整地复制） 。
Go语言中的数组和基本类型没有区别，是很纯粹的值类型，例如：

var a = [3]int{1, 2, 3}
var b = a
b[1]++
fmt.Println(a, b)

该程序的运行结果如下：
[1 2 3] [1 3 3]。
这表明b=a赋值语句是数组内容的完整复制。要想表达引用，需要用指针：

var a = [3]int{1, 2, 3}
var b = &a
b[1]++
fmt.Println(a, *b)

该程序的运行结果如下：
[1 3 3] [1 3 3]
这表明b=&a赋值语句是数组内容的引用。变量b的类型不是[3]int，而是*[3]int类型。
Go语言中有4个类型比较特别，看起来像引用类型，如下所示

数组切片：指向数组（array）的一个区间。
 map：极其常见的数据结构，提供键值查询能力。
 channel：执行体（goroutine）间的通信设施。
 接口（interface） ：对一组满足某个契约的类型的抽象。
但是这并不影响我们将Go语言类型看做值语义。下面我们来看看这4个类型。
数组切片本质上是一个区间，你可以大致将[]T表示为：

type slice struct {
first *T
len int
cap int
}

因为数组切片内部是指向数组的指针，所以可以改变所指向的数组元素并不奇怪。数组切片
类型本身的赋值仍然是值语义。
map本质上是一个字典指针，你可以大致将map[K]V表示为：

type Map_K_V struct {

// ...
}

type map[K]V struct {
impl *Map_K_V
}

基于指针，我们完全可以自定义一个引用类型，如：

type IntegerRef struct {
impl *int
}

channel和map类似，本质上是一个指针。将它们设计为引用类型而不是统一的值类型的原因
是，完整复制一个channel或map并不是常规需求。
同样，接口具备引用语义，是因为内部维持了两个指针，示意为：

type interface struct {
data *void
itab *Itab
}

接口在Go语言中的地位非常重要。关于接口的内部实现细节，在后面的高阶话题中我们再
细细剖析。
7、Go语言中的结构体 组合非继承
Go语言的结构体（struct）和其他语言的类（class）有同等的地位，但Go语言放弃了包括继
承在内的大量面向对象特性，只保留了组合（composition）这个最基础的特性。
组合甚至不能算面向对象特性，因为在C语言这样的过程式编程语言中，也有结构体，也有
组合。组合只是形成复合类型的基础。
上面我们说到，所有的Go语言类型（指针类型除外）都可以有自己的方法。在这个背景下，
Go语言的结构体只是很普通的复合类型，平淡无奇。例如，我们要定义一个矩形类型：

type Rect struct {
x, y float64
width, height float64
}

然后我们定义成员方法Area()来计算矩形的面积：

func (r *Rect) Area() float64 {
return r.width * r.height
}

可以看出， Go语言中结构体的使用方式与C语言并没有明显不同。
8、Go中的组合精华 创建结构体指针 和为 结构体扩充成员函数的时候.....传递 值类型和指针类型的区别

package main
import "fmt"
type Rect struct{
x,y float64
width,height float64
}
///如果写成rct Rect 那么内部的修改不会影响到 外部结构
///如果写成rct*Rect那么内部的修改会影响到外部结构的值 这就是 指针的效果
func (rct *Rect)Area() float64{
rct.width=1000 ///也可以(*rct).width=1000一样
return rct.width*rct.height
}
func main(){
rct:=new(Rect)
//对于结构体指针,...调用方法和值类型一样直接.唯一的区别是 作为参数传递的时候 传递的是地址 值可以被修改
//所以进行组合的时候就有两种选择
// 可以写成 var rct*Rect=&Rect{}
//也可以写成 var rct Rect=Rect{}
//var rct *Rect=new(Rect)
//也可以写成 var rct Rect=Rect{1,2,3,4}
rct.width=10.0
rct.height=10.0
area:=rct.Area()
fmt.Println(area)
fmt.Println(rct.width)
}

9、普通的组合继承 ...........................以及组合指针继承 以及覆盖 和函数 成员名字冲突

//通过值类型继承
package main
import "fmt"
//Go中继承属于匿名组合 .......可以从对象继承 也可以从指针匿名继承...
//匿名继承会去掉包名,,,所以不能同时继承类名相同的  即使不在同一个包中
type Base struct{
Name string
Age  uint8
}
///为Base结构体组合进去两个函数
func (pBase*Base) showName(){
fmt.Println("Age",pBase.Name)
}
func (pBase*Base) showAge(){
fmt.Println("Age",pBase.Age)
}
//创建Sub结构体
type Sub struct{
//组合Base修改内存模型
//匿名组合进Base 对于调用者是不知道的
//即使我们覆盖了 Base的方法 但是我们还是可以通过xxx.Base.xxx()调用基类的方法的
//如果是*Base我们需要在调用处手动添加new Base 否则运行会出错的
Base
}
func (pSub*Sub) showName(){
fmt.Println("Before Sub ShowName")
pSub.Base.showName()
fmt.Println("After Sub ShowName")
}
func main(){
obj:=new(Sub)
obj.Name="张三"
obj.Age=15
obj.showName()
obj.showAge()
}
///通过指针类型继承
package main
import "fmt"
//Go中继承属于匿名组合 .......可以从对象继承 也可以从指针匿名继承...
//匿名继承会去掉包名,,,所以不能同时继承类名相同的  即使不在同一个包中
type Base struct{
Name string
Age  uint8
}
///为Base结构体组合进去两个函数
func (pBase*Base) showName(){
fmt.Println("Age",pBase.Name)
}
func (pBase*Base) showAge(){
fmt.Println("Age",pBase.Age)
}
//创建Sub结构体
type Sub struct{
//组合Base修改内存模型
//匿名组合进Base 对于调用者是不知道的
//即使我们覆盖了 Base的方法 但是我们还是可以通过xxx.Base.xxx()调用基类的方法的
*Base
}
func (pSub*Sub) showName(){
fmt.Println("Before Sub ShowName")
pSub.Base.showName()
fmt.Println("After Sub ShowName")
}
func main(){
obj:=new(Sub)
//由于使用指针继承所以 我们要设置匿名组合模板的内存对象 地址
obj.Base=&Base{}
obj.Name="张三"
obj.Age=15
obj.showName()
obj.showAge()
}

10、Go语言的可见性 权限是包一级的,包外的不能访问包内的小写开头成员......包内无所谓

11、Go的非侵入式接口 和实现

/////Go语言会为每一个成员函数 自动生成对应的函数  比如 func(a *A) 会自动生成 func (a A) .....
///反过来则不行 因为 func (a A)这时候传递的是形参  (&a).xx()改变的是 参数 副本 而不是 外部类
package main
import "fmt"
///非侵入式接口
////接口 和实现完全分析 减少耦合
///实现方只负责实现  接口方只负责封装自己的借口就行...实现方甚至不知道 有这个接口的存在 这就是 Go的 非侵入式接口的特点
type IFly interface{
fly()
}
type ISay interface{
say()
}
type Bird struct{

}
//由于匿名传递进来的是指针类型 所对于接口的赋值必须是 指针
func (pBird*Bird) fly(){
fmt.Println("i am a bird, i can fly()!")
}
//由于匿名传递的不是指针类型是值类型 所以接口赋值 可以不是指针而是值
func (pBird Bird) say(){
fmt.Println("i am a bird, i can say()!")
}
func main(){
birdObj:=Bird{}

var iFly IFly=&birdObj
iFly.fly()
var iSay ISay=birdObj
iSay.say()
}

13、接口之间是可以相互赋值的
实现了相同方法的接口可以相互赋值,如果接口B是A非超集,那么 A可以赋值为B
对象不可以被赋值为接口 ,繁殖接口可以被赋值为实现了 某些方法的对象 或者包含他方法的 接口对象

package main
import "fmt"
///非侵入式接口
////接口 和实现完全分析 减少耦合
///实现方只负责实现  接口方只负责封装自己的借口就行...实现方甚至不知道 有这个接口的存在 这就是 Go的 非侵入式接口的特点
type IFly interface{
fly()
}
type ISay interface{
say()
}
type IFly1 interface{
fly()
}
type ISay1 interface{
say()
}
type Bird struct{

}
//由于匿名传递进来的是指针类型 所对于接口的赋值必须是 指针
func (pBird*Bird) fly(){
fmt.Println("i am a bird, i can fly()!")
}
//由于匿名传递的不是指针类型是值类型 所以接口赋值 可以不是指针而是值
func (pBird Bird) say(){
fmt.Println("i am a bird, i can say()!")
}
func main(){
birdObj:=Bird{}

var iFly IFly=&birdObj
iFly.fly()
var iSay ISay=birdObj
iSay.say()
////接口之间的赋值
var iFly1 IFly1=iFly
iFly1.fly()
}

14、Go中的值类型非常的彻底 数组都是值类型

15、关于给类型添加String()方法 相当于 其他语言的toString 用于打印输出

package main
import "fmt"
///非侵入式接口
////接口 和实现完全分析 减少耦合
///实现方只负责实现  接口方只负责封装自己的借口就行...实现方甚至不知道 有这个接口的存在 这就是 Go的 非侵入式接口的特点
type IFly interface{
fly()
}
type ISay interface{
say()
}
type IFly1 interface{
fly()
}
type ISay1 interface{
say()
}
type Bird struct{

}
//由于匿名传递进来的是指针类型 所对于接口的赋值必须是 指针
func (pBird*Bird) fly(){
fmt.Println("i am a bird, i can fly()!")
}
//由于匿名传递的不是指针类型是值类型 所以接口赋值 可以不是指针而是值
func (pBird Bird) say(){
fmt.Println("i am a bird, i can say()!")
}
func (pBird Bird) String() string{
return "aaaaaaaaaa"
}
func main(){
birdObj:=Bird{}

var iFly IFly=&birdObj
iFly.fly()
var iSay ISay=birdObj
iSay.say()
////接口之间的赋值
var iFly1 IFly1=iFly
iFly1.fly()
fmt.Println(birdObj)
}

16、接口的组合 就是把多个接口组合到一起......接口中只有函数没有属性

type IFly interface{
fly()
}
type ISay interface{
say()
}
type IFly1 interface{
fly()
}
type ISay1 interface{
say()
}
type ISay_Fly interface{
ISay
IFly
}

17、接口查询 obj,ok=val.(Interface) 返回查询的接口 并且返回查询结果
x.(type) 获取类型 只能在switch中用
x.(OterTypeInterface) 判断x是否是指定接口类型 返回指定接口对象,和查询结果
在Go语言中，还可以更加直截了当地询问接口指向的对象实例的类型，例如：

var v1 interface{} = ...
switch v := v1.(type) {
case int:    // 现在v的类型是int
case string: // 现在v的类型是string
...
}

就像现实生活中物种多得数不清一样，语言中的类型也多得数不清，所以类型查询并不经常使用。它更多是个补充，需要配合接口查询使用，例如：

type Stringer interface {
String() string
}

func Println(args ...interface{}) {
for _, arg := range args {
switch v := v1.(type) {
case int:                        // 现在v的类型是int
case string:                     // 现在v的类型是string
default:
if v, ok := arg.(Stringer); ok { // 现在v的类型是Stringer
val := v.String()
// ...
} else {
// ...
}
}
}
}

当然，Go语言标准库的Println()比这个例子要复杂很多，我们这里只摘取其中的关键部分进行分析。对于内置类型，Println()采用穷举法，将每个类型转换为字符串进行打印。对于更一般的情况，首先确定该类型是否实现了String()方法，如果实现了，则用String()方法将其转换为字符串进行打印。否则，Println()利用反射功能来遍历对象的所有成员变量进行打印。是的，利用反射也可以进行类型查询，详情可参阅reflect.TypeOf()方法的相关文档。此外，
18、 Any类型 对于匿名结构体赋值给任意类型 没法取出 具体每个匿名结构体的内部属性 只能前部打印 通过系统默认的String()函数

var any1 interface{}=1
var any2 interface{}="b"
var any3 interface{}=struct{x ,y string}{"hello,world","aaaaa"}
fmt.Println(any1,any2,any3)

由于Go语言中任何对象实例都满足空接口interface{}，所以interface{}看起来像是可以指向任何对象的Any类型，如下：

var v1 interface{} = 1       // 将int类型赋值给interface{}
var v2 interface{} = "abc"   // 将string类型赋值给interface{}
var v3 interface{} = &v2     // 将*interface{}类型赋值给interface{}
var v4 interface{} = struct{ X int }{1}
var v5 interface{} = &struct{ X int }{1}

当函数可以接受任意的对象实例时，我们会将其声明为interface{}，最典型的例子是标准库fmt中PrintXXX系列的函数，例如：

func Printf(fmt string, args ...interface{})
func Println(args ...interface{})
...

总体来说，interface{}类似于COM中的IUnknown，我们刚开始对其一无所知，但可以通过接口查询和类型查询逐步了解它。
由于Go语言中任何对象实例都满足空接口interface{}，所以interface{}看起来像是可以指向任何对象的Any类型，如下：

var v1 interface{} = 1       // 将int类型赋值给interface{}
var v2 interface{} = "abc"   // 将string类型赋值给interface{}
var v3 interface{} = &v2     // 将*interface{}类型赋值给interface{}
var v4 interface{} = struct{ X int }{1}
var v5 interface{} = &struct{ X int }{1}

当函数可以接受任意的对象实例时，我们会将其声明为interface{}，最典型的例子是标准库fmt中PrintXXX系列的函数，例如：

func Printf(fmt string, args ...interface{})
func Println(args ...interface{})
...

总体来说，interface{}类似于COM中的IUnknown，我们刚开始对其一无所知，但可以通过接口查询和类型查询逐步了解它。