go基础语法学习03

go基础语法学习03

1.类构建和成员函数

package main

import "fmt"

type Person struct {
	name string
	age  int
}

func (p Person) Eat() {
	fmt.Println(p.name, "is eating")
	p.name = "name1"	//这里p是对象的拷贝，修改p不会影响源对象
}

func (this *Person) Eat2() {
	fmt.Println(this.name, "is eating")
	this.name = "name2"	//这里this是指向源对象，修改this会影响源对象
}

func main() {
	tokey := Person{"tokey", 20}

	//用指针绑定成员函数，可以直接修改成员变量。
	//另一种方法绑定成员函数，用的是拷贝，修改之后不影响源对象。
	tokey.Eat()
	tokey.Eat2()
}

go没有class，但是可以用struct实现class的概念。

2.类继承

package main

import "fmt"

//基类
type Base struct {
	name string
	age  int
}

func (this *Base) print() {
	fmt.Println("this is base print")
}

//子类
type SubBase struct {
	Base    //继承时，直接写基类类型，没有字段名
	address string
	name    string
}

//属于类嵌套，不是继承
type Other struct {
	base  Base
	other string
}

func main() {
	//证明Other不是继承，SubBase是继承
	o := Other{}
	//o.print()	 编译报错
	fmt.Println(o)

	sub := SubBase{}
	sub.print()
	sub.name = "sub" //如果父类和子类出现同名字段，这样赋值是给子类中的字段赋值。
	sub.address = "address"
	sub.age = 20

	fmt.Println(sub)

	sub.Base.name = "base"

	fmt.Println(sub)

}

{{ 0} }
this is base print
{{ 20} address sub}
{{base 20} address sub}

3.类权限

1. 在go语言中，权限都是通过首字母大小写来控制的。
2. import中，如果包名不同，那么只有大写字母开头的才是public。
3. 对于类中的成员、方法，只有大写开头的才能在其他包中使用。

4.接口interface

package main

import "fmt"

func main() {
	//interface可以接受任意的数据类型，类似于void
	var i, j, k interface{}

	names := []string{"string", "name"}
	i = names
	fmt.Println("i代表切片数组:", i)

	age := 20
	j = age
	fmt.Println("j代表整形:", j)

	str := "hello"
	k = str
	fmt.Println("k代表字符串:", k)

	//check
	val, ok := k.(int)
	if !ok {
		fmt.Println("k不是int")
	} else {
		fmt.Println("k是int，值:", val)
	}

	//常用的场景：把interface当成一个函数的参数，使用switch来判断用户输入的不同类型
	array := make([]interface{}, 3)

	array[0] = 1
	array[1] = "hello"
	array[2] = true

	for _, val := range array {
		switch v := val.(type) {
		case int:
			fmt.Printf("int %d\n", v)
		case string:
			fmt.Printf("string %s\n", v)
		case bool:
			fmt.Printf("bool %v\n", v)
		default:
			fmt.Printf("error\n")
		}
	}

}

5.多态

package main

import "fmt"

//实现go多态，需要实现定义接口

//定义一个接口，注意接口类型是interface
type IAttack interface {
	//接口函数可以有多个，但是只能有函数模型，不能有实现
	Attack()
}

type PlayerObject struct {
	name  string
	level int
}

func (a *PlayerObject) Attack() {
	fmt.Println("PlayerObject", a.name, ", level is", a.level)
}

type BossObject struct {
	name  string
	level int
}

func (a *BossObject) Attack() {
	fmt.Println("BossObject", a.name, ", level is", a.level)
}

//定义一个多态的通用接口，传入不同的类型，实现不同的功能
func DoAttack(a IAttack) {
	a.Attack()
}

func main() {
	//var player interface{} //空接口
	var player IAttack //定义一个包含Attack接口的变量
	playerObject := PlayerObject{"player", 1}
	playerObject.Attack()

	bossObject := BossObject{"boss", 10}
	bossObject.Attack()

	//player 赋值为playerObject
	//接口赋值必须使用指针类型
	player = &playerObject
	player.Attack()
	player = &bossObject
	player.Attack()

	fmt.Println("---------------------------")
	DoAttack(&playerObject)
	DoAttack(&bossObject)

}

PlayerObject player , level is 1
BossObject boss , level is 10
PlayerObject player , level is 1
BossObject boss , level is 10
---------------------------
PlayerObject player , level is 1
BossObject boss , level is 10

go语言的多态不需要继承，只要实现相同的接口即可。

1. 定义一个接口，里面设计好需要的接口，可以有多个。
2. 任何实现了这个接口的类型，都可以赋值给这个接口，从而实现多态。
3. 多个类之间不需要有继承关系。
4. 如果interface中定义了多个接口，那么实际的类必须全部实现接口函数，才可以赋值。