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

Posted 2021-09-03 justry_deng

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

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

---

结构体

定义结构体

在很多语言中，面向对象编程需要使用"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语言区块链应用开发从入门到精通》高野 编著

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng