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

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 组合之指针

func (a *Integer) Less(b Integer)bool {

    *a-=10

    return *a<b

type Int int

func (a *Int) LessIne(b Int)bool{

   var aa int=10

   a=Integer(aa)

3、go中不存在this指针,通过语法糖显式传递对象

在Go语言中没有隐藏的this指针”这句话的含义是：

 方法施加的目标（也就是“对象” ）显式传递，没有被隐藏起来；

 方法施加的目标（也就是“对象” ）不需要非得是指针，也不用非得叫this。 

4、用type定以后的别名类型就是新类型了 只有强制转换才能使用

   a=Integer(aa)  //不强制转换会编译出错的

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 b = &a

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中的组合精华  创建结构体指针 和为 结构体扩充成员函数的时候.....传递 值类型和指针类型的区别

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

     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、普通的组合继承 ...........................以及组合指针继承 以及覆盖 和函数 成员名字冲突 

//通过值类型继承

//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")

      obj:=new(Sub)

      obj.Name="张三"

      obj.Age=15

      obj.showName()

      obj.showAge()

///通过指针类型继承

    *Base  

    //由于使用指针继承所以 我们要设置匿名组合模板的内存对象 地址

      obj.Base=&Base{}

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

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

/////Go语言会为每一个成员函数 自动生成对应的函数  比如 func(a *A) 会自动生成 func (a A) .....

///反过来则不行 因为 func (a A)这时候传递的是形参  (&a).xx()改变的是 参数 副本 而不是 外部类

///非侵入式接口

////接口 和实现完全分析 减少耦合

///实现方只负责实现  接口方只负责封装自己的借口就行...实现方甚至不知道 有这个接口的存在 这就是 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()!")

     birdObj:=Bird{}

     var iFly IFly=&birdObj

     iFly.fly()

     var iSay ISay=birdObj

     iSay.say()

13、接口之间是可以相互赋值的

实现了相同方法的接口可以相互赋值,如果接口B是A非超集,那么  A可以赋值为B

对象不可以被赋值为接口 ,繁殖接口可以被赋值为实现了 某些方法的对象 或者包含他方法的 接口对象

type IFly1 interface{

type ISay1 interface{

     ////接口之间的赋值

     var iFly1 IFly1=iFly

     iFly1.fly()

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

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

func (pBird Bird) String() string{

   return "aaaaaaaaaa"

     fmt.Println(birdObj)

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

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，我们刚开始对其一无所知，但可以通

过接口查询和类型查询逐步了解它。