GO语言小锤硬磕.十八 类和面向对象

定义一个类。go语言定义类通过结构体来实现

 不通过包中变量、函数、方法、类型公私问题

        go语言通过首字母大小写来控制变量、函数、方法、类型的公私有

        如果首字母小写，那么代表私有，仅在当前包中可以使用

        如果首字母大写，代表共有，其他包中也可以使用

package demo
import "fmt"

var num1 int =123 //私有 当前包可用
var Num1 int =123 //公有 其他包中也柯永刚

type person struct{    //私有
    name string    
    age int        
}

type Student struct { //公有
    Name string
    Age int
}

封装（类是数据与功能的封装，数据是成员白能量，功能是方法）

        将成员变量隐藏起来，通过set和get方法实现对成员变量的访问，提高安全性和灵活性

package model
import "fmt"
type Person struct{    //其他包可用
    name string     //当前包可用
    age int 
}

func (p *person)SetAge(age int){
    //安全校验
    if age < 0{
        fmt.Println("年龄不能为负数")
    }
    p.age = age
}


package main
import (
    "fmt"
    "main/model"
)
func main(){
    //p := model.Person{"lnj",18} 报错name和age不公开
    
    //方式一
    p:= model.Person{}
    p.SetAge(18)

    //方式二
    p := new(model.Person)
    p.SetAge(18)
    //封装的原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，剔骨工公共的方法对其校验访问
}

继承  

        go语言坚持“组合优于继承”的原则，所谓的继承其实是利用结构体的组合实现的（匿名结构体属性）

普通继承(组合)

        

package main
import "fmt"
type Person struct{
    name string
    age int
}
type Student struct{
    Person    //学生继承了人的特性
    score int
}
type Leader struct{    //小组站继承学生 多重继承
    Student
    countx int 
}

type Teacher struct{
    Person //老师继承了人的特性
    name string //出现了重名
    Title string
}

func main(){
    s := Student{Person{"lnj",18},99}
    fmt.Println(s.name)    
    fmt.Println(s.Person.name) //两种都可以访问

    //如果继承结构中出现了重名，采用就近的原则
    t := Teacher(Person("llll",22),"bbbb","数学")
    fmt.Println(t.Person.name)    //llll
    fmt.Println(t.name)        //bbbb

    //多重继承
    l := Leader(Student{Person{"lnj",18},99},10)
    //访问仿古式同上，可按层级访问，也可直接访问多重继承中的属性


}

方法的继承

package main
import "fmt"
type Person struct{
    name string
    age int
}
//父类方法
func (p Person)say(){
    fmt.Println("name is",p.name,"age is",p.age) 
}
//定义一个
type Student struct{
    Person
    score float32
}

type Teacher struct{
    Person
    Title string
}
func (t Teacher)say(){
    fmt.Println("say ok")
}


func main(){
    stu := Student{Person{"zs",18},60}
    stu.say()    //继承了父类的方法

    t := Teacher{Person{"xiao",20},"ok"}
    t.say()
    t.Person.say() //和属性一下方法同名时可以通过指定父类名称的方式访问父类方法
}

无论是属性还是方法继承，都只能子类访问父类，不能父类访问子类

多态 （go语言的多态采用接口来实现,类实现了接口的所有方法，就可以通过接口类传递结构体类)

        多态的优点

    多态简化了编程接口，允许类和类之间重用一些习惯性的命名，不用为每个新的方法命名新名字

     多态优化了参数传递，提高了代码复用性

 多态是某一事物的多种形态

        猫-》动物        狗-》动物

        男人-》人        女人-》人

package main
import "fmt"
//1.定义接口
type Animal interface{
    Eat()
}

type Dog struct{
    name string
    age int
}
//实现接口方法
func (d Dog)Eat(){
    fmt.Println(d.name ,"在吃")
}

type Cat struct{
    name string
    age int
}
//实现接口方法
func (c Cat)Eat(){
    fmt.Println(c.name."在吃")
}
//猫特有的方法
func (c Cat)WashFace(){
    fmt.Println(c.name."洗脸")
}

func main(){
    
    var a Animal            //定义一个接口变量
    a = Dog{"旺财",18}      //传入类
    a.Eat()                 

    a= Cat{"喵喵",18}
    a.Eat()

    //调用cat 的特有方法
    if cat,ok := a.(Cat);ok{
        cat.WashFace()
    }
    
}