golang 系列 (三) 结构体,接口,指针,以及各种循环与判断的高级语法

最新推荐文章于 2024-08-20 01:09:16 发布
最新推荐文章于 2024-08-20 01:09:16 发布
阅读量2.3k 收藏 3
点赞数 1
分类专栏： # Go 文章标签： Go 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geekqian/article/details/82886767
版权

个人博客首发 http://www.geekqian.com/post/919b1b0c.html

结构体和方法

Go 中可以在 结构体 (Struct) 中封装属性和操作, 概念类似 java 中的类. 定义方式如下:

type Student struct {
	Name string
	Age int
	Gender string
}

实现方式如下:

s1 := Student{Name:"Mike", Age:11, Gender:"boy"}
// 可以如此简写, 但必须注意参数顺序的一一对应.
s2 := Student{"Rose", 12, "girl"}
s3 := new (Student)
fmt.Println(s1.Name, s2.Gender, s3.Age) // 值为 Mike, girl, 0

匿名结构体:

s3 := struct {
    Name string
	Age int
	Gender string
}{"Robert", "boy", 13}

注意: 匿名结构体无法定义方法.

因为为结构体定义方法要在结构体的外部. 如下:

type Student struct {
	Name string
	Age int
	Gender string
}

// * 是指向 Student 结构体类型
func (s *Student) fmtName() {
	fmt.Println(s.Name)
} 

func main() {
	s3 := new (Student)
	s3.Name = "王二狗"
	s3.fmtName()
}

结构体继承

直接看代码:

// 定义结构体 Person
type Person struct {
	Country string
}

// 定义结构体 Student 并继承 Person
type Student struct {
	Name string
	Age int
	Gender string
	Person // 继承 Person 所有属性与方法
}

// * 是指向 Student 结构体类型
func (s *Student) fmtName() {
	fmt.Println(s.Name)
} 

// 打印国家
func (p *Person) fmtCountry() {
	fmt.Println(p.Country)
} 

func main() {
	s1 := new (Student)
	// 这是 Person 的属性与方法
	s1.Country = "中国"
	s1.fmtCountry()
	// 这是 Student 的属性与方法
	s1.Name = "王二狗"
	s1.fmtName()
}

接口

接口是用来保存共性方法的容器. 看如下代码定义:

// 定义接口
type Skill interface {
	Say() string
	Eat()
}

// 定义结构体 Person
type Person struct {
	// 属性
	Country string
}

// 定义结构体 Student 并继承 Person
type Student struct {
	Name string
	Age int
	Gender string
	Person // 继承 Person 所有属性与方法
}

// 实现接口方法
func (s Student) Say() string{
	fmt.Println("我叫" + s.Name + ",我来自" + s.Country)
	return "over"
}

func (s Student) Eat() {
	fmt.Println("我吃茶叶蛋")
}

func main() {
	s1 := new (Student)
	// 这是 Person 的属性与方法
	s1.Country = "中国"
	s1.fmtCountry()
	// 这是 Student 的属性与方法
	s1.Name = "王二狗"
	msg := s1.Say()
	fmt.Println(msg)
	s1.Eat()
}

指针

指针涉及到两个操作符 & 和 * , & 代表 取址符 * 代表 声明符 / 取值符

取址符 指的是取得内存地址的意思. 例如:

var a int = 1
fmt.Println("变量a的内存地址是: " , &a)

输出结果为：

// 变量a的内存地址是:  0xc00004a090

声明符 在使用指针时需要为指针值声明一个类型, 这个类型就是用 声明符 来定义的. 例如:

// 声明指针变量p 指针类型为int
var p *int

取值符 使用指针变量获取指针值

// 获取指针值
var b = *p

例子演示 :

// 定义变量a并赋值
var a int = 1
// 声明指针变量p 指针类型为int
var p *int 
// 获取变量a的内存地址赋值给p
p = &a

fmt.Println("变量a的内存地址是: " , &a)
fmt.Println("指针变量p的存储地址是: " , p)
fmt.Println("指针变量p的值是: " , *p)

注意: 这里 p 的存储地址与内存地址是有区别的, 我们可以把 p 看做是一个容器, 存储了一个 a 的内存地址, 而 p 本身也是指向一个内存地址的, 所以如果使用 &p 这种写法的话就会得到 p 本身所指向的内存地址.而不是储存的 a 的地址.

声明指针数组

使用下面这种方式声明:

const len int = 3
var ptr [len]*int

实例:

func main() {
	// 定义常量长度
	const len int = 3;
	// 定义指针数组
	var ptr [len]*int 
	// 定义整数数组
	arr := []int{1, 2, 3}
	
	var i int
	for i = 0; i < len; i ++{
		// 把数组值的内存地址储存到指针数组中
		ptr[i] = &arr[i]
	}

	// 遍历打印
	for  i = 0; i < len; i++ {
		fmt.Printf("a[%d] = %d\n", i, *ptr[i] )
	}
}

打印结果为:

a[0] = 1
a[1] = 2
a[2] = 3

指向指针的指针

顾名思义, 指针也可以储存另一个指针的地址. 定义方式如下:

var ptr **int;

实例:

func main() {
	// 定义变量a
	var a int = 1
	// 定义指针
	var ptr *int
	// 定义指向指针的指针
	var pptr **int

	// 定义指针 ptr 地址
	ptr = &a
	// 定义指针 pptr 地址
	pptr = &ptr

	fmt.Printf("指针变量 *ptr = %d\n", *ptr )
	fmt.Println("指针变量 *pptr = ", *pptr )
}

打印结果如下:

指针变量 *ptr = 1
指针变量 *pptr =  0xc00004a068

if、switch、for、select

各种判断选择语句

if

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// 程序重启后，产生的随机数和上次一样。是因为程序使用了相同的种子, 使用rand.Seed(seed)来设置一个不同的种子值。
	// 利用当前时间的UNIX时间戳初始化rand包
	rand.Seed(time.Now().UnixNano()) 
	
	// 定义变量a,b 并用随机数赋值
	var a int = rand.Intn(100)
	var b int = rand.Intn(100)

	// 使用if判断两个数值
	if a > b {
		fmt.Printf("结果是 a (%d) > b (%d)", a, b)
	} else if b > a {
		fmt.Printf("结果是 b (%d) > a (%d)", b, a)
	}
}

也可以使用这种方式

func main() {
	// 定义变量 i
	var i int
	// 判断是否小于 100
	if i := 1; i < 100 {
		fmt.Printf("结果是 i (%d) < 100 \n", i)
	}
	
	// 打印 i 的值
	fmt.Printf("i = %d", i)
}

打印结果:

结果是 i (1) < 100
i = 0

由此可得出结论, 在 if 中定义的 变量 i 是与外部定义的变量 i 是相互独立的.

switch

func main() {
	// 定义变量 s
	s := "golang"
	
	switch s {
		case "java" :
			fmt.Println("使用的语言是java")
		case "PHP" :
			fmt.Println("使用的语言是PHP")
		case "golang" :
			fmt.Println("使用的语言是golang")
		default :
			fmt.Println("不是匹配的语言")
	}
}

与 if 相同, 也可以这么定义:

func main() {
	// 定义变量 s
	arr := []string{"java", "golang", "PHP", "Python"}
	
	switch s := arr[3]; s {
		case "java" :
			fmt.Println("使用的语言是java")
		case "PHP" :
			fmt.Println("使用的语言是PHP")
		case "golang" :
			fmt.Println("使用的语言是golang")
		default :
			fmt.Printf("%v不是匹配的语言", s)
	}
}

打印的结果为

Python不是匹配的语言变量

类型switch 判断类型的语句.

func main() {
	// 定义变量 i
	v := 1

	// 使用类型 switch 判断
	switch i := interface{}(v).(type) {
		case int, int8, int16, int32, int64:
		    fmt.Printf("变量 %d 的类型为 %T. \n", i, v)
		case uint, uint8, uint16, uint32, uint64:
		    fmt.Printf("变量 %d 的类型为 %T. \n", i, v)
		default:
		    fmt.Printf("%v不是匹配的类型", i)
	}
}

打印的结果为

变量 1 的类型为 int.

for

// 定义条件循环. 
for i := 0; i < 10; i++ {
    fmt.Print(i, " ")
}

// 定义死循环
for {
	fmt.Print("abc")
}

range

特殊的范围表达式, 用法如下:

func main() {
	// 定义数组
	arrs := []int{1, 2, 3 ,4}

	// 使用 range 表达式会返回一个 key, value 形式的返回值
	for k , v := range arrs {
		fmt.Printf("key = %d, value = %d \n", k, v)
	}
}

打印结果为 :

key = 0, value = 1 
key = 1, value = 2 
key = 2, value = 3 
key = 3, value = 4

再举几个栗子 :

栗子1

// 如果只想获取值, 可使用空白符 _ 代表不接收 key
for _ , v := range arrs {
	fmt.Printf("value = %d \n", v)
}

value = 1 
value = 2 
value = 3 
value = 4

栗子2

// 遍历字符串
for k, v := range "go语言"{
	fmt.Printf("key = %d, value = %c\n", k , v)
}

key = 0, value = g
key = 1, value = o
key = 2, value = 语
key = 5, value = 言

注意: key 为何不是连续的? 因为一个中文字符在经过UTF-8编码之后会表现为三个字节。如下图:

select

select 语句类似于 switch 语句，但是 select 会随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行.

select 语句的语法特点：

  • 每个 case 都必须是一个通信
  • 所有 channel 表达式都会被求值
  • 所有被发送的表达式都会被求值
  • 如果任意某个通信可以进行，它就执行；其他被忽略。
  • 如果有多个 case 都可以运行，select 会随机公平地选出一个执行。其他不会执行。

否则：

  1. 如果有 default 子句，则执行该语句。
  2. 如果没有 default 字句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

栗子1

// 测试select是否随机执行case
for i := 0 ; i < 5 ; i++ {
	c1 := make(chan int , 1)
	c1 <- 1
	c2 := make(chan int , 1)
	c3 := make(chan int , 1)
	c3 <- 3
	var i1, i2 int
	select {
	case i1 = <- c1 :
		fmt.Printf("i1 = %d \n", i1)
	case c2 <- i2 :
		fmt.Printf("发送 i2 (%d) 到通道 c2\n", i2)
	case i3, ok := <- c3 :
		if ok{
			fmt.Printf("i3 = %d \n", i3)
		} else {
			fmt.Printf("c3 is closed")
		}
	default:
		fmt.Printf("---------当前没有通信--------\n\n")
	}
}

打印结果 :

发送 i2 (0) 到通道 c2
i1 = 1 
i3 = 3 
发送 i2 (0) 到通道 c2
发送 i2 (0) 到通道 c2

栗子2

// 测试select是否在匹配完所有合适的case后进入默认语句
for i := 0 ; i < 3 ; i++ {
	c1 := make(chan int , 1)
	c1 <- 1
	c2 := make(chan int , 1)
	c3 := make(chan int , 1)
	c3 <- 3
	var i1, i2 int
	for i := 0 ; i < 4 ; i++ {
		select {
			case i1 = <- c1 :
				fmt.Printf("i1 = %d \n", i1)
			case c2 <- i2 :
				fmt.Printf("发送 i2 (%d) 到通道 c2\n", i2)
			case i3, ok := <- c3 :
				if ok{
					fmt.Printf("i3 = %d \n", i3)
				} else {
					fmt.Printf("c3 is closed")
				}
			default:
				fmt.Printf("---------当前没有通信--------\n")
		}
	}
}

打印结果 :

发送 i2 (0) 到通道 c2
i1 = 1 
i3 = 3 
---------当前没有通信--------
i1 = 1 
i3 = 3 
发送 i2 (0) 到通道 c2
---------当前没有通信--------
发送 i2 (0) 到通道 c2
i3 = 3 
i1 = 1 
---------当前没有通信--------
geekqian
关注
专栏目录
golang结构体-对象和指针-函数赋予
u013560925的博客
05-21 1913
转载地址：https://studygolang.com/articles/14244 原作者：amu_lucifer 1、定义一个结构体 typeUserstruct{ useridint usernamestring passwordstring} 2、初始化一个结构体 　　有两种情况，一是得到结构体的对象，一是得到结构的对象指针...
Golang学习系列第三天：学习数组、切片、Map、结构体、指针、函数、接口类型、channel通道
董广明的博客
07-15 977
继Golang学习系列第二天：变量、常量、数据类型和流程语句之后，今天开始学习数据类型之高级类型： 派生类型。 学过java的人都知道，java其实就8种基本类型：byte、short、int、long、float、double、char、boolean，但它有引用数据类型：字符串、数组、集合、类、接口等。 而golang也有这样的划分，基本类型（Golang学习系列第二天已学过）和派生类型（不叫引用类型），派生类型有以下几种：数组类型、切片类型、Map类型、结构体类型(struct)、指针...
golang该如何循环 多层结构体
01-20
一：首先贴代码（你们大概看看就行，在看看后面的数据 你们就能理解 结构体嵌套的案例） 如果是PHP就方便很多，直接数组嵌套数组就行，也就是二维数组。 package model import ( fmt time ) type Find struct { Article []Article SelectArticle []SelectArticle RecoArticle []SelectArticle SelectLabel []SelectLabel IndexAbout SiteInfo IndexContact SiteInfo }
Go语言学习笔记(五)-其他类型(指针、结构体、、)
EvansChang
03-21 594
指针在Go语言中也存在指针，且指针保存了变量的地址，初始值为nil。定义指针与定义变量相似，不同的是在类型前面指针需要加*例如:var p *int //此处定义了一个int类型的指正指针也可以通过已有变量获取，通过&操作符便可，与C语言相似Go中*指针名指向变量底层，但是不同的是Go中没有指针运算。示例代码如下:package main import "fmt" func main(){
Go：指针和结构体
最新发布
Liu_y_xin的博客
08-20 860
Go语言中的指针是一种非常重要的概念，它允许程序员直接访问和操作内存地址，从而可以更高效地管理和传递数据。在Go中，指针相关的知识点主要包括指针的定义、指针的使用、指针与结构体的关系、指针与函数传参等。 Go语言中的结构体（Struct）是一种用户自定义的数据类型，它将不同类型的值组合在一起，形成一个新的复合数据类型。结构体在Go语言中广泛用于组织数据，并可以为其定义方法，使其具备一定的行为能力，相当于其他编程语言中的“类”（但Go不支持类继承），是面向对象编程的基础。
Go语言结构体指针
qq_54650406的博客
09-14 1394
golang结构体指针
Go 语言中的结构体：定义、初始化与高级用法解析
MrWangisgoodboy的博客
12-02 800
Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型Go语言中可以使用type关键字来定义自定义类型将myInt定义为int类型，通过type关键字的定义，myInt就是一种新的类型，它具有int的特性类型别名与自定义类型表面上看只有一个等号的差异结果显示a的类型是main.newInt,表示main包下定义的newInt类型。
go调用c语言结构体,数据结构和算法(Golang实现)(4)简单入门Golang-结构体和方法
weixin_35645077的博客
05-21 1001
结构体和方法一、值，指针和引用我们现在有一段程序：package mainimport "fmt"func main() {// a,b 是一个值a := 5b := 6fmt.Println("a的值：", a)// 指针变量 c 存储的是变量 a 的内存地址c := &afmt.Println("a的内存地址：", c)// 指针变量不允许直接赋值，需要使用 * 获取引用//c = 4...
javer转go入门笔记-结构体与指针
qq_38001359的博客
04-20 267
本文介绍了go语言中结构体和指针部分的内容，同时介绍了数组指针和结构体指针的隐式转换、数组指针和指针数组等问题。
Golang 结构体
李培冠的博客
08-04 9284
前言 结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。 用结构体的经典案例：学校的学生信息，每个学生信息包含一个唯一的学生学号、学生的名字、学生的性别、家庭住址等等。所有的这些信息都需要绑定到一个实体中，可以作为一个整体单元被复制，作为函数的参数或返回值，或者是被存储到数组中，等等。 结构体也是值类型，因此可以通过 new 函数来创建。 组成结构体类型的那些数据称为字段（fields）。字段有以下特性： 字段拥有自己的类型和值。 字段名必须唯一。 字段的类型也可
Go 语言编程 — 高级数据类型 — 结构体
烟云的计算
07-06 1981
目录 文章目录目录结构体访问结构体成员向函数传递结构体结构体指针 结构体 Golang 中，结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。 结构体的定义使用了 type 和 struct 关键字。 struct 关键字：定义一个新的数据类型，结构体中有一个或多个成员。 type 关键字：设定了结构体的名称。 结构体的格式如下： type struct_variable_type struct { member definition member definition ..
Go指针与结构体
qq_45371023的博客
02-20 301
指针和结构体，指针概念，如何使用。数组指针，指针函数，指针作为参数；结构体，定义一个结构体，匿名结构体，结构体嵌套，结构体导出。
【GO 编程语言】指针与结构体
guanguan12319的博客
07-24 156
【GO 编程语言】指针与结构体
golang结构体指针
知行合一
07-20 2577
1、由于结构体是值类型,在方法传递时希望传递结构体地址,可以使用结构体指针完成，结合new(T)函数创建结构体指针 peo := new(People) //因为结构体本质是值类型,所以创建结构体指针时已经开辟了内存空间 fmt.Println(peo == nil) //输出:false //由于结构体中属性并不是指针类型,所以可以直接调用 peo.Name = "jeff" fmt.Println(peo)//输出:&{jeff 0} peo1:=peo peo1.Name="高级语言" fmt
9-Go基础：结构体与指针
qq23001186的博客
04-25 1042
目录一、结构体1 - 结构体创建与初始化2 - 结构体数组3 - 结构体切片4 - 结构体map5 - 结构体作为函数参数二、指针1 - 指针定义2 - 指针操作注意事项3 - 指针变量作为函数参数4 - 数组指针5 - 指针数组6 - 切片指针7 - 结构体指针8 - 多级指针（简单了解） 一、结构体 1 - 结构体创建与初始化 结构体概念：结构体是由一系列具有相同类型或不同类型的数据构成的数据集合 结构体应用场景：结构体可以很好地管理一批有联系的数据，使用结构体可以提高程序的易读性 结构体创建语法
惊，你不知道go语言结构体指针的三大方法使用详解！
w5025的博客
08-21 534
go语言结构体的巧妙运用一、引言二、三种方式三、区别四、不同场景下的使用五、需要用到变量进行赋值的时候使用六、懒加载使用 一、引言 go语言相比于Java多了指针的使用，因此在变量的使用上，更加灵活。但是巧妙的使用能避免内存的浪费！ 二、三种方式 var c1 *Config var c2 = &Config{} c3 := new(Config) 三、区别 上面的三种方式返回的都是指针，但是又有什么区别呢？ fmt.Println(reflect.TypeOf(c1),reflect.Ty
Go基础——指针、结构体
星辰
11-02 348
1、指针Go语言指针与C差不多，取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。变量是一种使用方便的占位符，用于引用计算机内存地址。一个指针变量可以指向任何一个值的内存地址，它所指向的值的内存地址在 32 和 64 位机器上分别占用 4 或 8 个字节，占用字节的大小与所指向的值的大小无关。当一个指针被定义后没有分配到任何变量时，它的默认值为 nil。每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。
Golang面向对象基础：方法与结构体
Golang的基本语法包括数据类型、变量定义、控制结构（如if、for、switch）、函数、结构体、面向对象（如方法和接口）、并发（goroutine和channel）、接口、导入和包管理、主函数（main）、初始化函数（init）以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值