Golang的面向对象编程

　　　　　　　　　　Golang的面向对象编程

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

　　Go语言的面向对象之所以与C++,Java以及(较小程度上的)Python这些语言不同，是因为它不支持继承，仅支持聚合(也叫组合)和嵌入。接下来我们一起来学习一下Go语言的面向对象编程吧。

 

一.面向对象编程思想

　　面向对象编程刚流行的时候，继承是它首先被吹捧的最大优点之一。但是历经几十载的实践之后，事实证明该特性也有些明显的缺点，特别是当用于维护大系统时。Go语言建议的是面向接口编程。

　　常见的编程方式:
　　　　面向过程(面向函数式编程):
　　　　　　典型代表:
　　　　　　　　C语言
　　　　　　优点:
　　　　　　　　流程清晰,代码易读。
　　　　　　缺点:
　　　　　　　　耦合度太高，不利于项目迭代。

　　　　面向对象编程:
　　　　　　典型代表:
　　　　　　　　C++,Java,Python,Golang等。
　　　　　　优点:
　　　　　　　　解耦。
　　　　　　缺点:
　　　　　　　　代码抽象度过高，不易读。

　　面向对象三要素:
　　　　封装
　　　　　　组装:将数据和操作组装到一起。
　　　　　　隐藏数据:对外只暴露一些接口，通过接口访问对象。比如驾驶员使用汽车，不需要了解汽车的构造细节，只需要知道使用什么部件怎么驾驶就行，踩了油门就能跑，可以不了解其中的机动原理。
　　　　继承
　　　　　　多复用，继承来的就不用自己写了。
　　　　　　多继承少修改，OCP(Open-closed Principle)，使用继承来改变，来体现个性。
　　　　多态
　　　　　　面向对象编程最灵活的地方，动态绑定。
 
　　与其它大部分使用聚合和继承的面向对象语言不同的是，Go语言只支持聚合(也叫做组合)和嵌入。

 

二.结构体的定义及初始化

package main

import (
    "fmt"
)

type Person struct {
    Name   string
    Age    int
    Gender string
}

type Student struct {
    Person //通过匿名组合的方式嵌入了Person的属性。
    Score  float64
}

type Teacher struct {
    Person //通过匿名组合的方式嵌入了Person的属性。
    Course string
}

type Schoolmaster struct {
    Person   //通过匿名组合的方式嵌入了Person的属性。
    CarBrand string
}

func main() {
    /**
    第一种初始化方式:先定义后赋值
    */
    s1 := Student{}
    s1.Name = "Jason Yin"
    fmt.Println(s1)
    fmt.Printf("%+v\n\n", s1) //"+v表示打印结构体的各个字段"

    /**
    第二种初始化方式:直接初始化
    */
    s2 := Teacher{Person{"尹正杰", 18, "boy"}, "Go并发编程"}
    fmt.Println(s2)
    fmt.Printf("%+v\n\n", s2)

    /**
    第三种赋值方式:初始化赋值部分字段
    */
    s3 := Schoolmaster{CarBrand: "丰田", Person: Person{Name: "JasonYin最强王者"}}
    fmt.Println(s3)
    fmt.Printf("%+v\n", s3)
}

 

三.结构体的属性继承及变量赋值

package main

import (
    "fmt"
)

type Animal struct {
    Age int
}

type People struct {
    Animal
    Name   string
    Age    int
    Gender string
}

type IdentityCard struct {
    IdCardNO    int
    Nationality string
    Address     string
    Age         int
}

/*
    此时的Students以及是多重继承
*/
type Students struct {
    IdentityCard
    People //多层继承
    Age    int
    Score  int
}

func main() {
    /**
    如果子类和父类存在同名的属性,那么以就近原则为准
    */
    s1 := Students{
        Score: 150,
        IdentityCard: IdentityCard{
            IdCardNO:    110105199003072872,
            Nationality: "中华人民共和国",
            Address:     "北京市朝阳区望京SOHO",
            Age:         8,
        },
        People: People{Name: "Jason Yin", Age: 18, Animal: Animal{Age: 20}},
        Age:    27,
    }

    /**
    如果子类和父类存在同名的属性(如果父类还继承了其它类型，我们称之为多层继承)，那么就以就近原则为准;
    但是如果一个子类如果继承自多个父类(我们称之为多重继承),且每个字段中都有相同的字段,此时我们无法直接在子类调用该属性;
    */
    fmt.Printf("学生的年龄是:[%d]\n", s1.Age)
    s1.Age = 21
    fmt.Printf("学生的年龄是:[%d]\n\n", s1.Age)

    //给People类的Age赋值
    fmt.Printf("People的年龄是:[%d]\n", s1.People.Age)
    s1.People.Age = 5000
    fmt.Printf("People的年龄是:[%d]\n\n", s1.People.Age)

    //给IdentityCard类的Age赋值
    fmt.Printf("IdentityCard的年龄是:[%d]\n", s1.IdentityCard.Age)
    s1.IdentityCard.Age = 80
    fmt.Printf("IdentityCard的年龄是:[%d]\n", s1.IdentityCard.Age)
}

 

四.匿名组合对象指针使用案例

package main

import (
    "fmt"
    "time"
)

type Vehicle struct {
    Brand string
    Wheel byte
}

type Car struct {
    Vehicle
    Colour string
}

type Driver struct {
    *Car
    DrivingTime time.Time
}

func main() {
    /**
    对象指针匿名组合的第一种初始化方式:
        定义时直接初始化赋值。
    */
    d1 := Driver{&Car{
        Vehicle: Vehicle{
            Brand: "丰田",
            Wheel: 4,
        },
        Colour: "红色",
    }, time.Now(),
    }
    //打印结构体的详细信息,注意观察指针对象
    fmt.Printf("%+v\n", d1)
    //我们可以直接调用对象的属性
    fmt.Printf("品牌:%s,颜色:%s\n", d1.Brand, d1.Colour)
    fmt.Printf("驾驶时间:%+v\n\n", d1.DrivingTime)
    time.Sleep(1000000000 * 3)

    /**
    对象指针匿名组合的第二种初始化方式:
        先声明，再赋值
    温馨提示:
        遇到指针的情况一定要避免空(nil)指针,未初始化的指针默认值是nil,可以考虑使用new函数解决。
    */
    var d2 Driver
    /**
    由于Driver结构体中有一个对象指针匿名组合Car,因此我们需要使用new函数申请空间。
    */
    d2.Car = new(Car)
    d2.Brand = "奔驰"
    d2.Colour = "黄色"
    d2.DrivingTime = time.Now()
    fmt.Printf("%+v\n", d2)
    fmt.Printf("品牌:%s,颜色:%s\n", d2.Brand, d2.Colour)
    fmt.Printf("驾驶时间:%+v\n", d1.DrivingTime)
}

 

五.结构体成员方法案例

package main

import (
    "fmt"
)

//定义一个结构体
type Lecturer struct {
    Name string
    Age  uint8
}

//我们为Lecturer结构体封装Init成员方法
func (l *Lecturer) Init() {
    l.Name = "Jason Yin"
    l.Age = 20
}

/**
我为Lecturer结构体起一个别名
我们可以为Instructor类型添加成员方法,
通过别名和成员方法为原有类型赋值新的操作
*/
type Instructor Lecturer

/**
温馨提示:
    (1)我们为一个结构体创建成员方法时，如果成员方法有接收者,需要考虑以下两种情况:
        1>.如果这个接收者是对象的时候，是值传递;
        2>.如果这个接收者是对象指针，是引用传递;
    (2)只要函数接收者不同,哪怕函数名称相同，也不算同一个函数哟;
    (3)不管接收者变量名称是否相同,只要类型一致(包括对象和对象指针),那么我们就认为接收者是相同的,这时候不允许出现相同名称函数;
    (4)给指针添加方法的时候，不允许给指针类型添加操作(因为Go语言中指针类型是只读的);
*/
func (i *Instructor) Init() {
    i.Name = "尹正杰"
    i.Age = 18
}

func main() {

    var (
        l Lecturer
        i Instructor
    )

    //可以使用对象调用成员方法
    i.Init()
    fmt.Printf("%+v\n\n", i)

    //可以用对象指针调用成员方法
    (&l).Init()
    fmt.Printf("%+v\n", l)
}

 

六.结构体的方法继承和重写

package main

import (
    "fmt"
)

type Father struct {
    Name string
    Age  int
}

func (f *Father) Init() {
    f.Name = "成龙"
    f.Age = 66
}

//定义父类的Eat成员方法
func (f *Father) Eat() {
    fmt.Println("Jackie Chan is eating...")
}

//重写父类的Eat成员方法
func (s *Son) Eat() {
    fmt.Println("FangZuming is eating...")
}

//我们让Son类继承Ｆather父类
type Son struct {
    Father //匿名组合能够继承父类的属性和方法
    Score  int
}

func main() {
    var s Son
    s.Init()
    fmt.Printf("%+v\n", s)
    s.Eat()
    s.Name = "房祖名"
    s.Age = 38
    s.Score = 100
    fmt.Printf("%+v\n", s)
}

 

七.方法值和方法表达式

package main

import (
    "fmt"
)

/**
定义函数，函数的返回值是函数类型
*/
func CallBack(a int) func(b int) int {
    return func(c int) int {
        fmt.Println("调用了CallBack这个回调函数...")
        return a + c
    }
}

type BigData struct {
    Name string
}

func (this *BigData) Init() {
    this.Name = "Hadoop"
}

func (this *BigData) PrinfInfo() {
    fmt.Printf("%v是大数据生态圈的基石。\n", this.Name)
}

func (this BigData) SetInfoValue() {
    fmt.Printf("SetInfoValue : %p,%v\n", &this, this)
}

func (this *BigData) SetInfoPointer() {
    fmt.Printf("SetInfoPointer : %p,%v\n", this, this)
}

func main() {

    /**
      调用回调函数的返回值为函数类型
    */
    result := CallBack(10)
    fmt.Printf("result的类型是:[%T],result的值是:[%v]\n", result, result)
    res1 := result(20) //我们对返回的函数再次进行调用
    fmt.Printf("res1的类型是:[%T],res1的值是:[%d]\n\n", res1, res1)

    var hadoop BigData
    hadoop.Init()            //调用hadoop的初始化方法
    info := hadoop.PrinfInfo //我们可以声明一个函数变量info,我们称之为方法表达式

    /**
      我们对info函数变量进行调用，这样可以起到隐藏调用者hadoop对象的效果哟~(类似于回调函数的调用效果)
      方法值可以隐藏调用者,我们称为隐式调用。
    */
    info()

    /**
    　　方法表达式可以显示调用调用，必须传递方法调用者对象，在实际开发中很少使用这种方式，我们了解即可。
    */

    elk := BigData{"Elastic Stack"}
    fmt.Printf("main:%p,%v\n\n", &elk, elk)
    s1 := (*BigData).SetInfoPointer
    s1(&elk) //显示把接收者传递过去
    s2 := (BigData).SetInfoValue
    s2(elk) //显示把接收者传递过去
}

 

八.面向接口编程(多态案例)

　　博主推荐阅读:
　　　　https://www.cnblogs.com/yinzhengjie2020/p/12542435.html