九、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)
}

你可能感兴趣的:(Golang语言开发,golang,go,go语言,面向对象编程,编程语言)