go复杂数据类型 结构体

前言：

Go 语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。

通过结构体的方式来实现了面向对象 ，去除了传统的oop语法，继承，重载，构造，析构，隐藏this的特性，

仍然有面向对象三大特性,实现和面向对象方法有所不同，没有extends关键字 ,

结构体的内嵌配合接口比面向对象具有更高的扩展性和灵活性,耦合度低。

 

正文：

结构体定义格式：

type 类型名 struct {
     字段1 类型
     字段2 类型
    …
}

 

注意：结构体中的属性，可以为其赋值，也可以不赋值，是具有默认值的

 

结构体定义示例1：

 

type User struct {  // 定义结构体

name           string //定义变量

age            int

email, address string //定义多个变量

}

func main()  {

var user User         //结构体实例化

user.name = "lampol" //结构体成员赋值

user.age = 23

user.email = "ad6546@qq.com"

fmt.Println(user)         //输出 {lampol 23 ad6546@qq.com }

fmt.Printf("%T", user) //输出 main.User

}

结构体也可以通过new关键字，实例化，

使用new实例化后，变成指针结构体，返回结构体对应的指针

 

结构体定义实例化2： 使用new关键字

user := new(User)    //结构体实例化2

user.name = "lampol" //结构体成员赋值

user.age = 23

user.email = "ad6546@qq.com"

fmt.Println(user)      //输出 &{lampol 23 ad6546@qq.com }  

fmt.Printf("%T", user)  //输出 *main.User 表示指针结构体

 

结构体赋值：实例化的时候，并赋值

方式1：通过键值对

user := User{

name:  "lampol",

age:   23,

email: "342121@qq.com",

}

fmt.Println(user)      //输出 {lampol 23 ad6546@qq.com }

 

方式2：按顺序写

user := User{

"lampol",

23,

"1341234@qq.com",

"北京路118号",

}

fmt.Println(user)      //输出 {lampol 23 ad6546@qq.com }

 

结构体成员类型可以为切片类型，map类型，结构体

成员类型为切片和map：

 

type User struct {

Name    string

Lan      []string   //切片类型

Address map[string]string  //map类型

}

 

使用：

var u User

u.Name = "lampol"

 

u.Lan = make([]string, 2, 5) //切片实例化

u.Lan[0] = "PHP"

u.Lan[1] = "Go"

 

u.Address = make(map[string]string) //map实例化

u.Address["pro"] = "江苏省"

u.Address["city"] = "南京市"

fmt.Println(u)  //输出：{lampol [PHP Go] map[city:南京市 pro:江苏省]}

fmt.Printf("%T", u) //输出：main.User

 

结构体成员类型为结构体，即可实现结构体的继承

 

type Address struct {

Mobile string

Pro    string

City   string

}

type User struct {

Name    string

Address Address

}

 

使用：

var u User //实例化

u.Name = "lampol"

 

u.Address.Mobile = "13355556666" //结构体成员赋值

u.Address.Pro = "江苏省"

u.Address.City = "南京市"

 

fmt.Println(u)   //输出{lampol {13355556666 江苏省 南京市}}

fmt.Printf("%T", u) //输出 main.User

 

结构体方法：

go中结构体的概念是一个个的类。既然是类，对象，那么就有各种操作方法。

 

结构体方法定义如下：在方法名前，增加结构体对象

 

type User struct {

Name string

}

// 定义结构体方法

func (u User) eat(addr string) string {

fmt.Println(u.Name, "去", addr, "eat....")

return u.Name + "去" + addr + "eat...."

}

调用：通过对象调用方法

var u User //实例化  

u.Name = "lampol"

res := u.eat("福州")  //调用方法 输出：lampol 去 福州 eat....

fmt.Println(res) //福州 lampol去福州eat....

 

 

结构体的继承：

结构体嵌套另一个匿名结构体，那么这个结构可以直接访问匿名结构体的方法，

从而实现了继承

 

结构体继承示例：

 

//父结构体

type Person struct {

Name string

Age  int

}

//父结构体方法

func (p Person) run(h int) {

fmt.Println(p.Name, p.Age, h, "run.....")

}

 

type Male struct {

Height int

Person  //将父结构体加入到子结构体成员中实现继承

}

调用：

m := Male{

Height: 170,

Person: Person{

Name: "lampol",

Age:  30,

},

}

   //继承后可直接调用父结构体方法

m.run(m.Height)   //输出 lampol 30 170 run.....

//可直接调用父结构体属性

fmt.Println(m.Name,m.Age) //输出lampol 30

 

 

结构体构造函数

结构体构造函数，就是在创建结构体对象的时候，对成员变量进行初始化

 

结构体构造函数示例：

type User struct {

Name string

Age  int

}

//结构体初始化

func newUser(name string, age int) *User {

return &User{

Name: name,

Age:  age,

}

}

调用：

user1 := newUser("lampol", 35)  //通过结构体构造函数生成对象

fmt.Println(user1)  //输出 &{lampol 35}

 

user2 := User{  //通过直接赋值的方式生成对象

Name: "yangphp",

Age: 30,

}

fmt.Println(user2)  //输出 {yangphp 30}