Go语言结构体和方法

@

目录

• 1. 结构体别名定义
• 2. 工厂模式
• 3. Tag 原信息
• 4. 匿名字段
• 5. 方法

---

1. 结构体别名定义

变量别名定义

package mainimport "fmt"type integer intfunc main() {	//类型别名定义	var i integer = 1000	fmt.Printf("值: %d, 类型: %T\n", i, i)	var j int = 100	j = int(i) 			//j和i不属于同一类型，需要转换	fmt.Println(j)}//输出结果如下值: 1000, 类型: main.integer1000

结构体别名定义

package mainimport "fmt"//创建结构体Studenttype Student struct {	Number int}//结构体定义别名type Stu Studentfunc main() {	//声明Student类型结构体	var a Student	a = Student{30}	//声明Stu类型结构体	var b Stu	b = Stu{20}	//强转类型后才能进行赋值	a = Student(b)	fmt.Printf("a = %d,类型: %T\n", a, a)	b = Stu(a)	fmt.Printf("b = %d,类型: %T\n", b, b)}//输出结果如下a = {20},类型: main.Studentb = {20},类型: main.Stu

2. 工厂模式

• Go 中所谓的工厂模式其实就是：
  包内一个不可直接实例的结构体（结构体名称首字母小写），包外不可直接实例，那么为了解决这个问题，就写一个包外可调用的函数，通过这个函数实现返回结构体对象。

package mainimport "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,	}}//输出结果如下&{ 0}&{张三 18}

总结:
① make 用来创建map、slice、channel
② new 用来创建值类型

---

3. Tag 原信息

• 在和其他语言进行对接交互时使用JSON格式，有些语言格式大小写规范比较严格，为了使Go语言和其他语言对接数据传输，所以使用Tag原信息进行解决

• 通俗的来说就相当于是一个充电的转接口

示例

package mainimport (	"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处理结构体，转换成字节数组	data, err := json.Marshal(stu)	if err != nil {		fmt.Println("错误提示:", err)		return	}	fmt.Println(data)				//字节数组形式输出	fmt.Println(string(data))		//转换成字符串输出}//输出结果如下[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 mainimport (	"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处理结构体，转换成字节数组	data, err := json.Marshal(stu)	if err != nil {		fmt.Println("错误提示:", err)		return	}	fmt.Println(data)	fmt.Println(string(data))}//输出结果如下[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. 匿名字段

结构体中的字段（属性）没有名称，称之为匿名字段

示例

package mainimport "fmt"type Cart struct {	name  string	color string}type Train struct {	//匿名字段	Cart //实现继承	int  //数据类型定义，仅能存在一次，两个int则会冲突}func main() {	//初始化赋值	var t Train			t.name = "train"	t.color = "red"	t.int = 10		//直接调用数据类型赋值	fmt.Println(t)}//输出结果如下{{train red} 10}

双引用结构体，多继承（继承的两个结构体中定义相同属性）

package mainimport "fmt"//父结构体type Cart struct {	name  string	color string}//父结构体type Box struct {	color string}//子结构体type Train struct {	//匿名字段	Cart //实现继承	Box	int //数据类型定义，仅能存在一次，两个int则会冲突}func main() {	//初始化赋值	var t Train	t.name = "train"	t.Cart.color = "red"	t.Box.color = "blue"	t.int = 10 //直接调用数据类型赋值	fmt.Println(t)}//输出结果如下{{train red} {blue} 10}

package mainimport "fmt"//父结构体type Cart struct {	name  string	color string}//父结构体type Box struct {	color string}//子结构体type Train struct {	//匿名字段	Cart //实现继承	Box	int   //数据类型定义，仅能存在一次，两个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           //直接调用数据类型赋值	fmt.Println(t)}

5. 方法

• Go 中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是 struct
• 语法格式如下

func (recevier type) methodName(参数列表)(返回值){}recevier type     特定类型，如指针、别名，结构体 methodName 	      方法名

• 示例

package mainimport "fmt"//定义结构体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)}//输出结果s: {zhangsan 18}

定义返回方法是否会把初始化的值给返回？

package mainimport "fmt"//定义结构体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("初始化完成")}//返回结构体func (s *Student) get() Student {	return *s}func main() {	var stu Student	//定义值	stu.init("zhangsan", 18, 90)	//返回值	stu1 := stu.get()	fmt.Println(stu1)}//输出结果如下初始化完成{zhangsan 18 90}

传统数据类型自定义方法，做数据类型转换

package mainimport "fmt"//别名类型type integer int//传统数据类型自定义方法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)}//输出结果如下类型:string,值:100

指针传入和值传入的区别
值传入不会对数值进行改变，指针传入才可以改变数值

package mainimport "fmt"type integer int//传统数据类型自定义方法func (p integer) convert() string {	return fmt.Sprintf("%d", p)}//方法传指针进行数据同步修改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)}//输出结果如下类型: string ,值: 100类型: main.integer ,值: 100i: 200

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

package mainimport "fmt"//父结构体type Car struct {	weight int	name   string}//父方法func (c *Car) Run() {	fmt.Println("Running")}//子结构体Biketype Bike struct {	//组合(有名字)	c     Car	wheel int}//子结构体Traintype 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)	//方法继承,调用父结构体方法	bike.c.Run()	fmt.Println(train)	//方法继承	train.Run()}//输出结果如下{{500 bike} 2}Running{{140000 train} 8}Running

package mainimport "fmt"//父结构体type Cart struct {	weight int	Color  string}//父方法func (c Cart) Run() {	fmt.Println("Running")}//子结构体traintype Train struct {	Cart	wheel int}//子结构体方法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)}//输出结果如下color:[red],weight:[14000],wheel:[8]Runningcolor:[red],weight:[14000],wheel:[8]