Let's GO(三）

人生苦短，Let's GO

• Let's GO(一)
• Let's GO(二)
• Let's GO(三)
• Let's GO(四)

今天我学了什么？

1. 结构体(struct)

/*
type TYPENAME struct {
name type
...
}
*/

type person struct { 
	name, city string  //这里上下类型的位置最好对上，可以使用go fmt完成代码格式化
	age               int8
}
//1.定义
var p1 person
p1.name = ""
...
//2.定义并赋值
p2 := person{
	name: " "   //name:可以略去,此时必须初始化所有字段且与定义顺序一致
	city: ""
	age:20
}
//3.
var p3 = new(person) //p3:=&person{}
(*p3).name = ""
p3.city="" //可以直接调用指针结构体中的字段

匿名类

var user struct {
		name string
		age  int
}
user.name = "Joko"
user.age = 80
fmt.Printf("p1:%#v
", user)

2、方法（Method）和 接收者

方法就是类内函数，也不知道go是怎么神奇的将零散的方法整合成一个大结构
接收者是一个我没听说过的概念，学习之后感觉作用类似与this指针

//构造函数,习惯上命名为NewStructName
func NewPerson(name string,age int) *Person  { 
	return &Person{
		name:name,
		age:age,
	}
}

//(p Person)就是接收者啦，惯例取类第一个字母小写为名，这里是值接收者
func (p Person) Dream()  {
	fmt.Printf("%s is dreaming
",p.name)
}

//指针接收者在修改内部数据上更有优势（自己声明的this)
func (p *Person) SetAge(age int) {
	p.age = age
}

3. 组合与继承

Go的官方回应Go是否为面对对象语言时表示yes and no,
yes ：Go 具备很多面对对象的特性
no：但Go又不像C++或Java那么强硬的封装

type Address struct {
	city string
}

type Person2 struct {
	name string
	age int
	Address //Address类以匿名类形式进行组合
}

p2 := Person2{
		name:    "JOKO",
		age:     10,
		Address: Address{"hk"},
	}
fmt.Printf("%#v
",p2)
fmt.Println(p2.city)  //直接访问匿名结构体字段,前提是不存在字段冲突
//如果不使用匿名类调用方式：p2.Address.city

type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s move",a.name)
}

type Dog struct {
	feet int
	*Animal
}

func (d *Dog) wang()  {
	fmt.Printf("%s www",d.name)
}

d.wang()
d.move()

继承与多态，但是没有任何明确的说继承这个字眼

4.接口(interface)

接口其他都不管，就认方法，实现方法就是实现了接口。

type sayer interface {
	say()
}

func (p Person) say() {
	fmt.Println("Hi")
}
//实现接口
func sayHi(arg sayer)  {
	arg.say()
}

type Sayer interface {
	say()
}

//实现多个接口
type Runer interface {
	run()
}

//接口嵌套
type animal interface {
	Sayer
	Runer
}

空接口 interface{}
神奇的一个东西：任何类型都实现空接口，所以空接口可以存储任意类型值
这是Go的泛型？

type xxx interface {
}

var x interface{}  //直接声明空接口变量x
x = "Hello"        //x 可以实现任意变量
fmt.Println(x)
x = 123
fmt.Println(x)
x = false
fmt.Println(x)

var m = make(map[string]interface{},16)
m["name"] = "Pallava"
m["age"] = 18
m["hobby"] = []string{"sing","jump","rap"}
fmt.Println(m)

//断言：判断空接口存的值的类型
ret,ok:= x.(bool)
if !ok {
	fmt.Println("not bool")
} else {
	fmt.Println("is bool",ret)
}

总结：

很明显，Go的语言出乎意料的精炼高效，像开发python一样愉快的开发C++般功能的项目。
希望Go越来越强大（后浪！）
那么朋友，人生苦短，Let's GO!