九、Golang学习笔记：面向对象（上）

---

Golang中面向对象的知识，包括对象的创建、成员的使用、继承等等。

---

面向对象

面向过程：强调的是步骤、过程、每一步都是自己亲自去实现。

面向对象：通俗讲就是找一个专门做这个事的人来做，不用关心具体怎么实现的。面向过程强调的是过程、步骤。而面向对象强调的是对象。三大特征：封装、继承、多态。

类：抽象，是一系列事物的统称，具有相同的特征和行为。

对象：类的具体

匿名字段实现继承以及对象创建

//Golang语言通过结构体定义类
//与结构体相同，需要思想上的转变
type Student struct{
    //属性--成员
    //方法--函数
    id int
    name string
    age int
}
func mian(){
    var stu Student = Student{101,"张三",18}//对象创建
    var stu1 Student = Student{102,"李四",20}
}

继承：是一种类间关系，描述一个类从另一个类获取成员信息的类间关系。继承必定发生在两个类之间，参与继承关系的双方称为父类和子类。

父类提供成员信息，子类获取成员信息。

type Student struct{
    //属性--成员
    //方法--函数
	Person//匿名字段，只有类型，没有成员的名字
    score float64//独有的
}
type Teacher struct{
	Person
    salary float64
}
type Person struct{//父类
    //公共的
    id int
    name string
    age int
}
func main(){
    var stu Student = Student{Person{101,"张三",18},90}
    //部分初始化
    var stu Student = Student{score:90}   
    var stu Student = Student{Person:Person{id:101}}
}

成员操作

type Student struct{
    //属性--成员
    //方法--函数
	Person//匿名字段，只有类型，没有成员的名字
    score float64//独有的
}

type Person struct{//父类
    //公共的
    id int
    name string
    age int
}
func main(){
    //获取成员的值 对象名.成员
    var stu Student = Student{Person{101,"张三",18},90}
	var stu1 Student = Student{Person{102,"李四",18},80}
    
    //修改成员的值 对象名.成员=值
    stu.score = 100
    
    fmt.Println(stu.score)
    fmt.Println(stu1.score)
    fmt.Println(stu1.Person.id)//父类成员
    fmt.Println(stu1.id)//上面的简化写法    
    
}

指针类型匿名字段

type Student struct{
	*Person//指针类型匿名字段，只有类型，没有成员的名字
    score float64
}

type Person struct{//父类
    id int
    name string
    age int
}
func main(){
    var stu Student = Student{&Person{101,"张三",18},90}//取地址符号
    fmt.Println(stu.name)
}

多重继承

type Student struct{
	Person//匿名字段，只有类型，没有成员的名字
    score float64
}
type Person struct{//父类
    Object
    name string
    age int
}
type Object struct{
    id int    
}

func main(){
    var stu Student
    stu.age = 18
    fmt.Println(stu.Person.name)
    stu.Person.Object.id = 101
    stu.id = 101/简化写法
    fmt.Println(stu.Person.Object.name)
}

基本方法创建

type Int int//type为int类型指定了别名
func (a Int)TestInt(b Int) Int{
    return a+b
}
func main(){
    var num Int = 10
    var num1 Int = 20
    n := num.TestInt(20)//num给a，20给b
    n1 := num1.TestInt(5)
    fmt.Println(n)
    fmt.Println(n1)
}

为结构体添加方法

type Student struct{
	id int
    name string
    age int
}

//语法： func（对象 结构体类型）方法名（参数列表）（返回值列表）{代码体}
func (s Student) PrintShow(){//接收者
    fmt.Println(s)
}

func (s *Student) EditInfo(){
    s.age = 20
}

func main(){
    stu := Student{101,"张三",18}
    stu.PrintShow()//完成对方法的调用，将stu中的值，传递给了方法s
    stu.EditInfo()
    stu.PrintShow()//发现值并没有改变，需要给结构体类型加指针
}

使用方法注意事项：

1. 只要接收者类型不一样，就算方法同名，也不影响.
2. 接受者为指针

type Student struct{
	id int
    name string
    age int
}
type Teacher struct{
	id int
    name string
}
func (t *Teacher) Show(){//两个方法同名，但是接受类型不同
    fmt.Println(s)
}

func (s *Student) Show(){
    fmt.Println(s)
}
func main(){
    stu := Student{101,"张三",18}
    //（&stu）.Show()
    stu.Show()//简化
    teacher := Teacher{102,"老王"}
    teacher.Show()
}

方法继承

type Student struct{
	Person
    score float64
}
type Person struct{
	id int
    name string
    age int
}
func (p *Person) PrintInfo(){
    fmt.Println(*p)
}
func main(){
    stu := Student{Person{101,"张三",18},90}
    stu.PrintInfo()
}

方法重写

type Student struct{
	Person
    score float64
}
type Person struct{
    name string
    age int
}
func (p *Person) PrintInfo(){
    fmt.Println("这是父类中的方法")
}
func (p *Student) PrintInfo(){
    fmt.Println("这是子类中的方法")
}
func main(){
    var stu Student
    stu.PrintInfo()//如果父类中的方法名称与子类中的方法名称一致，那么通过子类的对象调用的是子类中的方法，这就是方法重写
    stu.Person.PrintInfo()//调用父类的方法
}

方法值与方法表达式

type Person struct{
    name string
    age int
}
func (p *Person) PrintInfo(){
    fmt.Println(*p)
}
func main(){
    per := Person("张三",18)
    per.PrintInfo()
    //方法值
    f := per.PrintInfo//没有()
    fmt.Printf("%T",f)//输出类型,结果：func（）
    f()//调用
    //方法表达式
    f := (*Person).PrintInfo//类的名字 与方法类型保持一致
    f(&per)
}