人生苦短，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\n", 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\n",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\n",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!

巴特西

Let's GO(三）

人生苦短，Let's GO

今天我学了什么？

1. 结构体(struct)

2、方法（Method）和接收者

3. 组合与继承

4.接口(interface)

总结：

最新文章

热门文章

巴特西

Let's GO(三）

人生苦短，Let's GO

今天我学了什么？

1. 结构体(struct)

2、方法（Method）和 接收者

3. 组合与继承

4.接口(interface)

总结：

最新文章

热门文章

2、方法（Method）和接收者