Go学习第八章——面向“对象”编程（入门——结构体与方法）

已于 2023-10-25 20:30:26 修改
阅读量395 收藏
点赞数
文章标签： golang 学习 笔记 开发语言 后端
于 2023-10-25 18:02:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hai_helloyou/article/details/134040674
版权

Go面向“对象”编程（入门——结构体与方法）

Golang语言面向对象编程说明：

  1. Golang也支持面向对象编程(OOP)，但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。所以我们说Golang支持面向对象编程特性是比较准确的。
  2. Golang没有类(class)，Go语言的结构体(struct)和其它编程语言的类(class)有同等的地位，你可以理解Gelang是基于struct来实现OOP特性的。
  3. Golang面向对象编程非常简洁，去掉了传统OOP语言的方法重载、构造函数和析构函数、隐藏的this指针等等。
  4. Golang仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其它OOP语言不一样，比如继承:Golang没有extends 关键字，继承是通过匿名字段来实现。
  5. Golang面向对象（OOP）很优雅，OOP本身就是语言类型系统(type system)的一部分，通过接口(interface)关联，耦合性低，也非常灵活。后面同学们会充分体会到这个特点。也就是说在Golang中面向接口编程是非常重要的特性。

1 结构体

1.1 快速入门

假设定义结构体是老师，属性：名字，年龄，学校

type Teacher struct {
	//变量名字大写外界可以访问这个属性
	Name   string
	Age    int
	School string
}

下面我们尝试赋值，并打印出来：

type Teacher struct {
	//变量名字大写外界可以访问这个属性
	Name   string
	Age    int
	School string
}

func main() {
	var tea1 Teacher
	tea1.Name = "张三"
	tea1.Age = 28
	tea1.School = "深圳大学"
	fmt.Println("tea1=", tea1)

	fmt.Println("老师的信息如下：")
	fmt.Println("name=", tea1.Name)
	fmt.Println("age=", tea1.Age)
	fmt.Println("school=", tea1.School)
}

输出结果：

tea1= {张三 28 深圳大学}
老师的信息如下：
name= 张三      
age= 28         
school= 深圳大学

通过上面的案例和讲解可以看出：

  1. 结构体是自定义的数据类型，代表一类事务。
  2. 结构体变量（实例）是具体的，实际的，代表一个具体变量。
1.2 内存解析

在Go语言中，结构体的存储是在堆上。

当我们创建一个结构体实例时，它的内存将被分配在堆上。这意味着结构体的生命周期可以超出创建它的函数的生命周期。

例如，当我们使用new关键字或make函数创建一个结构体实例时，它将被分配在堆上。

type Person struct {
    Name string
    Age  int
}

func main() {
    // 使用 new 关键字创建结构体实例
    p := new(Person)
    p.Name = "Alice"
    p.Age = 25

    // 使用 make 函数创建结构体实例（只适用于为某些类型分配内存，如 map、slice 和 channel）
    m := make(map[string]int)
    m["key"] = 42
    
    // 结构体实例被分配在堆上，可以在其他函数中继续使用
    anotherFunc(p)
    yetAnotherFunc(m)
}

这是因为在Go语言中，所有的变量都是通过传值而不是通过引用传递。在堆上分配结构体实例可以确保结构体数据的持久性和可用性。

image-20231025144249457

Go语言中结构体的内存布局

Go语言中的结构体是一组值的集合，这些值被存储在内存中的一段连续的区域。结构体的内存布局取决于结构体中的成员变量顺序和类型，以及对齐方式。

结构体的对齐方式

Go语言中使用的是一种称为Packing的方式进行对齐。这种方式默认对齐到最多8字节的倍数，即8字节对齐。可以通过在结构体成员变量的后面添加逗号和数字的形式手动调节对齐方式。

type Person struct {
	Name   string
	Age    int
	Height float64
}

func main() {
	var p Person

	// 获取结构体的大小
	size := unsafe.Sizeof(p)
	fmt.Printf("结构体大小：%d 字节\n", size)

	// 获取结构体字段的偏移量
	nameOffset := unsafe.Offsetof(p.Name)
	ageOffset := unsafe.Offsetof(p.Age)
	heightOffset := unsafe.Offsetof(p.Height)
	fmt.Printf("Name 字段的偏移量：%d 字节\n", nameOffset)
	fmt.Printf("Age 字段的偏移量：%d 字节\n", ageOffset)
	fmt.Printf("Height 字段的偏移量：%d 字节\n", heightOffset)

	// 结构体的对齐方式
	packed := unsafe.Alignof(p)
	fmt.Printf("结构体的对齐方式：%d 字节\n", packed)
｝

输出结果：

结构体大小：20 字节
Name 字段的偏移量：0 字节   
Age 字段的偏移量：8 字节    
Height 字段的偏移量：12 字节
结构体的对齐方式：4 字节

在这个示例中，我们定义了一个Person结构体，它包括名字、年龄和身高三个字段。我们通过unsafe包中的函数来获取结构体的大小、字段的偏移量以及对齐方式。结构体的大小为20字节，字段的偏移量分别为0字节、8字节和12字节，结构体的对齐方式为4字节。

1.3 创建结构体四种方法

基本介绍

  1. 从概念或叫法上：结构体字段 = 属性 = field
  2. 字段是结构体的一个组成部分，一般是基本数据类型、数组、也可以是引用数据类型。
  3. 指针，slice和map的零值都是nil，即还没有分配空间。

方式一：直接声明

案例：var person Person

方式二：{}

案例：var person Person = Person{“Tom”, 18} => person := Person{“Tom”, 18}

方式三：&

案例：var person *Person = new (Person)

type Person struct {
	Name string
	Age  int
}

func main() {
	var p *Person = new(Person)
	// (*p).Name = "smith" 标准写法
	// go设计者，为了程序使用方便，底层对下面这个做了优化，实现了这种简单的写法
	// 会给 p 加上 取值运算 =》 (*p).Name = "smith" 
	p.Name = "smith" 
	p.Age = 18
	fmt.Println(p)
	fmt.Println(*p)
}

输出结果：

&{smith 18}
{smith 18}

方式四：{}

案例：var person *Person = &Person{}

type Person struct {
	Name string
	Age  int
}

func main() {
	var p *Person = &Person{}
	// 标准方式：(*person).Name = "scott"
	p.Name = "scott"
	p.Age = 18
	fmt.Println(p)
}

输出结果：&{scott 18}

1.4 注意事项和使用细节
  1. 结构体的所有字段在内存中是连续的，指针本身的地址是连续的，但是指向的地址不一定是连续的。

image-20231025153910544

//结构体
type Point struct {
    x int
    y int
}

//结构体
type Rect struct {
    leftUp, rightDown Point
}

//结构体
type Rect2 struct {
    leftUp, rightDown *Point
}

func main() {

    r1 := Rect{Point{1,2}, Point{3,4}} 

    //r1有四个int, 在内存中是连续分布
    //打印地址
    fmt.Printf("r1.leftUp.x 地址=%p r1.leftUp.y 地址=%p r1.rightDown.x 地址=%p r1.rightDown.y 地址=%p \n", 
    &r1.leftUp.x, &r1.leftUp.y, &r1.rightDown.x, &r1.rightDown.y)

    //r2有两个 *Point类型，这个两个*Point类型的本身地址也是连续的，
    //但是他们指向的地址不一定是连续

    r2 := Rect2{&Point{10,20}, &Point{30,40}} 

    //打印地址
    fmt.Printf("r2.leftUp 本身地址=%p r2.rightDown 本身地址=%p \n", 
       &r2.leftUp, &r2.rightDown)

    //他们指向的地址不一定是连续...， 这个要看系统在运行时是如何分配
    fmt.Printf("r2.leftUp 指向地址=%p r2.rightDown 指向地址=%p \n", 
       r2.leftUp, r2.rightDown)
}

输出结果：

r1.leftUp.x 地址=0x9496080 r1.leftUp.y 地址=0x9496084 r1.rightDown.x 地址=0x9496088 r1.rightDown.y 地址=0x949608c
r2.leftUp 本身地址=0x948a038 r2.rightDown 本身地址=0x948a03c
r2.leftUp 指向地址=0x9496068 r2.rightDown 指向地址=0x94960a0

  1. 结构体之间可以转换，但是有要求，就是结构体的字段要完全一样（包括：名字、类型，个数）

    type A struct {
	Num int
}

type B struct {
	Num int
}

func main() {
	var a A
	var b B
	a = A(b)
	fmt.Println(a, b)
}

  2. 结构体进行type重新定义（相当于取别名），Golang认为是新的数据类型，但是相互间可以强转。

type Student struct {
	Name string
	Age  int
}

type Stu Student

func main() {
	var stu1 Student
	var stu2 Stu
	// stu2 = stu1 // 错误，系统认为这是两个不一样的类型
	stu2 = Stu(stu1)
	fmt.Println(stu1, stu2)
}

  1. struct的每个字段上，可以写上一个标签tag，该tag可以通过反射机制获取，常见的使用场景就是序列化和反序列化。

    type Student struct {
	Name string `json:"name"` // 这里就是结构体的标签tag
	Age  int    `json:"age"`
}

func main() {
	// 1.创建一个student变量
	student := Student{"张三", 18}
	// 2.将monster变量序列化为json格式字符串
	jsonStr, err := json.Marshal(student) // 这里json.Marshal底层用到了反射
	if err != nil {
		fmt.Println("jsonStr报错")
	}
	fmt.Println("jsonStr:", jsonStr)
	fmt.Println("string(jsonStr):", string(jsonStr))
}

    如果这里不加上标签，生成的json格式，就变成：string(jsonStr): {"Name":"张三","Age":18}

    会发现，这里的Name的首字母是大写，这又是不可避免，因为小写就调用不了

    所以这里通过标签，设置一个别名，底层用了反射解决这个问题~~~

    输出结果：string(jsonStr): {"name":"张三","age":18}

2 方法

在某些情况下，我们需要声明（定义）方法。比如Person结构体：除了有一些字段外(年龄，姓名…)，Person结构体还有一些行为。比如：可以说好，跑步，学习等，还可以做算术题。这时就要用方法才能完成

Golang中的方法是作用在指定的数据类型上的（即：和指定的数据类型绑定），因此自定义类型，都可以有方法，而不仅仅只是struct。

2.1 方法的声明和调用
type A struct {
    Num int
}

func (a A) test() {
    fmt.Println(a.Num)
}

对上面的语法说明：

  1. func (a A) test() {} 表示A结构体有一方法，方法名为 test
  2. (a A) 体现test方法是和A类型绑定的
type Person struct {
	Name string
}

func (p Person) test() {
	p.Name = "Tom"
	fmt.Println("test():", p.Name)
}

func main() {
	person := Person{Name: "张三"}
	person.test() // 调用方法
	fmt.Println("main p.Name=", person.Name)
}

输出结果：

test(): Tom
main p.Name= 张三

对上面的总结：

  1. test方法和Person类型绑定

  2. test方法只能通过Person类型的遍历来调用，而不能直接调用，也不嫩更实用其他类型变量来调用。

  3. func (p Person) test() {} 这个p是它的副本，进行的是值传递，与函数很像。

2.2 快速入门案例

  1. 给Person结构体添加speak 方法，输出 xxx是一个好人

    type Person struct{
	Name string
}

//给Person结构体添加speak 方法,输出  xxx是一个好人
func (p Person) speak() {
	fmt.Println(p.Name, "是一个goodman~")
}

  2. 给Person结构体添加jisuan 方法,可以计算从 1+…+1000的结果,

    type Person struct {
	Name string
}

func (p Person) jisuan() {
	res := 0
	for i := 1; i <= 1000; i++ {
		res += i
	}
	fmt.Println(p.Name, "计算的结果是=", res)
}

func main() {
	p := Person{Name: "张三"}
	p.jisuan() // 输出：张三 计算的结果是= 500500
}

  3. 给Person结构体jisuan2 方法,该方法可以接收一个参数n，计算从 1+…+n 的结果

    type Person struct {
	Name string
}

// 给Person结构体jisuan2 方法,该方法可以接收一个参数n，计算从 1+..+n 的结果
func (p Person) jisuan2(n int) {
	res := 0
	for i := 1; i <= n; i++ {
		res += i
	}
	fmt.Println(p.Name, "计算的结果是=", res)
}

func main() {
	p := Person{Name: "张三"}
	p.jisuan2(10) // 输出：张三 计算的结果是= 55
}

  4. 给Person结构体添加getSum方法,可以计算两个数的和，并返回结果

    type Person struct {
	Name string
}

// 给Person结构体添加getSum方法,可以计算两个数的和，并返回结果
func (p Person) getSum(n1 int, n2 int) int {
	return n1 + n2
}

func main() {
	p := Person{Name: "张三"}
	sum := p.getSum(1, 1)
	fmt.Printf("%v sum=%v", p.Name, sum) //输出：张三 sum=2
}
2.3 调用机制和传参原理

说明：方法的调用和传参机制和函数基本一样，不一样的地方是方法调用时，会将调用方法的变量，当作实参也传递给方法。下面举例说明：

案例：

image-20231025165316278

type Person struct {
	Name string
}

// 给Person结构体添加getSum方法,可以计算两个数的和，并返回结果
func (p Person) getSum(n1 int, n2 int) int {
	return n1 + n2
}

func main() {
	p := Person{Name: "张三"}
	n1 := 10
	n2 := 20
	res := p.getSum(n1, n2)
	fmt.Println("res=", res)
}
  1. 在通过一个变量去调用方法时，其调用机制和函数一样
  2. 不一样的地方是，变量调用方法时，该变量本身也会作为一个参数传递到方法（如果变量是值类型，则进行值拷贝，如果是引用类型，则进行地质拷贝）
2.4 注意事项和细节
  1. 结构体类型是值类型，在方法调用中，遵守值类型的传递机制，是值拷贝传递方式
  2. 如果程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理
  3. Golang中的方法作用在指定的数据类型上的(即: 和指定的数据类型绑定),因此自定义类型，都可以有方法，而不仅仅是struct，比如int ,float32等都可以有方法
  4. 方法的访问范围控制的规则，和函数一样。方法名首字母小写，只能在本包4访问，方法首字母大写，可以在本包和其它包访问。
  5. 如果一个类型实现了String这个方法，那么fmt.Println默认会调用这个变量的String()进行输出

上面这些注意事项都比较简单，就代码展示一下最后一条：

type Student struct {
	Name string
	Age  int
}

// 给*Student实现方法String()
func (stu *Student) String() string {
	str := fmt.Sprintf("Name=[%v] Age=[%v]", stu.Name, stu.Age)
	return str
}

func main() {
	//定义一个Student变量
	stu := Student{
		Name: "tom",
		Age:  20,
	}
	//如果你实现了 *Student 类型的 String方法，就会自动调用
	fmt.Println(stu)
	fmt.Println(&stu)
}

输出结果：

{tom 20}
Name=[tom] Age=[20]
2.5 方法和函数区别
  1. 调用方式不一样
  • 函数的调用方式：函数名（实参列表）
  • 方法的调用方式：变量.方法名（实参列表）
  1. 数据传递的限制不一样
  • 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然。
  • 对于方法（如struct的方法），接收者为值类型时，可以直接用指针类型的遍历调用方法，反过来同样也可以。

这一点很容易迷糊，下面用段代码解释一下：

type Person struct {
    Name string
}

//函数
//对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然

func test01(p Person) {
    fmt.Println(p.Name)
}

func test02(p *Person) {
    fmt.Println(p.Name)
}

//对于方法（如struct的方法），
//接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以

func (p Person) test03() {
    p.Name = "jack"
    fmt.Println("test03() =", p.Name) // jack
}

func (p *Person) test04() {
    p.Name = "mary"
    fmt.Println("test03() =", p.Name) // mary
}

func main() {

    p := Person{"tom"}
    test01(p)
    test02(&p)

    p.test03()
    fmt.Println("main() p.name=", p.Name) // tom

    (&p).test03() // 从形式上是传入地址，但是本质仍然是值拷贝

    fmt.Println("main() p.name=", p.Name) // tom

    (&p).test04()
    fmt.Println("main() p.name=", p.Name) // mary
    p.test04()   // 等价 (&p).test04 , 从形式上是传入值类型，但是本质仍然是地址拷贝
}

输出结果：

tom
tom
test03() = jack
main() p.name= tom
test03() = jack
main() p.name= tom
test03() = mary
main() p.name= mary
test03() = mary

从代码会发现，仅管传递的是一个地址，但是编译器进行了内部优化，实际上还是值传递，只是支持这种写法，但并不是进行一个地址值的修改。

3 工厂模式

说明：Golang的结构体没有构造函数，通常可以使用工厂模式来解决这个问题

相当于，这个工厂模式，就是以前构造函数的功能。

看个需求：

一个结构体的声明如下:

package model

type Student struct {
	Name string
}

因为这里的 Student 的首字母S是大写的，如果我们想在其他包串接Student的实例（比如：main包），引入model包后，就可以直接创建Student结构体的变量（实例）。

但是问题来了，如果搜字母是小写的，比如是： type student struct {…}就不行了，咋办？-》工厂模式来解决，

Model包

package model

type student struct {
	name  string
	score float64
}

// 因为student结构体首字母是小写，因此是只能在model使用
// 通过工厂模式来解决
func NewStudent(n string, s float64) *student {
	return &student{
		name:  n,
		score: s,
	}
}

// 如果score字段首字母小写，则，在其他包不可以直接方法，我们可以提供一个方法
func (s *student) GetScore() float64 {
	return s.score
}

// 如果score字段首字母小写，则，在其他包不可以直接方法，我们可以提供一个方法
func (n *student) GetName() string {
	return n.name
}

main包

import (
	"GoStudy_Day1/model"
	"fmt"
)

func main() {
	// 定student结构体是首字母小写，我们可以通过工厂模式来解决
	stu := model.NewStudent("Tom", 88.8)
	fmt.Println(stu)
	fmt.Println(*stu)
	// fmt.Println("name=", stu.name) // 报错，因为是私密的
	fmt.Println("name=", stu.GetName())
	fmt.Println("score=", stu.GetScore())
}

输出结果：

&{Tom 88.8}
{Tom 88.8}
name= Tom
score= 88.8

其实，这就看出来，就是Java的GetSet，绕了一圈，又回来啦~~~！！！！！

XiaoZhi-paperfly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大家一起学Golang——结构体、方法
01-07
大家一起学Golang——结构体、方法 结构体类型 空结构体 结构体标签 匿名字段 方法 重写 结构体类型 结构体类型通过一系列的且唯一的字段来声明。在go中数组切片只能存储同一类型的数据，但结构体用户可以自定义将...
Go语言基础之面向对象编程
01-07
Go语言并没有沿袭传统面向对象编程中的诸多概念 封装：通过方法实现 继承：通过匿名字段实现 多态：通过接口实现 一、匿名组合 1. 匿名字段 匿名字段（嵌入字段）： go支持只提供类型，而不写字段名的方式 匿名字段...
Go学习第九章——面向“对象”编程（三大特性与接口和断言）
Hai_Helloyou的博客
10-26 362
徐徐渐进，详细讲解，面向“对象”编程（三大特性与接口和断言）
Go入门系列（十） go中的面向对象编程——方法
jqsfjqsf的博客
02-15 200
本系列文章目录 展开/收起 Go入门系列（一） 初识Go语言 Go入门系列（二） 变量、指针、数据类型简介和作用域 Go入门系列（三） 基础类型——整型、浮点型、布尔类型和字符串 Go入门系列（四） 数组Array和切片Slice Go入门系列（五） 哈希表map Go入门系列（六） 结构体s...
《Go Web编程实战派——从入门到精通》学习笔记之第1章 Go基础入门
yxqq378287007的博客
08-20 2809
《Go Web编程实战派——从入门到精通》学习笔记之第1章 Go基础入门
Go学习第七章——数组arr，切片slice和映射map
Hai_Helloyou的博客
10-24 309
当负载因子超过一定阈值时，map 会重新分配更大的内存空间，将已有的元素重新哈希到新的内存位置上，并拷贝到新的底层数组中。由于哈希表是按照 key 所计算的哈希值来访问元素的，因此访问元素的速度是非常快的，不会因为 key 的顺序而降低速度。此外，由于底层数组存储的是键值对，而不是一个个具体的元素，所以在空间占用上，与 key 的顺序无关，可以充分利用底层数组的空间。map 的底层实现是哈希表，哈希表对 key 进行哈希运算，将 key 映射到底层数组的某个位置上，并存储对应的 value。
Go 语言学习总结（6）—— 学习 Golang 从零到大师
科技D人生
02-18 935
Pic: Gopher mascot and old logo 让我们从Go（或Golang）的简短介绍开始。 Go 是由 Google工程师 Robert Griesemer，Rob Pike 和 Ken Thompson 设计的。 它是一种静态类型的编译语言。 第一个版本于 2012 年 3 月作为开源发布。 " Go 是一种开放源代码编程语言，可轻松构建简单，可靠且高效的软件"。 — GoLang 在许多语言中，有很多方法可以解决给定的问题。 程序员可能会花费大量时间来思考解决问题...
Go语言入门之路——数据结构
qq_73924465的博客
01-28 707
Go语言入门攻略，万字张文，go语言基本数据结构，一文即可！！！！
100天精通Golang（基础入门篇）——第3天：Go语言的执行原理及常用命令、编码规范和常用工具
热门推荐
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
06-07 5万+
本文通过介绍Go语言的执行原理和常用命令，帮助读者全面了解Go的工作原理和常用命令的使用。同时，详细解释了Go编码规范的各个方面，包括命名规范、注释规范和代码风格。此外，还介绍了一些常用的工具，以提升开发效率和代码质量。通过学习本文，读者可以更好地掌握Go语言的使用技巧和开发规范。
go+vue——go入门
zsssss333的博客
04-12 1710
看到有人推【七米】，所以。。。
Go入门系列（六） 结构体struct
jqsfjqsf的博客
02-15 466
本系列文章目录 展开/收起 Go入门系列（一） 初识Go语言 Go入门系列（二） 变量、指针、数据类型简介和作用域 Go入门系列（三） 基础类型——整型、浮点型、布尔类型和字符串 Go入门系列（四） 数组Array和切片Slice Go入门系列（五） 哈希表map Go入门系列（六） 结构体s...
第8章 自制容器——结构体和枚举1
08-08
第八章 自制容器——结构体和枚举第一节：结构体的使用第二节：typedef运算符第三节：结构体与数组第四节：结构体与函数第五节：枚举类型第六节：联合体第七节：结
用C语言实现面向对象编程
12-22
一、类的封装实现：借用高焕堂的宏... 　类的封装实质是用借用 struct 结构体，用函数指针来表示 C++中类的方法（成员函数）。接下来给类 A 的方法写实体函数。 void init_A(void *t，int x) { A *cthis = (A
go 面向对象编程-2
01-06
面向对象编程思想-抽象 定义一个结构体的时候，实际上就是把一类事物的共有的属性(字段)和行为（方法）提取出来，形成一个物理模型(结构体). 这种研究问题的方法称为抽象 package main import ( fmt ) type ...
Golang：二进制数据的Base64编码和解码操作
彭世瑜的博客
05-17 171
Base64可以将二进制数据编码为文本数据，比如将二进制格式的图片编码为文本存储。前面的部分，是存储了二进制数据的格式，并非base64编码后的结果。这个文本格式可以在浏览器中直接打开。
golang template: “xxx.html“ is an incomplete or empty template 解决方法
05-15 142
这个异常一般是因为在使用 template.New("xxx.html") 时这里的名称非真实存在的视图文件名导致， 这个地方有点坑， 明明ParseFiles函数已经指定了视图路径了，而这里的New里面的名字居然还必须是你后面指定的视图路径中的文件名！
【博客714】golang使用mmap来优化gc
最新发布
qq_43684922的博客
05-21 134
需要处理的对象非常多时，比如：时序数据库victoriametrics源码中，利用了mmap申请内存并自己维护，从而避免过多gc影响性能，因为频繁申请和释放堆对象会降低性能。
JAVA 转 Golang——速通 Golang 基础
只会写bug的靓仔的博客
05-18 643
根据鼠鼠的实习投递经历，由于越来越多中大型公司都使用 Golang，在现在这个越来越内卷的后端就业环境下，学习一下 Golang 拓宽技术栈面是必须的，下面就跟着鼠鼠进行一些基础知识点的比较和学习吧。
C++面向对象——类/抽象 图解
09-03
在面向对象的编程中，C语言并不直接支持类和抽象的概念。引用中提到，final关键字用来修饰方法，表示该方法不能在子类中被覆盖。而abstract关键字用来修饰抽象方法，表示该方法必须在子类中被实现。然而，在C语言中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值