【Go基础】结构体、方法封装、结构体内嵌、接口

男娘i 2022-09-03 14:25 211阅读 0赞

# 结构体、方法封装、结构体内嵌、接口 #

*  结构体、方法封装、结构体内嵌、接口
    
     *  结构体
        
         *  定义结构体
         *  结构体变量的声明、赋值
     *  方法封装
     *  结构体的组合与内嵌
        
         *  组合
         *  内嵌（即：继承）
     *  接口
     *  相关资料

--------------------

## 结构体 ##

### 定义结构体 ###

> 在很多语言中，面向对象编程需要使用"class"来定义类，在Go语言中并没有"class"关键字。早Go语言中，星耀面向对象编程，习惯上会先自定义一个类型，这个类型一般会以结构体的形式呈现：
> 
>     type TypeName struct { 
>      fieldName1 T1
>      fieldName2 T2
>      ......
>     }
> 
> 其中，`TypeName`是自定义的类型名称；结构体由多个成员变量组成。
> 
> 注：特别的，**如果希望自己开发的结构体作为公共包被其他包导入，那么需要将结构体首字母大写，同样的，结构体内的字段和函数希望被外部包访问也需要将首字母大写**。

*  示例：

type Person struct { 
    	name string // 姓名
    	age int // 姓名
    	sex string // 性别
    	fight int // 体重
    }

### 结构体变量的声明、赋值 ###

> 总的来说，分为两种情况：
> 
>  *  声明时赋值
>  *  声明后赋值

*  示例：

import (
    	"fmt"
    )
    
    func main() { 
    	// 方式一：声明时赋值
    	p := Person{ 
    		"张三",
    		18,
    		"man",
    		80, // 注意：当"}"与最后一个值在同一行时不需要",", 否者需要加","
    	}
    	fmt.Println(p)
    
    	// 方式二：声明后赋值
    	p2 := Person{ }
    	p2.name = "张三"
    	p2.age = 18
    	p2.sex = "man"
    	p2.fight = 80
    	fmt.Println(p2)
    }
    
    type Person struct { 
    	name string // 姓名
    	age int // 姓名
    	sex string // 性别
    	fight int // 体重
    }

输出：

{ 张三 18 man 80}
    { 张三 18 man 80}

## 方法封装 ##

> 格式：
> 
>     func (obj ObjT) funcName([params list]) [return list] { 
>     // ......
>     }
> 
> **方法与函数的区别：**
> 
>  *  声明时，方法需要指定调用者的类型，函数无需指定
>  *  调用时，方法只有对应的对象才可以调用，函数没有限制，所有类型的对象都可以调用函数

示例：

import (
    	"fmt"
    )
    
    func main() { 
    	p1 := Wealth{ 100}
    	p2 := Wealth{ 100}
    	// 函数，求财富差
    	fmt.Println(diff(p1, p2))
    
    	// 方法，求财富差
    	fmt.Println(p1.diff(p2))
    }
    
    type Wealth struct { 
    	money float64
    }
    
    // 函数
    func diff(thisObj, otherObj Wealth) float64 { 
    	return thisObj.money - otherObj.money
    }
    
    // 方法
    func (thisObj Wealth) diff(otherObj Wealth) float64 { 
    	return thisObj.money - otherObj.money
    }

输出：

12
    12

## 结构体的组合与内嵌 ##

> 从效果上来看，**go的内嵌，类似于java的继承**

### 组合 ###

> 所谓组合，即：一个结构体内部的某些成员变量，是由其他结构体组成的

示例：

import (
    	"fmt"
    )
    
    func main() { 
    	p1 := Person{ 100}
    	p2 := SuperMan{ p: p1}
    	fmt.Printf("%+v\n", p2)
    
    	// 调用成员变量p的方法
    	p2.p.setAge(18)
    	fmt.Printf("%+v\n", p2)
    }
    
    type Person struct { 
    	Age int
    }
    
    type SuperMan struct { 
    	p Person
    }
    
    func (p Person) setAge(age int) { 
    	p.Age = age
    }

输出：

{ p:{ Age:100}}
    { p:{ Age:100}}

### 内嵌（即：继承） ###

> 格式：
> 
>     type MyStructOne struct { 
>      fieldName1 T1
>      fieldName2 T2
>      ......
>      MyStructTwo
>     }
> 
> 如上所示，我们说结构体`MyStructOne`内嵌（继承了）了结构体`MyStructTwo`

示例：

import (
    	"fmt"
    )
    
    func main() { 
    	sunWuKong := SuperMan{ 
    		skill: "七十二变",
    	}
    	fmt.Printf("%+v\n", sunWuKong)
    
    	// 直接调用内嵌类的属性或者方法
    	sunWuKong.name = "孙悟空"
    	sunWuKong.setAge(18)
    	fmt.Printf("%+v\n", sunWuKong)
    }
    
    type Person struct { 
    	name string
    	age  int
    }
    
    type SuperMan struct { 
    	skill  string
    	Person // 内嵌了结构体Person
    }
    
    func (p *Person) setAge(age int) { 
    	p.age = age
    }

输出：

{ skill:七十二变 Person:{ name: age:0}}
    { skill:七十二变 Person:{ name:孙悟空 age:18}}

## 接口 ##

> 格式：
> 
>     type InterfaceName interface { 
>      funcName1([params list]) [return list]
>      funcName2([params list]) [return list]
>      funcName3([params list]) [return list]
>      ......
>     }

示例：

import "fmt"func main() { 	/* * ---------------- 使用接口前 */	c1 := Cat{ color: "橘黄色"}	d1 := Dog{ color: "白色"}	fmt.Println(c1.Sleeping("邓沙利文"))	fmt.Println(d1.Sleeping("邓沙利文"))	/* * ---------------- 使用接口后 */	c2 := Cat{ color: "橘黄色"}	d2 := Dog{ color: "白色"}	// 声明接口变量 var animal Animal // 指定接口实现者为c2 animal = &c2 fmt.Println(animal.Sleeping("邓沙利文")) // 指定接口实现者为d2 animal = &d2 fmt.Println(animal.Sleeping("邓沙利文"))}type Dog struct { color string}type Cat struct { color string}// 定义接口type Animal interface { Sleeping(master string) string}// 接口实现1func (dog Dog) Sleeping(master string) string { return master + "的" + dog.color + "的狗子, 正在睡觉..."}// 接口实现2func (cat Cat) Sleeping(master string) string { return master + "的" + cat.color + "的猫咪, 正在睡觉..."}

输出：

邓沙利文的橘黄色的猫咪, 正在睡觉...
    邓沙利文的白色的狗子, 正在睡觉...
    邓沙利文的橘黄色的猫咪, 正在睡觉...
    邓沙利文的白色的狗子, 正在睡觉...

--------------------

**^\_^ 整理自《Go语言区块链应用开发从入门到精通》高野 编著**

**^\_^ 本文已经被收录进[《程序员成长笔记》 ][Link 1]，笔者JustryDeng**

[Link 1]: https://gitee.com/JustryDeng/notebook