【Golang】Go语言中如何面向对象?

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑

文章目录

Go语言怎样实现面向对象

Go语言（Golang）虽然不是一个纯粹的面向对象编程语言，但它通过结构体（Struct）、接口（Interface）等机制，提供了面向对象的编程范式。
在实际的项目开发中，使用面向对象的理念可以显著提高代码的可维护性、可扩展性和可复用性。

1. 面向对象的三大特性

面向对象编程（OOP）的核心思想是将数据和操作数据的行为封装到对象中，通过对象之间的交互来完成程序的功能。OOP具有三大特性：封装、继承、多态。

（1）封装

封装是指将某事物的属性和行为包装到对象中，这个对象只对外公布需要公开的属性和行为，而这个公布也是可以有选择性的。在Go语言中，封装主要通过结构体实现。

（2）继承

生活中的继承：

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

继承就是子类继承父类的特征和行为，使得子类具有父类的属性和方法，使得子类具有父类相同的行为。子类会具有父类的一般特性也会具有自身的特性。

java语言的继承，显示声明class User extends Person{
name
age
}
如此，当修改父类名称或者其中的方法，属性名称后，所有的子类的都得同步去改，比较麻烦

Go语言的继承：结构体的嵌套

Go语言中结构体嵌套，有两种方式
1、模拟继承 is - a
哪个结构体被继承(父类)，就将哪个结构体当做一个字段写到 子类结构体里面

type A struct{
      field
   }type B struct{
      A  // 匿名字段  B.A
      field
   }// B继承A，B是可以直接访问A的属性的

2、聚合关系 has - a

type C struct{
      field
   }type D struct{
      c C  //聚合关系，不使用匿名字段
      field
   }// D是无法直接访问C中的属性的，必须使用D.c.c_field

匿名字段方式继承

package main

import"fmt"// Person 定义一个父类type Person struct{
    name string
    age  int}// Student 定义一个子类，Student拥有了父类所有的属性，还有自己的特性type Student struct{
    Person // 父类以匿名字段形式作为子类的属性，实现了继承。
    school string}funcmain(){// 1、 创建父类对象
    p1 := Person{name:"jingtian", age:18}
    fmt.Println(p1)
    fmt.Println(p1.name, p1.age)// 2、创建子类
    s1 := Student{Person: Person{name:"小明", age:3}, school:"景天科技苑"}
    fmt.Println(s1)
    fmt.Println(s1.Person.name, s1.Person.age, s1.school)// 3、创建子类var s2 Student
    s2.Person.name ="张三"
    s2.Person.age =3
    s2.school ="北大"
    fmt.Println(s2)// 概念：提升字段, 只有匿名字段才可以做到// Person 在Student中是一个匿名字段， Person中的属性 name age 就是提升字段// 所有的提升字段就可以直接使用了，不需要再通过匿名字段点来获取了var s3 Student
    //字段提升，可以直接用子类对象操作父类字段
    s3.name ="李四"
    s3.age =4
    s3.school ="清华"
    fmt.Println(s3)
    fmt.Println(s3.name, s3.age)}

聚合方式叫组合，不再是继承了

package main

import"fmt"//聚合继承type Human struct{
    name string
    age  int}type Man struct{//聚合继承，不再以匿名字段形式将父类写在这，而是命名一个变量名
    Human Human
    phone string}funcmain(){//创建子类对象
    man := Man{
        Human: Human{"轩辕氏",999},
        phone:"19899999999",}
    fmt.Println(man)//访问父类属性，聚合继承不能使用变量提升。提升字段, 只有匿名字段才可以做到//聚合方式继承，访问父类属性需要写全，对象.变量名.父类字段名
    fmt.Println(man.Human.name)}

继承就是子类继承父类的特征和行为，使得子类具有父类的属性和方法，使得子类具有父类相同的行为。子类会具有父类的一般特性也会具有自身的特性。

匿名字段 + 提升字段：Go语言中的匿名字段。
当继承多个父类具有相同属性字段的时候，就不能再使用字段提升了，因为此时就不能确定使用的是哪个父类的属性。
此时就要加上父类.属性名

（3）多态

多态需要结合接口实现，由于篇幅限制，下一章接着更新，敬请期待！

2. 方法

（1）Go语言中的方法

Go语言中同时拥有函数和方法。一定要和其他只有方法的语言区分开

类：结构体->属性、方法?

Go语言实现方法

方法：需要指定调用者，约定这个方法属于谁的. 对象.方法()

函数：不需要指定调用者，定义了函数就可以直接函数名()调用

方法：可以理解为函数多了一个调用者
方法定义, func 方法调用者 方法名(){} 方法的定义比函数多了个调用者
定义中，函数与方法就不一样，函数是 func 函数名(参数) 返回值 返回值类型 {}
1、方法可以重名，只需要调用者不同
2、如果调用者相同，则不能重名

package main

import"fmt"// 方法：可以理解为函数多了一个调用者// 方法可以重名，不同的对象，调用的结果是不一样的type Dog struct{
    name string
    age  int}// 方法定义,   func 方法调用者  方法名()// 1、方法可以重名，只需要调用者不同// 2、如果调用者相同，则不能重名func(dog Dog)eat(){
    fmt.Println("Dog eating...")}func(dog Dog)sleep(){
    fmt.Println("Dog sleep...")}// 在Go语言中，fmt.Sprintf函数是一个非常实用的函数，它可以将一个字符串格式化为指定的格式。// 它的用途非常广泛，可以用来构建复杂的字符串，包括打印日志、生成报错信息等。// 带有参数和返回值的方法func(dog Dog)xiaohua(food string)string{//返回值字符串格式化return fmt.Sprintf("%v吃进了%s, 吐出来骨头", dog.name, food)}type Cat struct{
    name string
    age  int}func(cat Cat)eat(){
    fmt.Println("Cat eating...")}func(cat Cat)sleep(){
    fmt.Println("Cat sleep...")}funcmain(){// 创建一个对象
    dog := Dog{
        name:"旺财",
        age:2,}
    fmt.Println(dog)// 方法的调用，通过对应的结构体对象来调用
    dog.eat()//调用带有参数和返回值的方法
    back := dog.xiaohua("肉")
    fmt.Println(back)//不同对象调用同名方法
    cat := Cat{name:"喵喵", age:1}
    cat.eat()//打印查看方法所属类型，类型跟函数一样都是func()
    fmt.Printf("方法所属类型: %T\n", cat.eat)}

（2）方法与函数对比总结

方法：

• 某个类的行为功能，需要指定调用者
• 一段独立的代码功能，必须要使用调用者来调用
• 多个类的方法可以重名，单个类不行
• 方法是某个类的动作

函数：

• 一段独立的代码功能，可以直接调用
• 命名完全不能冲突
• 函数是一个特殊的类型

（3）方法的重写

需要和继承结合

子类可以重写父类的方法 override

子类还可以新增自己的方法

子类可以访问父类中的属性和方法
子类重写父类方法，方法名与父类方法相同，只是调用者改成了子类

package main

import("fmt")// 方法重写，建立在父类和子类结构上的type Animal struct{
    name string
    age  int}// 父类方法func(animal Animal)eat(){
    fmt.Println(animal.name," 正在吃....")}func(animal Animal)sleep(){
    fmt.Println(animal.name," 正在sleep....")}//父类更通用，子类更具体// 子类type Dog2 struct{
    Animal
}// 子类自己的方法func(dog Dog2)wang(){
    fmt.Println("wangwangwanwg~~~")}type Cat2 struct{
    Animal
    color string// 子类可以定义自己的属性}// 子类重写父类的方法 , 子类的方法名和父类同名，即可重写父类的方法func(cat Cat2)eat(){
    fmt.Println(cat.name," 正在吃cat....")}funcmain(){// 定义一个子类，使用父类方法
    dog := Dog2{Animal{name:"旺财", age:3}}
    dog.eat()// 调用父类的方法
    dog.wang()// 调用自己扩展的方法

    cat := Cat2{Animal{name:"煤球", age:3},"黑色"}
    cat.eat()// 如果重写了父类的方法就是调用子类自己的方法

    fmt.Println(cat.color)// 调用子类自己的属性// 子类可以操作父类的方法，父类可以操作子类的吗？不可以// 父类不能调用子类自己的扩展的方法
    a := Animal{name:"大黄", age:3}//父类调用与子类同名方法，只能调用到父类自己的方法，不能调用子类扩展后的方法
    a.eat()
    a.sleep()}

Go语言面向对象详细教程，更高级的应用，持续更新中，感兴趣的朋友可以关注下，ღ( ´･ᴗ･` )比心