前言：
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 = "[email protected]"
fmt.Println(user) //输出 {lampol 23 [email protected] }
fmt.Printf("%T", user) //输出 main.User
}
结构体也可以通过new关键字，实例化，
使用new实例化后，变成指针结构体，返回结构体对应的指针
结构体定义实例化2： 使用new关键字
user := new(User) //结构体实例化2
user.name = "lampol" //结构体成员赋值
user.age = 23
user.email = "[email protected]"
fmt.Println(user) //输出 &{lampol 23 [email protected] }
fmt.Printf("%T", user) //输出 *main.User 表示指针结构体
结构体赋值：实例化的时候，并赋值
方式1：通过键值对
user := User{
name: "lampol",
age: 23,
email: "[email protected]",
}
fmt.Println(user) //输出 {lampol 23 [email protected] }
方式2：按顺序写
user := User{
"lampol",
23,
"北京路118号",
}
fmt.Println(user) //输出 {lampol 23 [email protected] }
结构体成员类型可以为切片类型，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}
标签：user,string,复杂,fmt,数据类型,lampol,User,go,结构 From： https://www.cnblogs.com/ypeih/p/17281417.html