Golang 入门系列(四)浅谈Golang中的面向对象

2024-03-03 19:20:28

感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18318.html

大家都知道 golang 语法中主要的是结构体和函数，并没有类的概念，那么如果想让golang搞一搞面向对象编程该怎么实现呢？

下面就围绕着封装、继承、多态和抽象这4个面向对象编程的基本特征说一说Golang语言是如何实现面向对象编程。

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

java或者C# 里面，结构体（struct）是不能有成员函数的。然而，Go语言中的结构体（struct）可以有"成员函数"。方法可以被添加到结构体中，类似于类的实现。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

学过java或C# 的人应该都知道，面向对象的三个基本特征：封装、继承和多态。他们的定义我这里就不细说了。下面，就直接看看 go 语言下的面向对象是怎样实现的吧。

封装特性
=======

Golang区分公有属性和私有属性的机制就是方法或属性是否首字母大写，如果方法的首字母是大写的说明是公有方法，可以被其他方法调用，如果首字母小写则是私有方法，不能被调用。

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

基类指针可以指向任意派生类的对象，并在运行时绑定最终调用的方法的过程被称为多态。多态是运行时特性，而继承则是编译时特征，也就是说，继承关系在编译时就已经确定了，而多态则可以实现运行时的动态绑定。

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

以上，就把Go语言如何实现面向对象的简单介绍了一下，其实跟java和C# 等也都差不多，大家可以比较着来看。总结的来说就是：Go没有类，而是松耦合的类型、方法对接口的实现。

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

最后

GO语言中的面向对象

其实GO并不是一个纯面向对象编程语言。它没有提供类（class）这个关键字，只提供了结构体（struct）类型。

所以，我个人觉得Go 语言在的面向对象其实更简单，也更容易理解。

如何实现面向对象

封装特性
=======

下面我们定义一个Person类型如下：

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
func (person *Person) setName(name string) {  
    person.name = name  
}  
  
func (person *Person) GetInfo() {  
    fmt.Println(person.name)  
}  
  
func main() {  
    p := Person{"zhangsan"}  
    p.setName("lisi")  
    p.GetInfo()  
}

继承特性
=======

GO语言的继承方式采用的是匿名组合的方式：Woman 结构体中包含匿名字段Person，那么Person中的属性也就属于Woman对象。

package main  
  
import "fmt"  
  
type Person struct {  
    name string  
}  
  
type Woman struct {  
    Person  
    sex string  
}  
  
func main() {  
    woman := Woman{Person{"wangwu"}, "女"}  
    fmt.Println(woman.name)  
    fmt.Println(woman.sex)  
}

多态特性
=======

下面这个例子：Woman和Man都是实现了吃东西的行为。所以，我们可以把它们共同的方法提炼出来定义一个抽象的Eater 接口：

package main  
  
import "fmt"  
  
type Eater interface {  
    Eat()  
}  
  
type Man struct {  
}  
  
type Woman struct {  
}  
  
func (man *Man) Eat() {  
    fmt.Println("Man Eat")  
}  
  
func (woman *Woman) Eat() {  
    fmt.Println("Woman Eat")  
}  
  
func main() {  
    var e Eater  
  
    woman := Woman{}  
    man := Man{}  
  
    e = &woman  
    e.Eat()  
  
    e = &man  
    e.Eat()  
}

码农公寓

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

GO语言中的面向对象

如何实现面向对象

最后

推荐阅读：

相关文章