go学习笔记day2(1)

最新推荐文章于 2024-09-12 22:14:20 发布

牧牧牧牧牧

最新推荐文章于 2024-09-12 22:14:20 发布

阅读量98

点赞数

分类专栏：编程语言学习 # go

本文链接：https://blog.csdn.net/m0_37872998/article/details/114311704

版权

编程语言学习同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

4 篇文章 0 订阅

订阅专栏

文章目录

map

testMap:=make(map[string]string)//定义
delete(testMap,key)//删除

map在作为参数传递给函数时是传递的引用即指针，指向的是同一块内存地址的值

struct

type myint int //声明一种类型或结构体 该语句表示将int取别名为myint
type mystruct struct{
    a string
    b string 
}

结构体在做为参数传递时不是传递的指针，而是传递的副本

changeStruct(s mystruct){
    s.a = "golang"
}
var s mystruct
s.a = "python"
s.b = "d"
changeStruct(s)
/*
s.a还是等于 python
函数体修改为
changeStruct(s *mystruct)
changeStruct(&s)
此时修改之后的s.a = golang
*/

type Hero struct{
	Name string
	Ad int
	Level int
}
func (t Hero) Show(){
	fmt.Println(t)
}

func (t Hero) GetName() string{
	return t.Name
}

func (t *Hero) SetName(newName string) {
	t.Name = newName
}

func main(){
	hero := Hero{Name:"zhangsan",Ad:100,Level:1}
	hero.Show()
	name := hero.GetName()
	fmt.Println(name)
	hero.SetName("lishi")
	hero.Show()
}
/*
运行结果为
{zhangsan 100 1}
zhangsan
{lishi 100 1}
如SetName函数定义为如下
func (t Hero) SetName(newName string) {
	t.Name = newName
}
结果为
{zhangsan 100 1}
zhangsan
{zhangsan 100 1}
*/

结构体对象方法传值同结构体传值一样，不加指针传的是副本，加指针则是引用

继承

type Human struct{
	name string
	sex string
}

func (t *Human) Eat(){
	fmt.Println("eating")
}

func (t *Human) Walk(){
	fmt.Println("Walking")
}

type SuperMan struct{
	Human //结构体首位代表继承
	age int
}

// 重写父类方法
func (s *SuperMan) Eat(){
	fmt.Println("s->eating")
}

func(s *SuperMan) ShowAge(){
	fmt.Println(s.age)
}

func main(){
	h := Human{"zhang","female"}
	h.Eat()
	h.Walk()

	s := SuperMan{Human{"kelke","man"},100}
	s.Walk()
	s.Eat()
	s.ShowAge()
}
/*输出结果为
eating
Walking
Walking
s->eating
100
*/

多态

//定义接口，本质为指针
type Human interface{
	Say()
	GetCountry() string
	GetName() string
}

type Chinese struct{
	// Human
	country string
	name string
}

func (c *Chinese) Say(){
	fmt.Println("你好")
}

func (c *Chinese) GetCountry() string{
	return c.country
}

func (c *Chinese) GetName() string{
	return c.name
}

type British struct{
	country string
	name string
}

func (c *British) Say(){
	fmt.Println("hello")
}

func (c *British) GetCountry() string{
	return c.country
}

func (c *British) GetName() string{
	return c.name
}
func SayHello(human Human){
	human.Say()
	fmt.Println(human.GetCountry())
	fmt.Println(human.GetName())
}
func main(){
	var human Human
	human = &Chinese{"China","丁"}
	c := Chinese{"China","丁"}
	human.Say()
	fmt.Println(human.GetCountry())
	fmt.Println(human.GetName())
	fmt.Println("----------")
	human = &British{"English","lola"}
	e := British{"English","lola"}
	human.Say()
	fmt.Println(human.GetCountry())
	fmt.Println(human.GetName())
	
	fmt.Println("----------")
	// c.Say()
	// e.Say()
	SayHello(&c)
	
	fmt.Println("----------")
	SayHello(&e)
		
}
/*输出结果
你好
China
丁
----------
hello
English
lola
----------
你好
China
丁
----------
hello
English
lola
*/