GO-结构体(类似python中的类)

一.结构体有名属性

package main
import "fmt"
func main(){
    type sb struct {
        name string  //属性名,数据类型
        age int    //如果两个属性数据类型一样可以name,age int
    }
    //他有两个属性不一定要两个属性都进行赋值
    //位置进行传参{"you",11}
    //但是位置传参必须所有属性都传进去
    sb1 :=sb{name:"you",age:11}  //属性名:属性值
    
     
    fmt.println(sb1)  //{you 11}
    fmt.println(sb1.name) //you
}

二.结构体匿名属性

package main
import "fmt"
func main(){
    type sb struct {
         string  //数据类型
         int
    }
    sb1 :=sb{string:"you"}
    fmt.println(sb1)  //{you 0}
    fmt.println(sb1.string) //you
}

三.结构体方法

package main
import "fmt"

type sb struct {
}

//注意点不定义在main函数内
func (sb sb) speak() {   //func (结构体对象 结构体类型) 方法名(){}
    fmt.println("嗯")
}


func main(){
    wq :=sb{}
    wq.speak()
}

四.结构体嵌套

type hobby struct {
    name string
    id int
}
type person struct {
    name  string
    hobby   //结构体名称
}
func main(){
    a := person{name: "p1",hobby:hobby{name:"lol",id:1}}
    
    fmt.println(a.hobby.name) //如果名字有重名需要.结构体.属性
    
    fmt.println(a.id)//如果没有重名属性名会提升
    //fmt.println(a.hobby.id)你同样也可以这样获取
}

/*
个人理解可以把它理解成python中的类的继承,比如a继承b
type b struct {int}
type a struct {b}
但是也有不同之处,他两个类中的名字一样可以共存,而python中不行
*/

五.结构体为方法的参数且修改结构体的属性

package main
import "fmt"

type person struct {
    name  string
}

func changename(p *person,newname string){   //如果不是改变原来的类只传值可以穿结构体对象
    (*p.name) = newname  //也可以写成p.name=newname
}
func main(){
    a := person{name: "p1"}
    changename(&a,"ywy")
    fmt.println(a.name)
}

六.结构体为方法的参数不修改结构体的属性

package main
import "fmt"

type person struct {
    name  string
}

func changename(p person,newname string){   
    p.name = newname  
}
func main(){
    a := person{name: "p1"}
    changename(a,"ywy")
    fmt.println(a.name)
}

七.结构体类型断言

写法一:

package main
import "fmt"

type person struct {
    name  string
}
func test(a interface{}){
    _,err :=a.(*person)
    if !err{
        fmt.println("是person")
    }
}

func main(){
    a := person{name: "p1"}
    test(a)
}

写法二:

package main

import (
    "fmt"
)

type person struct {
    name string
}

func test(a interface{}) {
    switch a.(type) {   //如果要获取a的对象就astruct :=a.(type)
    case person:
        fmt.println("是person")
    default:
        fmt.println("不是person")
    }
}
func main() {
    a := person{name: "p1"}
    test(a)
}