golang 中的结构体

## golang 结构体
golang 中没有"类"的概念，golang中的结构体和其他语言中的类有点相似。

## 结构体定义初始化的几种方法
### 结构体的定义
使用 type 和 struct 关键字来定义结构体，具体代码格式如下：
```
type 类型名 struct {
	字段名	字段类型
	字段名	字段类型
	...	
}
```
```
type Person struct {
	name string
	age int
	email string
	sex	string
}
```
结构体首字母可以大写也可以小写，大写表示这个结构体是公有的，在其他的包里也可以使用。小写表示私有的，只能在本包中使用。
### 结构体实例化(第一种方法)
```
var 结构体实例 结构体类型
```
```
type Prosen struct {
	name string
	age  int
	sex  string
}

func main() {
	var myPreson Prosen
	myPreson.name = "呵呵"
	myPreson.age = 20
	myPreson.sex = "man"

fmt.Printf("myPreson: %v\n", myPreson) //myPreson: {呵呵 20 man}
}
```
### 实例化结构体(第二种方法)
```
type Prosen struct {
	name string
	age  int
	sex  string
}

func main() {
	var myPreson = new(Prosen)
	myPreson.age = 30
	myPreson.name = "haha 2"
	myPreson.sex = "女"

fmt.Printf("myPreson: %#v\n", myPreson)
	//myPreson: &main.Prosen{name:"haha 2", age:30, sex:"女"}
}
```
### 实例化结构体(第三种方法)
```

type Prosen struct {
	name string
	age  int
	sex  string
}

func main() {
	var myPreson = &Prosen{}
	myPreson.age = 30
	myPreson.name = "haha 2"
	myPreson.sex = "女"

fmt.Printf("myPreson: %#v\n", myPreson)
	//myPreson: &main.Prosen{name:"haha 2", age:30, sex:"女"}
}
```

### 结构体实例化(第四种方法)
```
type Prosen struct {
	name string
	age  int
	sex  string
}

func main() {
	var myProsen = Prosen{
		name: "haha",
		age:  20,
		sex:  "女",
	}
	fmt.Printf("myProsen: %#v\n", myProsen)
	//myProsen: main.Prosen{name:"haha", age:20, sex:"女"}
}
```
## 结构体方法和接收者
在go语言中，没有类的概念但是可以给类型(结构体，自定义类型)定义方法。所谓方法就是定义了接收者的行数。接收者的概念就类似于其他语言中的this 或者 self。
方法的定义格式如下:
```
func (接收者变量 接收者类型) 方法名(参数列表) （返回参数）{
		函数体
}
```

```
type Preson struct {
	name string
	age  int
	sex  string
}

func (p Preson) printPresonInfo() {
	fmt.Printf("p.name: %v\n", p.name)
	fmt.Printf("p.age: %v\n", p.age)
	fmt.Printf("p.sex: %v\n", p.sex)
}

func main() {
	var p = &Preson{
		name: "lulu",
		age:  24,
		sex:  "man",
	}
	p.printPresonInfo()
}
```
### 使用 传入接收者类型的指针  来修改结构体内的变量

```
type Preson struct {
	name string
	age  int
	sex  string
}

func (p Preson) printPresonInfo() {
	fmt.Printf("p.name: %v\n", p.name)
	fmt.Printf("p.age: %v\n", p.age)
	fmt.Printf("p.sex: %v\n", p.sex)
}

func (p *Preson) SetPresonInfo(name string, age int, sex string) {
	p.name = name
	p.age = age
	p.sex = sex
}

func main() {
	var p = &Preson{
		name: "lulu",
		age:  24,
		sex:  "man",
	}
	p.printPresonInfo()

var p1 = &Preson{
		name: "修改前的名字",
		age:  20,
		sex:  "修改前的 性别",
	}
	fmt.Printf("p1: %v\n", p1)
	/*
		p1: &{修改前的名字 20 修改前的 性别}
	*/
	p1.SetPresonInfo("修改后的name", 50, "修改后的性别")
	fmt.Printf("p1: %v\n", p1)
	/*
		p1: &{修改后的name 50 修改后的性别}
	*/
}

```
## 给任意类型添加方法
## 嵌套结构体
```
type user struct {
	username string
	password string
	address  address
}
type address struct {
	city  string
	name  string
	phone string
}

func main() {

var user1 = new(user)
	var address = new(address)
	address.city = "china"
	address.name = "luoluo"
	address.phone = "156111181694"
	user1.username = "ssss"
	user1.address = *address
	fmt.Printf("user1: %v\n", user1)
	/*
		user1: &main.user{username:"ssss", password:"", address:main.address{city:"china", name:"luoluo", phone:"156111181694"}}
	*/

}
```
## 结构体的继承
```
type Animal struct {
	name string
}

func (a Animal) run() {
	fmt.Printf("%v 在跑\n", a.name)
}

type Dog struct {
	age int
	Animal
}

func (d Dog) tell() {
	fmt.Printf("%v 在叫  %v  %v岁\n", d.name, d.name, d.age)
}

func main() {
	var d = new(Dog)
	d.name = " haha"
	d.age = 20
	d.run() //因为 dog 嵌套了 animal 的结构体 ，所以 dog继承了 animal 的属性 和 方法
	d.tell()
}
```