【GO语言卵细胞级别教程】11，彻底帮你搞懂1.4结构体声明方式直接赋值使用key赋值指针声明的两种方式指针声明

1.4结构体声明方式

直接赋值

// 1.直接赋值方式，但顺序不能变
var a1 Stu  = Stu{"张三", 19}
fmt.Println(a1)

使用key赋值


// 2.使用key赋值:注意最后一个结尾要加逗号
var a2 Stu = Stu{
	Name:"谢思肖",
	Age:21,
}
fmt.Println(a2)

指针声明的两种方式


// 3.指针声明
var a3 \*Stu = &Stu{"龙丹丹", 18}
fmt.Println(a3, \*a3)

指针声明使用key赋值


var a4 \*Stu = &Stu{
	Name:"谢思肖",
	Age:21,
}
fmt.Println(a4, \*a4)

完整的代码

package mystudy
// 面向对象 结构体之方法
import "fmt"
type Stu struct{
	Name string
	Age int
}

func DemoObjStruct(){
	fmt.Println("------结构体声明方法------")
	// 1.直接赋值方式，但顺序不能变
	var a1 Stu  = Stu{"张三", 19} 
	fmt.Println(a1)
	// 2.使用key赋值:注意最后一个结尾要加逗号
	var a2 Stu = Stu{
		Name:"谢思肖",
		Age:21,
	}
	fmt.Println(a2)
	// 3.指针声明
	var a3 \*Stu = &Stu{"龙丹丹", 18}
	fmt.Println(a3, \*a3)
	var a4 \*Stu = &Stu{
		Name:"谢思肖",
		Age:21,
	}
	fmt.Println(a4, \*a4)
}

1.5使用包导入结构体

不同包之间引用

首选要大写结构体
在调用的函数中导入包

文件：stu.go
package mystudy
// 这里要大写大写
type Stu struct{
  name string
  age int
}
/// 调用

文件main.go
package main
import "模块名称/mystudy"
func main(){
    var st mystudy.Stu = mystudy.Stu{"lisi"， 22}
}

方案2：针对小写的结构体如何对外使用呢，这里借助一个桥梁，就是对外开放的函数
在这里插入图片描述

首先定义结构体
定义一个外部可以访问的函数
访问函数以修改结构体
定义 mystudy.go

package mystudy
// 面向对象 结构体之方法
import "fmt"


type teacher struct{
	Name string
	age int
}

func InitTeacher(name string, age int)\*teacher{
	return &teacher{name, age}
}

func DemoObjStruct(){
	var te \*teacher
	te = &teacher{"wagn", 22}
	fmt.Println(te)
	(\*te).Name = "www"
	fmt.Println(te)
}

定义主函数

package main

import (
	"fmt"
	"com.gdzs/goproject/src/com/gdzs/mystudy"
)
func main(){
	te := mystudy.InitTeacher("青青", 28)
	fmt.Println(te)
	(\*te).Name = "qingqing"
	// 也可以写成 te.Name = "qingqing"
	fmt.Println(te)
}

// 输出结果
&{青青 28}
&{qingqing 28}

注意

以上的teacher的属性需要首字母大写，主函数中才可以使用te.Name修改，如果是小写则无法访问，就会报如下错误

main.go:86:8: (\*te).name undefined (type mystudy.teacher has no field or method name)

注意声明的时候，不能使用var xxx mystudy.teacher，因为这个结构体是不对外使用的，所以只能使用xxx:=xx这种隐式声明类型的方式。

1.6结构体嵌入

1.6.1 嵌入方式1：匿名结构体

结构体嵌入（Struct embedding）是一种在一个结构体中嵌入另一个结构体的方式，以便通过嵌入的结构体来访问其字段和方法。

通过结构体嵌入，可以将一个结构体类型作为另一个结构体的字段，使得被嵌入的结构体的字段和方法成为了外部结构体的一部分，就好像它们是直接定义在外部结构体中一样。

使用结构体嵌入的主要目的是实现代码的重用和组合。通过嵌入结构体，可以将通用的字段和方法提取到一个单独的结构体中，并在其他结构体中嵌入该结构体，从而实现代码的复用，并且可以通过外部结构体访问嵌入结构体的字段和方法。

package mystudy
// 结构体嵌入知识点
import "fmt"
type Animal struct{
	Name string
	Age int
}

func getAnimal(name string, age int)\*Animal{
	return &Animal{name, age}
}


func(a Animal) eat(){
	fmt.Println(a.Name, "吃东西")
}


type Dog struct{
	Animal // 嵌入结构体
	weight int 
}

func (d Dog) call(){
	fmt.Println(d.Name,"叫了一声，说她的体重是：",d.weight)
}
func (d \*Dog) setWight(weight int){
	(\*d).weight = weight
	fmt.Println(d.weight)
}

func DemoQianru(){
	// 声明方式1
	var d Dog = Dog{Animal{"花花", 22}, 108}
	fmt.Println(d)
	// 声明方式2
	// 在 Go 语言中，结构体的字段初始化可以按照顺序进行赋值。
	// 但是在嵌套结构体中，如果嵌入的结构体没有指定字段名，
	// 那么在初始化时不能省略字段名。
	var d2 Dog = Dog{Animal:Animal{"兰兰", 22}, weight:108}
	fmt.Println(d2)
	d.setWight(99)
	fmt.Println(d)
	// 声明方式3使用指针
	var d3 \*Dog = &Dog{Animal:Animal{"雨雨", 22}, weight:108}
	(\*d3).setWight(98)
	fmt.Println((\*d3))
}

嵌入的结构体可以通过变量直接调用,如上代码所示

// 访问方式1
d2.weight
// 访问方式2
d2.Animal.Name

对于指针，这几种方式调用都是可以使得

对于指针，这几种方式调用都是可以使得s
fmt.Println(d3.Animal.Name)
fmt.Println(d3.Name)
fmt.Println((\*d3).Name)

1.7.2结构体嵌入：当作一个字段

一个结构体当作一个类型来嵌入结构体中

type Dog struct {  
	a Animal // Animal结构体被嵌入到Dog结构体中 
}

声明和调用方法
1. 声明：var c1 = cat{Animal{“猫猫”, 19}, 180}
2. 调用方式：c1.a.XXX

package mystudy
// 结构体嵌入知识点
import "fmt"
type Animal struct{
	Name string
	Age int
}

func getAnimal(name string, age int)\*Animal{
	return &Animal{name, age}
}

func(a Animal) eat(){
	fmt.Println(a.Name, "吃东西")
}

type cat struct{
	a Animal
	high int 
}


func DemoQianru(){
	fmt.Println("------结构体嵌入，当作类型------")
	// 声明
	var c1 = cat{Animal{"猫猫", 19}, 180}
	fmt.Println(c1)
	// 此语句无法调用，会报错
	// 16.结构体嵌入.go:59:17: c1.Name undefined (type cat has no field or method Name)
	// fmt.Println(c1.Name)
	// 使用以下带调用
	fmt.Println(c1.a.Name)
}

通过以上如果想通过类来实现的话，还得是使用嵌入的匿名结构体，因为它会自动搜索结构体中的属性的。不需要指定具体的属性

1.7面向对象-封装

有了1.6章节的嵌入结构体可以看到要是实现封装的话，使用嵌入匿名的结构体可以完成。

1.7.1给她创建一个类吧

在 Go 语言中，没有类的概念，而是使用结构体（struct）和方法（method）来实现面向对象的编程。
可以通过定义一个结构体来表示一个类型，并在该结构体上定义方法来操作和处理该类型的实例。这种结构体和方法的组合可以用来模拟类的概念。

下面是一个创建结构体和方法的示例：
（1）首字母大写，其他包可以访问，否则，只能在当前包可以访问
（2）属性也是一样的，大写首字母可以对外访问，否则只能当前包可以访问
（3）方法也是如此：方法使用结构体绑定方法

定义一个类

package mystudy
// 类知识
type Student struct{
     Name string
     age int
}

创建构造函数:因为结构体都是值传递，所以这里使用指针

func getStudent(name string, age int)\*Student{
	return &Student(name, age)
}

创建方法：使用结构体绑定方法
注意这里设置需要传入指针，才能改变对应的值

func (s \*Student)setName(name string){
	(\*s).Nmae = name
}

func (s Student)getName(){
    return s.Name
}

1.7.2类的继承

类继承：使用嵌入匿名结构体即可
（1）实现父类结构体，实现子类结构体，子类结构体嵌入匿名父类结构体
（2）同样定义了showInfo()方法必须参数和返回值都一样，不能出现参数不同，返回值不同的同名函数，否则会报错
（3）当调用的时候会先在子类中寻找方法或者属性，如果找不到再调用父类的

// 定义父类结构体
type People struct{
    Name string
    Age int
}
// 定义父类方法
func (p People)showInfo()string{
	fmt.Println("父类方法showInfo")
    message := fmt.Sprinf("我的名字：%v 我的年龄",p.Name, p.Age)
    return message
}
// 定义父类方法
func (p People)whoami(){
	fmt.Println("我是谁：", p.Name)
}
-------------------------------
// 定义子类结构体
type Student struct{
	People
	notes string
}
// 定义子类发方法
func(s Student) showInfo()string{
	fmt.Println("子类方法showInfo")
    message := fmt.Sprinf("我的名字：%v 我的年龄",s.Name, s.Age)
    return message
}

完整的测试代码

package mystudy
// 面向对象-继承
import "fmt"

// 定义父类结构体
type People struct{
    Name string
    Age int
}
func (p \*People)setName(name string){
	(\*p).Name = name
}

// 定义父类方法
func (p People)showInfo()string{
	fmt.Println("父类方法showInfo")
    message := fmt.Sprintf("我的名字：%v 我的年龄:%v",p.Name, p.Age)
    return message
}
// 定义父类方法
func (p People)whoami(){
	fmt.Println("我是谁：", p.Name)
}

// 定义子类结构体
type Student struct{
	People
	notes string
}
// 定义子类发方法
func(s Student) showInfo()(message string){
	// 子类的方法如果和父类同名，那么就必须参数和返回值都是一样的，否则就会报错
	fmt.Println("子类方法showInfo")
    message = fmt.Sprintf("我的名字：%v 我的年龄:%v", s.Name, s.Age)
	fmt.Println(message)
	return 
}

func DemoJc(){
	// 声明一个对象
	fmt.Println("------面向对象-继承------")
	var s1 = Student{People{"关关", 19}, "前任2"}
	message := s1.showInfo()
	fmt.Println(message)
	fmt.Println("==重新设置新的名字：盈盈")
	s1.setName("颖颖")
	message = s1.showInfo()
	fmt.Println(message)
}
// 输出结果
------面向对象-继承------
子类方法showInfo
我的名字：关关 我的年龄:19
我的名字：关关 我的年龄:19
==重新设置新的名字：盈盈
子类方法showInfo
我的名字：颖颖 我的年龄:19
我的名字：颖颖 我的年龄:19

1.7.3多继承

多继承就是按照1.7.2的介绍，这个时候多加几个嵌入结构体就行了

type People struct{
    Name string
    Age int
}

type People2 struct{
    Name string
    Age int
    higi int
}

type Student struct{
     People 
     People2
     notes string
}

func DemoMain(){
    var st = Student{People{"xxx", 19}, People2{"xxx", 21, 180}, "测试"}
}

完整代码

package mystudy
// 面向对象-继承
import "fmt"

/\*
人父类
\*/
// 定义父类结构体
type People struct{
    Name string
    Age int
}

func (p \*People)setName(name string){
	(\*p).Name = name
}

// 定义父类方法
func (p People)showInfo()string{
	fmt.Println("父类方法showInfo")
    message := fmt.Sprintf("我的名字：%v 我的年龄:%v",p.Name, p.Age)
    return message
}
// 定义父类方法
func (p People)whoami(){
	fmt.Println("我是谁：", p.Name)
}

/\*
父类：People2
\*/
type People2 struct{
	Name string
	Age int
	high int
}

/\*
学生子类
\*/

// 定义子类结构体
type Student struct{
	People
	People2
	notes string
}
// 定义子类发方法
func(s Student) showInfo()(message string){
	// 子类的方法如果和父类同名，那么就必须参数和返回值都是一样的，否则就会报错
	fmt.Println("子类方法showInfo")
    message = fmt.Sprintf("我的名字：%v 我的年龄:%v", s.People.Name, s.People2.Age)
	fmt.Println(message)
	return 
}

func DemoJc(){
	// 声明一个对象
	fmt.Println("------面向对象-继承------")
	var s1 = Student{People{"关关", 19},People2{"关关2", 20, 88}, "前任2"}
	message := s1.showInfo()
	fmt.Println(message)
	fmt.Println("==重新设置新的名字：盈盈")
	s1.setName("颖颖")
	message = s1.showInfo()
	fmt.Println(message)
}
//
------面向对象-继承------
子类方法showInfo
我的名字：关关 我的年龄:20
我的名字：关关 我的年龄:20
==重新设置新的名字：盈盈
子类方法showInfo
我的名字：颖颖 我的年龄:20
我的名字：颖颖 我的年龄:20

注意：

如果父类的属性有重复的，这个时候调用属性的时候要指定具体的结构体

s1.People.Name
s1.People2.Age

1.7.4注意事项

结构体的嵌入匿名结构体可以是基本类型

type People struct{
    Name string
    Age int
}

type Studen struct{
    People
    int
    float32
}

st2 := Student2{People{"学生2", 22}, 18,19}
fmt.Println(st2)
fmt.Println(st2.int)
fmt.Println(st2.float32)
// 输出结果
{{学生2 22} 18 19}
18
19

创建结构体的时候可以使用之前的声明方法，使用key或者直接按照顺序

st3 := Student2{
	People:People{
		Name:"学生3",
		Age:22,
	},
	int:19,
	float32:99,
}
fmt.Println(st3)
注意，最后要加上 逗号

对于指针结构体嵌入引用的也是类似2的声明

package mystudy
// 面向对象-继承
import "fmt"

type Student3 struct{
	\*People
	int
}

func DemoJc(){
	st4 := Student3{
		&People{"李华", 22}, 88,
	}
	fmt.Println(st4)
	fmt.Println(st4.People)
	fmt.Println(\*(st4.People))
}
// 输出结果
{0xc000116030 88}
&{李华 22}
{李华 22}

结构体的字段可以是结构体的类型，这个在1.6章节介绍了。这通常也称为组合模式

type People struct{
    Name string
}

type Student struct{
    p People
}

1.8实现接口

1.8.1语法定义

接口语法:接口只能定义方法，不能定义变量

type Persion interface{
     // 方法
     eat()
     // 方法
     say()
}

继承接口

type Student struct{
   
}
// 实现方法
func（s Student) eat(){
  fmt.Println("eat")
}

1.8.2注意事项

接口中定义一组方法，但是不需要实现，不需要方法体，接口不能包含任何变啊零。
实现接口要实现所有的方法才是实现,一下代码没有全部实现会报错

type Persion1 interface {
	SayHello()
	eat()
}
// 定义学生类
type StudentClass01 struct{
	Name string
}

func(s StudentClass01) SayHello(){
	fmt.Println(s, "Student say hello")
}

当你调用的时候这里就会报错，如果没有全部实现编译不会报错
var st StudentClass01
var p Persion1
p = st
p.SayHello()

goproject\src\com\gdzs\mystudy\18.接口01.go:33:5: cannot use st (variable of type StudentClass01) as Persion1 value in assignment: StudentClass01 does not implement Persion1 (missing method SayHello)

Golang中的接口不需要显式的实现接口，Golang中没有implement关键字（Go中实现接口是基于方法的，不是基于接口的）
如果有两个接口 A B 有共同的方法 a b 如果c结构体实现了a b两个方法，那么就是两个接口都实现了如下的Persion1 和Persion两个接口

package mystudy
// 接口定义
import "fmt"

type Persion interface {
	SayHello()
}

type Persion1 interface {
	SayHello()
}
// 定义学生类
type StudentClass01 struct{
	Name string
}

func(s StudentClass01) SayHello(){
	fmt.Println(s, "Student say hello")
}
// 定义教师类
type Teacher struct{
}

func(t Teacher) SayHello(){
	fmt.Println(t, "Teacher say hello")
}

func say(p Persion1){
	p.SayHello()
}

func DemoInterface01(){
	var st StudentClass01
	var t Teacher
	say(st)
	say(t)
}

接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量:这里说的其实就是面向对象的多态

// 定义教师类
type Teacher struct{
}

func(t Teacher) SayHello(){
	fmt.Println(t, "Teacher say hello")
}

func say(p Persion1){
	p.SayHello()
}

func DemoInterface01(){
	var t Teacher
	say(t)
}

只要是自定义数据类型，就可以实现接口，不仅仅是结构体类型

type Persion1 interface{
    SayHello()
}

func say(p Persion1){
	p.SayHello()
}
// 其他类型的接口
type integer int

func (i integer)SayHello(){
	fmt.Println("int say hello:", i)
}

func DemoInterface01(){
	var i integer =100
	say(i)
}
// 打印结果
int say hello:100

一个自定义类型可以实现多个接口:同一个模块下的接口可以直接使用，比如这里的Persion使用的就是前面代码模块里面的

package mystudy
import "fmt"
// 实现多个接口
// 接口1
type Persion2 interface{
	eat()
}
// 接口2
type Animal2 interface{
	say()
}
// 结构体实现
type Student6 struct{

}
// 实现接口1
func(s Student6)eat(){
	fmt.Println("student eat")
}
// 实现接口2
func(s Student6)say(){
	fmt.Println("student say")
}

// 实现接口2
func(s Student6) SayHello(){
	fmt.Println("Student say hello")
}
func DemoMulInterface(){
	var st Student6
	var p2 Persion2
	// 前面代码模块里面的
	var p1 Persion
	var a Animal2
	p2 = st
	a = st
	p1 = st
	p2.eat()
	a.say()
	p1.SayHello()
}
// 输出结果
student eat
student say
Student say hello

接口可以继承别的接口，A继承B ，那么实现的时候要都实现所有接口的方法才可以
#GO接口继承

package mystudy
// 接口继承接口
import "fmt"

type Ainter interface{
	a()
}
type Binter interface{
	b()
}
type Cinter interface{
	Ainter
	Binter
	c()	
}

type Dstruct struct{

}

func (s Dstruct) a(){
	fmt.Println("aaa")
}
func (s Dstruct) b(){
	fmt.Println("bbb")
}
func (s Dstruct) c(){
	fmt.Println("ccc")
}

func DemoMulInterInter(){
	var s Dstruct
	var c Cinter = s
	c.c()
}

接口类型默认是一个指针类型，没有对应接口初始化，那么就会输出空
空接口时所有类型的祖先，因为所有类型都实现了空接口，可以把任何一个变量赋给空接口
#GO空接口
如下的空接口

type Empty interface{}
// 空接口可以接收任意一个变量
var a interface{} = 12
var b interface{} = "aa"
var c interface{} = 'x'

在这里插入图片描述

1.9多态

多态（Polymorphism）是一种面向对象编程的重要概念，它允许我们使用统一的接口来处理不同类型的对象。Go语言通过接口（Interface）来实现多态性。
代码示例：

package mystudy
import "fmt"
// 多态
type Shape interface {
	Area() float64
}

/\*
定义矩形类型
\*/
type Rectangle struct{
	Width float64
	Height float64
}
// 实现方法
func (r Rectangle) Area() float64 {
	return r.Width \* r.Height
}
// 特定方法
func (r Rectangle) GetHeight() float64{
	return r.Height
}
/\*
定义圆形
\*/
type Circle struct{
	Radius float64
}
// 定义圆形面积
func (c Circle) Area() float64{
	return 3.14 \* c.Radius \* c.Radius
}

// 公共方法
func DtTest(s Shape) {
	fmt.Println("公共方法:", s.Area())
	//因为GetHeight是矩形类独有的,所以这里需要转类型
	//这里使用断言 这个方法接收会出现报错,程序不会继续执行
	// var re Rectangle = s.(Rectangle)
	// 断言方法2
	re, ok := s.(Rectangle)
	fmt.Println(ok)
	fmt.Println(re.GetHeight())
}

func DtDemo(){
	shape := []Shape{
		Circle{10},
		Rectangle{10, 11},
	}	
	for i, shape := range shape{
		fmt.Printf("%T:", shape)
		fmt.Println(i, shape.Area())
		DtTest(shape)
		switch shape.(type){
			case Rectangle:
				fmt.Println("这是矩形")
			case Circle:
				fmt.Println("这是圆形")
		}
	}
}

多态时需要使用类型判定方法
s.(Rectangle)判断类型并强制转换类型为Rectangle 这里会返回两个值，re,ok ok是bool表示是否转换成功。re是转成功后的类型可以调用独有的方法

// 公共方法
func DtTest(s Shape) {
	fmt.Println("公共方法:", s.Area())
	//因为GetHeight是矩形类独有的,所以这里需要转类型
	//这里使用断言 这个方法接收会出现报错,程序不会继续执行
	// var re Rectangle = s.(Rectangle)
	// 断言方法2
	re, ok := s.(Rectangle)
	fmt.Println(ok)
	fmt.Println(re.GetHeight())
}

方法2:不推荐这种方法，因为会报错

var s = s.(Rectangle)


![img](https://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/2e1aad1af71547b1b75da88443d42a4d~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771857102&x-signature=0f5ULcyu28Nudo7n8AnxftO9gmw%3D)
![img](https://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/83c6848e621c410ba1e195c81d1d2c4b~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771857102&x-signature=Jf8701zJclW15SEUzJ%2BU3YLJvGA%3D)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://gitee.com/vip204888)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**