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

Posted on 2017-02-09 17:06 Bill Yuan 阅读(1763) 评论(0) 编辑收藏举报

转自：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，我们刚开始对其一无所知，但可以通过接口查询和类型查询逐步了解它。

刷新页面返回顶部

（评论功能已被禁用）

阅读排行：
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· .NET周刊【3月第1期 2025-03-02】
· [AI/GPT/综述] AI Agent的设计模式综述

智慧 + 毅力 = 无所不能

导航

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

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