go10---struct

package main
 
import (
    "fmt"
)
 
type test struct{} //空的结构体
 
type person struct {
    name string
    age  int
}
 
type student struct { //结构体嵌套
    name    string
    age     int
    contact struct {
        phone, city string
        num         int
    }
}
 
type teacher struct { //匿名字段
    string
    int
}
 
func main() {
    a := test{}
    fmt.Println(a) //{}
 
    p := person{}
    fmt.Println(p) //{ 0}
    p.name = "joi"
    p.age =
    fmt.Println(p)      //{joi 19}
    fmt.Println(p.name) //joi
 
    p1 := person{
        name: "lll",
        age:  ,
    }
    fmt.Println(p1)      //    {lll 32}
    fmt.Println(p1.name) //lll
 
    A(p1)
    fmt.Println(p1.age) //32,值拷贝，不是引用传递
 
    A1(&p1)
    fmt.Println(p1.age) //888，指针传递，
 
    p2 := &person{ //p2就是指向结构体的地址了，以后和传递就是指针传递了，
        name: "kkk",
        age:  ,
    }
 
    A1(p2)
    p2.name = "OK"       //p2是一个地址，这里不需要用*p2 = "OK"
    fmt.Println(p2.name) //OK，
 
    b := struct { //匿名结构体
        name string
        age  int
    }{
        name: "uuu",
        age:  ,
    }
    fmt.Println(b) //{uuu 19}
 
    //匿名结构体
    c := &struct {
        name string
        age  int
    }{
        name: "eee",
        age:  ,
    }
    fmt.Println(c) //&{eee 29}
 
    d := student{}
    fmt.Println(d) //{ 0 {  0}}
    d = student{
        name: "dd",
        age:  ,
    }
    d.contact.city = "sity"
    d.contact.num =
    d.contact.phone = "phone" //里面的结构体只能够分部赋值
    fmt.Println(d)            //{dd 1 {phone sity 9}}
 
    e := teacher{"tec", } //依靠顺序传值
    fmt.Println(e)          //{tec 52}
    var e1 teacher
    e1 = e
    fmt.Println(e1) //{tec 52},结构体可以直接赋值
}
 
func A(per person) {
    per.age =
    fmt.Println(per.age) //
}
 
func A1(per *person) {
    per.age =
    fmt.Println(per.age) //
}

package main
 
/*
结构struct
 
Go 中的struct与C中的struct非常相似，并且Go没有class，
struct代替了class的位置但是没有代替class的功能，因为go没有继承的概念
使用 type <Name> struct{} 定义结构，名称遵循可见性规则
支持指向自身的指针类型成员
支持匿名结构，可用作成员或定义成员变量
匿名结构也可以用于map的值
可以使用字面值对结构进行初始化
允许直接通过指针来读写结构成员
相同类型的成员可进行直接拷贝赋值
支持 == 与 !=比较运算符，但不支持 > 或 <
支持匿名字段，本质上是定义了以某个类型名为名称的字段
嵌入结构作为匿名字段看起来像继承，但不是继承
可以使用匿名字段指针
 
*/
 
import (
    "fmt"
)
 
//实现继承,嵌入结构（组合）
type human struct {
    sex int
}
 
type teacher struct {
    human
    name string
    age  int
}
 
type student struct {
    human
    name string
    age  int
}
 
func main() {
    a := teacher{name: "teac", age: }
    b := student{name: "stud", age: }
    fmt.Println(a, b) //{{0} teac 32} {{0} stud 18}
 
    a1 := teacher{name: "teac", age: , human: human{sex: }}
    b1 := student{name: "stud", age: , human: human{sex: }}
    fmt.Println(a1, b1) //{{1} teac 32} {{1} stud 18}
    a1.age =
    a1.human.sex =   //a1.sex = 200也可以，因为human的字段就已经是teacher和student的属性了，
    fmt.Println(a1, b1) //{{100} teac 88} {{1} stud 18}
}

go语言没有class，struct就是go语言的class.