Go語言學(xué)習(xí)之結(jié)構(gòu)體和方法使用詳解

更新時間：2022年04月21日 08:18:06 作者：隱姓埋名4869

這篇文章主要為大家詳細(xì)介紹了Go語言中結(jié)構(gòu)體和方法的使用，文中的示例代碼講解詳細(xì)，對我們學(xué)習(xí)Go語言有一定的幫助，需要的可以參考一下

1. 結(jié)構(gòu)體別名定義

變量別名定義

package main

import "fmt"

type integer int

func main() {
	//類型別名定義
	var i integer = 1000
	fmt.Printf("值: %d, 類型: %T\n", i, i)

	var j int = 100
	j = int(i) 			//j和i不屬于同一類型，需要轉(zhuǎn)換
	fmt.Println(j)
}

輸出結(jié)果如下

值: 1000, 類型: main.integer
1000

結(jié)構(gòu)體別名定義

package main

import "fmt"

//創(chuàng)建結(jié)構(gòu)體Student
type Student struct {
	Number int
}

//結(jié)構(gòu)體定義別名
type Stu Student

func main() {
	//聲明Student類型結(jié)構(gòu)體
	var a Student
	a = Student{30}

	//聲明Stu類型結(jié)構(gòu)體
	var b Stu
	b = Stu{20}

	//強(qiáng)轉(zhuǎn)類型后才能進(jìn)行賦值
	a = Student(b)
	fmt.Printf("a = %d,類型: %T\n", a, a)
	b = Stu(a)
	fmt.Printf("b = %d,類型: %T\n", b, b)
}

輸出結(jié)果如下

a = {20},類型: main.Student
b = {20},類型: main.Stu

2. 工廠模式

Go 中所謂的工廠模式其實就是：

包內(nèi)一個不可直接實例的結(jié)構(gòu)體（結(jié)構(gòu)體名稱首字母小寫），包外不可直接實例，那么為了解決這個問題，就寫一個包外可調(diào)用的函數(shù)，通過這個函數(shù)實現(xiàn)返回結(jié)構(gòu)體對象。

package main

import "fmt"

type Student struct {
	Name string
	Age  int
}

func main() {
	//初始化
	stu1 := new(Student)
	fmt.Println(stu1)

	//工廠模式處理
	stu2 := NewStudent("張三", 18)
	fmt.Println(stu2)
}

//工廠模式
func NewStudent(name string, age int) *Student {
	return &Student{
		Name: name,
		Age:  age,
	}
}

輸出結(jié)果如下

&{ 0}
&{張三 18}

總結(jié):① make 用來創(chuàng)建map、slice、channel

② new 用來創(chuàng)建值類型

3. Tag 原信息

在和其他語言進(jìn)行對接交互時使用JSON格式，有些語言格式大小寫規(guī)范比較嚴(yán)格，為了使Go語言和其他語言對接數(shù)據(jù)傳輸，所以使用Tag原信息進(jìn)行解決

通俗的來說就相當(dāng)于是一個充電的轉(zhuǎn)接口

示例

package main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

func main() {
	//初始化
	var stu = new(Student)
	stu.Name = "stu"
	stu.Age = 20
	stu.Score = 88

	//使用Json處理結(jié)構(gòu)體，轉(zhuǎn)換成字節(jié)數(shù)組
	data, err := json.Marshal(stu)
	if err != nil {
		fmt.Println("錯誤提示:", err)
		return
	}
	fmt.Println(data)				//字節(jié)數(shù)組形式輸出
	fmt.Println(string(data))		//轉(zhuǎn)換成字符串輸出
}

輸出結(jié)果如下

[123 34 78 97 109 101 34 58 34 115 116 117 34 44 34 65 103 101 34 58 50 48 44 34 83 99 111 114 101 34 58 56 56 125]
{"Name":"stu","Age":20,"Score":88}

JSON格式化字段名

package main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	//json打包時字段名
	Name  string  `json:"stu_name"`
	Age   int     `json:"stu_age"`
	Score float32 `json:"stu_score"`
}

func main() {
	//初始化
	var stu = new(Student)
	stu.Name = "stu"
	stu.Age = 20
	stu.Score = 88

	//使用Json處理結(jié)構(gòu)體，轉(zhuǎn)換成字節(jié)數(shù)組
	data, err := json.Marshal(stu)
	if err != nil {
		fmt.Println("錯誤提示:", err)
		return
	}
	fmt.Println(data)
	fmt.Println(string(data))
}

輸出結(jié)果如下

[123 34 115 116 117 95 110 97 109 101 34 58 34 115 116 117 34 44 34 115 116 117 95 97 103 101 34 58 50 48 44 34 115 116 117 95 115 99 111 114 101 34 58 56 56 125]
{"stu_name":"stu","stu_age":20,"stu_score":88}

4. 匿名字段

結(jié)構(gòu)體中的字段（屬性）沒有名稱，稱之為匿名字段

示例

package main

import "fmt"

type Cart struct {
	name  string
	color string
}

type Train struct {
	//匿名字段
	Cart //實現(xiàn)繼承
	int  //數(shù)據(jù)類型定義，僅能存在一次，兩個int則會沖突
}

func main() {
	//初始化賦值
	var t Train		
	t.name = "train"
	t.color = "red"
	t.int = 10		//直接調(diào)用數(shù)據(jù)類型賦值
	fmt.Println(t)
}

輸出結(jié)果如下

{{train red} 10}

雙引用結(jié)構(gòu)體，多繼承（繼承的兩個結(jié)構(gòu)體中定義相同屬性）

package main

import "fmt"

//父結(jié)構(gòu)體
type Cart struct {
	name  string
	color string
}

//父結(jié)構(gòu)體
type Box struct {
	color string
}

//子結(jié)構(gòu)體
type Train struct {
	//匿名字段
	Cart //實現(xiàn)繼承
	Box
	int //數(shù)據(jù)類型定義，僅能存在一次，兩個int則會沖突
}

func main() {
	//初始化賦值
	var t Train
	t.name = "train"
	t.Cart.color = "red"
	t.Box.color = "blue"
	t.int = 10 //直接調(diào)用數(shù)據(jù)類型賦值
	fmt.Println(t)
}

輸出結(jié)果如下

{{train red} {blue} 10}

package main

import "fmt"

//父結(jié)構(gòu)體
type Cart struct {
	name  string
	color string
}

//父結(jié)構(gòu)體
type Box struct {
	color string
}

//子結(jié)構(gòu)體
type Train struct {
	//匿名字段
	Cart //實現(xiàn)繼承
	Box
	int   //數(shù)據(jù)類型定義，僅能存在一次，兩個int則會沖突
	color string
}

func main() {
	//初始化賦值
	var t Train
	t.name = "train"
	t.Cart.color = "red" //Cart的屬性
	t.Box.color = "blue" //Box的屬性
	t.color = "yellow"   //train自身屬性
	t.int = 10           //直接調(diào)用數(shù)據(jù)類型賦值
	fmt.Println(t)
}

5. 方法

Go 中的方法是作用在特定類型的變量上，因此自定義類型，都可以有方法，而不僅僅是 struct
語法格式如下

func (recevier type) methodName(參數(shù)列表)(返回值){}

???????recevier type     特定類型，如指針、別名，結(jié)構(gòu)體 
methodName           方法名

示例

package main

import "fmt"

//定義結(jié)構(gòu)體
type Student struct {
	Name string
	Age  int
}

//定義方法
func (s Student) init(name string, age int) Student {
	s.Name = name
	s.Age = age
	return s
}

func main() {
	var stu Student
	s := stu.init("zhangsan", 18)
	fmt.Printf("s: %v\n", s)
}

輸出結(jié)果

s: {zhangsan 18}

定義返回方法是否會把初始化的值給返回？

package main

import "fmt"

//定義結(jié)構(gòu)體
type Student struct {
	Name  string
	Age   int
	Score float32
}

//初始化方法
func (s *Student) init(name string, age int, score float32) {
	s.Name = name
	s.Age = age
	s.Score = score
	fmt.Println("初始化完成")
}

//返回結(jié)構(gòu)體
func (s *Student) get() Student {
	return *s
}

func main() {
	var stu Student
	//定義值
	stu.init("zhangsan", 18, 90)
	//返回值
	stu1 := stu.get()
	fmt.Println(stu1)
}

輸出結(jié)果如下

初始化完成
{zhangsan 18 90}

傳統(tǒng)數(shù)據(jù)類型自定義方法，做數(shù)據(jù)類型轉(zhuǎn)換

package main

import "fmt"

//別名類型
type integer int

//傳統(tǒng)數(shù)據(jù)類型自定義方法
func (p integer) convert() string {
	return fmt.Sprintf("%d", p)
}

func main() {
	var i integer
	i = 100
	s := i.convert()
	fmt.Printf("類型:%T,值:%s\n", s, s)
}

輸出結(jié)果如下

類型:string,值:100

指針傳入和值傳入的區(qū)別

值傳入不會對數(shù)值進(jìn)行改變，指針傳入才可以改變數(shù)值

package main

import "fmt"

type integer int

//傳統(tǒng)數(shù)據(jù)類型自定義方法
func (p integer) convert() string {
	return fmt.Sprintf("%d", p)
}

//方法傳指針進(jìn)行數(shù)據(jù)同步修改
func (p *integer) set(b integer) {
	*p = b
}

func main() {
	var i integer
	i = 100
	s := i.convert()
	fmt.Printf("類型: %T ,值: %s\n", s, s)
	fmt.Printf("類型: %T ,值: %d\n", i, i)
	i.set(200)
	fmt.Printf("i: %v\n", i)
}

輸出結(jié)果如下

類型: string ,值: 100
類型: main.integer ,值: 100
i: 200

方法繼承，組合（匿名字段是組合的特殊形式）

package main

import "fmt"

//父結(jié)構(gòu)體
type Car struct {
	weight int
	name   string
}

//父方法
func (c *Car) Run() {
	fmt.Println("Running")
}

//子結(jié)構(gòu)體Bike
type Bike struct {
	//組合(有名字)
	c     Car
	wheel int
}

//子結(jié)構(gòu)體Train
type Train struct {
	//匿名
	Car
	wheel int
}

func main() {
	var bike Bike
	bike.c.name = "bike"
	bike.c.weight = 500
	bike.wheel = 2

	var train Train
	train.name = "train"
	train.weight = 140000
	train.wheel = 8

	fmt.Println(bike)
	//方法繼承,調(diào)用父結(jié)構(gòu)體方法
	bike.c.Run()

	fmt.Println(train)
	//方法繼承
	train.Run()
}

輸出結(jié)果如下

{{500 bike} 2}
Running
{{140000 train} 8}
Running

package main

import "fmt"

//父結(jié)構(gòu)體
type Cart struct {
	weight int
	Color  string
}

//父方法
func (c Cart) Run() {
	fmt.Println("Running")
}

//子結(jié)構(gòu)體train
type Train struct {
	Cart
	wheel int
}

//子結(jié)構(gòu)體方法
func (t Train) String() string {
	str := fmt.Sprintf("color:[%s],weight:[%d],wheel:[%d]\n", t.Color, t.weight, t.wheel)
	return str
}

func main() {
	var train Train
	train.Color = "red"
	train.weight = 14000
	train.wheel = 8
	fmt.Println(train)
	train.Run()
	fmt.Printf("%s\n", train)
}

輸出結(jié)果如下