网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

【Golang 基础】Go 语言面向对象

2020-06-10 02:47:52 admin 779

## Go 语言的面向对象

Go 语言的面向对象非常简单， **仅支持封装，不支持继承和多态。继承和多态是在接口中实现的。**

因此 Go 语言中没有 `class`，而是通过 `struct（结构体）` 对相同类型或不同类型的数据进行封装。

* 通过 `type <structName> struct {}` 格式定义结构体；

type User struct {
        Name     string
        Age      int
        IsActive bool
    }

* 定义后的结构体就可以作为类型使用；

hvkcoder := User{Name: "hvkcoder", Age: 18, IsActive: true}
    fmt.Println(hvkcoder) // {hvkcoder 18 true}

或

hvkcoder := User{"hvkcoder", 18, true}
    fmt.Println(hvkcoder) // {hvkcoder 18 true}

* 通过 `结构体.成员名称` 访问结构体中的对象；

fmt.Println(hvkcoder.Name) // hvkcoder

* 结构体是值类型，因此支持比较运算符的使用；

hvkcoder := User{Name: "hvkcoder", Age: 18, IsActive: true}
    jason := User{Name: "jason", Age: 20, IsActive: true}
        
    fmt.Println(hvkcoder == jason) // false

* 由于结构体是值类型，因此需要向函数传递 **结构体指针** ，才能去改变结构体中的值；

package main
    
    import "fmt"
    
    type User struct {
        Name     string
        Age      int
        IsActive bool
    }
    
    func setName(user *User,name string){
        user.Name = name
    }
    
    func main(){
        test := User{Name: "jason", Age: 18, IsActive: true}
        fmt.Println(test.Name) // jason
        setName(&test, "hvkcoder")
        fmt.Println(test.Name) // hvkcoder
    }

* 结构体也可以嵌套

package main
    
    import "fmt"
    
    type Address struct {
        city, town string
    }
    
    type User struct {
        Name     string
        Age      int
        IsActive bool
        UAddress Address
    }
    
    func main() {
        user := User{
            Name:     "hvkcoder",
            Age:      18,
            IsActive: false,
            UAddress: Address{"北京", "海淀"},
        }
    
        fmt.Println(user) // {hvkcoder 18 false {北京 海淀}}
    }

### Go 语言中的方法

Go 语言中的方法从某种意义上来说就是函数的语法糖，`receiver` 作为方法的第一个强制类型参数传入，这也就是 `Method Value` 与
`Method Expression` 的区别。

package main
    
    import "fmt"
    
    type Student struct {
        Name string
    }
    
    // receiver 定义结构方法
    func (student Student) SayHi(){
        fmt.Println("Hello! My name's", student.Name)
    }
    
    func main(){
    
        student := Student{"hvkcoder"}
    
        // 使用 Method Value 方式调用方法
        student.SayHi() // Hello! My name's hvkcoder
        
        // 使用 Method Expression 方法调用方法
        (Student).SayHi(student) // Hello! My name's hvkcoder
    }

* 既然说了 Go 语言中的方法实际上就是函数的语法糖，因此想通过方法去改变结构体的值，仍然需要传递指针；

package main
    
    import "fmt"
    
    type User struct {
        Name     string
        Age      int
        IsActive bool
    }
    
    func (user *User) setName(name string){
        user.Name = name
    }
    
    func main(){
        test := User{Name: "jason", Age: 18, IsActive: true}
        fmt.Println(test.Name) // jason
        
        test.setName("hvkcoder")
        fmt.Println(test.Name) // hvkcoder
    }

* Go 中不存在方法重载；
  * 如果外部结构和内嵌结构存在同名方法，则优先调用外部结构的方法；

### 使用 Go 实现一个二叉排序树

package algorithm
    
    import "fmt"
    
    // 二叉树节点结构
    type Node struct {
        Value       int
        Left, Right *Node
    }
    
    // 添加二叉排序树节点
    func (node *Node) Insert(newNode *Node) {
    
        // 根据二叉排序树的特点，左子树的所有节点均小于根节点，右子树的所有节点均大于根节点
        if node.Value > newNode.Value {
            // 判断左子树是否有值
            if node.Left == nil {
                node.Left = newNode
            } else {
                node.Left.Insert(newNode)
            }
        } else {
            // 判断右子树是否有值
            if node.Right == nil {
                node.Right = newNode
            } else {
                node.Right.Insert(newNode)
            }
        }
    }
    
    // 前序遍历二叉排序树节点
    func (node *Node) PreorderTraversal(){
        if node != nil{
            fmt.Printf("%d ", node.Value)
            node.Left.PreorderTraversal()
            node.Right.PreorderTraversal()
        }
    }
    
    // 中序遍历二叉排序树节点
    func (node *Node) InorderTraversal(){
        if node != nil{
            node.Left.InorderTraversal()
            fmt.Printf("%d ", node.Value)
            node.Right.InorderTraversal()
        }
    }
    
    // 后序遍历二叉排序树节点
    func (node *Node) PostorderTraversal(){
        if node != nil{
            node.Left.PostorderTraversal()
            node.Right.PostorderTraversal()
            fmt.Printf("%d ", node.Value)
        }
    }
    
    
    // 创建二叉排序树
    func NewBinarySortTree(treeNode []int) *Node{
        var root *Node
        if len(treeNode) > 0 {
            for _,value := range treeNode {
                node := Node{Value:value}
                if root == nil {
                    root = &node
                }else {
                    root.Insert(&node)
                }
            }
        }
        return root
    }

package main
    
    import (
        "./algorithm"
        "fmt"
    )
    
    func main() {
        // 声明一个二叉树节点 Slice
        treeNode := []int{8, 3, 10, 1, 4, 13, 16, 14}
        // 创建二叉排序树
        binarySortTree := algorithm.NewBinarySortTree(treeNode)
        // 使用 前序方式遍历 二叉树
        binarySortTree.PreorderTraversal() // 8 3 1 4 10 13 16 14
        fmt.Println()
    
        // 使用 中序方式遍历 二叉树
        binarySortTree.InorderTraversal() // 1 3 4 8 10 13 14 16
        fmt.Println()
    
        // 使用 后序方式遍历 二叉树
        binarySortTree.PostorderTraversal() // 1 4 3 14 16 13 10 8
    }

转载文章，原文链接：【Golang 基础】Go 语言面向对象

关键字词golang go

分享到：

上一篇：【Golang 基础】Go 语言的接口

下一篇：golang 基础（23）channel

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

【Golang 基础】Go 语言面向对象

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

【Golang 基础】Go 语言 面向对象

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

【Golang 基础】Go 语言面向对象