Golang--面向对象

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

  • Golang也支持面向对象编程(OOP),但是和传统的面向对象编程有区别,并不是纯粹的面向对象语言。所以我们说Golang支持面向对象编程特性是比较准确的。
  • Golang没有类(class),Go语言的结构体(struct)和其它编程语言的类(class)有同等的地位,可以理解Golang是基于struct来实现OOP特性的。
  • Golang面向对象编程非常简洁,去掉了传统OOP语言的方法重载、构造函数和析构函数、隐藏的this指针等等
  • Golang仍然有面向对象编程的继承,封装和多态的特性,只是实现的方式和其它OOP语言不一样,比如继承:Golang没有extends 关键字,继承是通过匿名字段来实现。 

1、结构体

package main
import "fmt"//定义结构体
type Stu struct{//变量名字大写外界可以访问,小写外界不能访问Name stringAge intNum string
}func main(){//创建结构体实例var stu1 Stufmt.Println(stu1)//在未赋值时默认值:{ 0 }	stu1.Name = "张三"	stu1.Age = 18stu1.Num = "1001"fmt.Println(stu1)//创建结构体实例var stu2 Stu = Stu{"李四",19,"1002"}fmt.Println(stu2)//创建结构体实例var stu3 = Stu{"王五",20,"1003"}fmt.Println(stu3)//创建结构体实例stu4 := Stu{"赵六",21,"1004"}fmt.Println(stu4)//创建结构体实例   指针类型stu5 := &Stu{"田七",22,"1005"}fmt.Println(stu5)//创建结构体实例   指针类型stu6 := &Stu{"周八",23,"1006"}fmt.Println(stu6)//创建结构体实例stu7 := new(Stu)stu7.Name = "吴九"stu7.Age = 24stu7.Num = "1007"fmt.Println(stu7)
}

1.1 结构体实例创建

package main
import "fmt"//定义结构体
type Stu struct{//变量名字大写外界可以访问,小写外界不能访问Name stringAge intNum string
}func main(){//方式一:直接创建var s1 Stus1.Name = "张三"s1.Age = 18s1.Num = "1001"fmt.Println(s1)fmt.Printf("%T\n",s1) // 输出的是结构体的类型--> main.Stu//方式二:创建时直接赋值var s2 = Stu{"李四",19,"1002"}fmt.Println(s2)//方式三:new关键字创建,返回结构体指针var p *Stu = new(Stu)(*p).Name = "王五"(*p).Age = 20p.Num = "1003"     // 结构体指针可以直接访问结构体成员(简化)fmt.Println(*p)    // 输出的是结构体的值fmt.Println(p)     // 输出的是结构体的地址//方式四:返回结构体指针var p2 = &Stu{"赵六",21,"1004"}p2.Age = 11fmt.Println(*p2)    //输出的是结构体的值fmt.Println(p2)     //输出的是结构体的地址fmt.Printf("%p\n",p2)  // 输出的是结构体的地址fmt.Printf("%T\n",p2)  // 输出的是结构体的类型--> *main.Stu
}

1.2 创建结构体实例时指定字段值

package main
import "fmt"type Stu struct{Age intName string
}func main(){//方式一:按照顺序赋值--缺点:如果顺序改变,就会报错s := Stu{10,"张三"}fmt.Println(s)//方式二:按照指定变量赋值,可以不按照顺序赋值s1 := Stu{Name:"李四",Age:11,     // 分行赋值,最后一行需要加逗号}fmt.Println(s1)//方式三:想要返回结构体的指针类型s3 := &Stu{12,"王五"}fmt.Println(s3) // &{12 王五}fmt.Println(*s3) //{12 王五}
}

1.3 跨包创建结构体实例

  1. 创建不同的包
  2. student --> package model
  3. main.go --> package main


     

结构体名字首字母小写,并可以进行跨包访问  -->  工厂模式


 

1.4 结构体之间的转换

1、结构体是用户单独定义的类型,和其它类型进行转换时需要有完全相同的字段(名字、个数、类型、顺序需要完全一致)

package main
import "fmt"type Stu struct{Age intName string
}type Person struct{Age intName string
}func main(){s1 := Stu{18,"张三"}p1 := Person{19,"李四"}p1 = Person(s1)fmt.Println(s1)fmt.Println(p1)
}

2、 结构体进行type重新定义(相当于取别名),Golang认为是新的数据类型,但是相互间可以强转

package main
import "fmt"type Stu struct{Age intName string
}
type Per Stufunc main(){var s1 Stu = Stu{20,"张三"}var p1 Per = Per{19,"李四"}p1 = Per(s1)fmt.Println(s1)       // 输出的是结构体的值fmt.Printf("%T\n",s1) // 输出的是结构体的类型--> main.Stufmt.Println(p1)       // 输出的是结构体的值fmt.Printf("%T\n",p1) // 输出的是结构体的类型--> main.Per
}

2、方法

方法:指作用在指定的数据类型上,和指定的数据类型绑定,因此自定义类型都可以方法,不仅仅时struct。

函数:函数是独立的代码块,可以接受参数并返回结果。

区别:

  • 函数:不需要接收者,可以被独立调用。
  • 方法:必须有一个接收者,该接收者可以是一个值(值接收者)或指针(指针接收者),并且在调用方法时,需要通过接收者的实例来调用。

调用:

package main
import "fmt"type Stu struct{Age intName string
}//(s Stu)用于给Stu绑定Print方法,s Stu表示接收者
//结构体传递是值传递,不影响原结构体的值
func (s Stu) Print(){s.Age = 100fmt.Println(s.Age,s.Name) // {100 张三}
}func main(){var s1 Stu = Stu{20,"张三"}s1.Print()      //{100 张三}fmt.Println(s1) //{20 张三}
}

注意:

  • 结构体和方法绑定,调用该方法时必须靠指定的类型(其他类型变量调用会报错)
  • 结构体对象传入方法中,是进行了值传递(副本),副本改变不影响原结构体
  • 结构体对象传入方法中,如果需要在方法中改变原结构体的值,可以通过结构体指针的方式来处理
    package main
    import "fmt"type Stu struct{Age intName string
    }//(s Stu)用于给Stu绑定Print方法,s Stu表示接收者
    //结构体传递是值传递,不影响原结构体的值
    func (s *Stu) Print(){s.Age = 100 // 结构体指针可以直接访问结构体成员(简化)fmt.Println(s.Age,s.Name) // {100 张三}
    }func main(){var s1 Stu = Stu{20,"张三"}(&s1).Print()      //或者是s1.Print(),都可以实现调用fmt.Println(s1) //{100 张三}
    }
  • Golang中的方法作用在指定的数据类型上的,和指定的数据类型绑定,因此自定义类型都可以有方法,而不仅仅时struct,比如int,float32等都可以有方法(借用type来给基本数据类型取别名,Golang认为是新的数据类型,用这个特性来绑定方法)

    package main
    import "fmt"type interger intfunc (i interger) Print(){i = 11111111fmt.Println(i) // 11111111//fmt.Printf("%T\n",i) // main.interger
    }
    func (i *interger) change(){*i = 1111fmt.Println(*i)
    }func main(){var i interger = 100i.Print() // 11111111fmt.Println(i) // 100--不改变i.change() //1111fmt.Println(i) //1111--改变
    }
  • 方法的访问范围控制的规则,和函数一样。方法名首字母小写,只能在本包访问;方法首字母大写,可以在本包和其他包访问
  • 如果一个类型实现了String()这个方法,那么fmt.Println默认会调用这个变量的String()进行输出
    package main
    import "fmt"type Stu struct{Age intName string
    }
    func (s *Stu) String() string{str := fmt.Sprintf("Age:%d Name:%s",s.Age,s.Name)return str
    }// func (s Stu) String() string{
    // 	str := fmt.Sprintf("Age:%d Name:%s",s.Age,s.Name)
    // 	return str
    // }func main(){var s Stu = Stu{10,"张三"}fmt.Println(&s)//fmt.Println(s)
    }

简化:

  • 使用结构体或结构体指针调用变量或方法时,指针调用可以不用*
  • 使用结构体或结构体指针作为参数传参时,结构体传给结构体指针可以不用&(对于方法来说,接收者为值类型,可以传入指针类型(但还是值传递),接收者为指针类型,可以传入值类型)

3、封装

什么是封装:
封装就是把抽象出的字段和对字段的操作封装在一起,数据被保护在内部,程序的其它包只有通过被授权的操作方法,才能对字段进行操作

封装的好处:

  • 隐藏实现细节
  • 可以对数据进行验证,保证安全合理

Golang中如何实现封装:

  • 建议将结构体、字段(属性)的首字母小写(其它包不能使用,类似private,实际开发不小写也可能,因为封装没有那么严格)
  • 给结构体所在包提供一个工厂模式的函数,首字母大写(类似一个构造函数)
  • 提供一个首字母大写的Set方法(类似其它语言的public),用于对属性判断并赋值
  • 提供一个首字母大写的Get方法(类似其它语言的public),用于获取属性的值

4、继承

当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体,在该结构体中定义这些相同的属性和方法,其它的结构体不需要重所定义这些属性和方法,只需嵌套一个匿名结构体即可在Golang中,如果一个struct嵌套了另一个匿名结构体,那么这个结构体可以直接访问匿名结构体的字段和方法,从而实现了继承特性。(提高代码复用性和扩展性)

package main
import "fmt"type Animal struct{Age int;Wei int;
}func (an *Animal) Eat(name string){fmt.Printf("%s: eat\n",name)
}
func (an *Animal) Run(name string){fmt.Printf("%s: run\n",name)
}type Dog struct{AnimalName string
}
func (dog *Dog) Shout(){fmt.Println("汪")
}type Cat struct{AnimalName string
}
func (cat *Cat)Shout(){fmt.Println("喵")
}func main(){var cat Cat = Cat{Animal{10,10},"小白"}var dog Dog = Dog{Animal{6,20},"小黑"}//catcat.Animal.Eat(cat.Name) // 小白: eatcat.Animal.Run(cat.Name) // 小白: runcat.Shout() // 喵//dogdog.Animal.Eat(dog.Name) // 小黑: eatdog.Animal.Run(dog.Name) // 小黑: rundog.Shout() // 汪
}

注意:

  • 结构体可以使用嵌套匿名结构体所有的字段和方法,即:首字母大写或者小写的字段、方法,都可以使用
  • 匿名结构体字段访问可以简化(例如:cat.Animal.Eat(cat.Name) -->  cat.Eat(car.Name) )
    调用过程:cat.Eat(car.Name)先在对应的Cat结构体中找是否有Eat方法,如果有则直接访问;如果没有则就去找嵌入的结构体中继续寻找(就近原则)
  • 当结构体和匿名结构体有相同的字段或者方法时,编译器采用就近访间原则访问,如希望访问匿名结构体的字段和方法,可以通过匿名结构体名来区分
  • Golang中支持多继承:如一个结构体嵌套了多个匿名结构体,那么该结构体可以直接访问嵌套的匿名结构体的字段和方法,从而实现了多重继承。为了保证代码的简洁性,建议大家尽量不使用多重继承,很多语言就将多重继承去除了(可能出现菱形继承的问题),但是Go中保留了
  • 嵌入的匿名结构体有相同的字段名或者方法名,则在访问时,需要通过指明匿名结构体类型名来区分。
  • 结构体的匿名字段可以是基本数据类型(这与既不继承没关系)
    package main
    import "fmt"type Animal struct{int
    }	func main(){var a Animal = Animal{10}fmt.Println(a.int) // 10
    }
  • 嵌套匿名结构体后,也可以在创建结构体变量(实例)时,直接指定各个匿名结构体字段的值

  • 嵌入匿名结构体的指针也是可以的

  • 结构体的字段可以是结构体类型的(组合模式) 

5、接口

package main
import "fmt"//接口的定义:定义规则,定义规范,定义某种能力
//interface接口类型
type SayHello interface{//只声明,没有实现的方法sayHello()
}
//接口的实现:定义一个结构体
type Chinese struct{}
//实现接口的方法--具体的实现
func (ch Chinese) sayHello(){fmt.Println("你好")
}//接口的实现:定义一个结构体
type American struct{}
//实现接口的方法--具体的实现
func (am American) sayHello(){fmt.Println("hello")
}
//定义一个函数:接收具备SayHello接口的能力的变量、
func greet(s SayHello){s.sayHello()
}func main(){c := Chinese{}a := American{}//调用函数greet(c)greet(a)
}
  • 接口中可以定义一组方法,但不需要实现。并且接口中不能包含任何变量。到某个自定义类型要使用的时候(实现接口的时候),再根据具体情况把这些方法具体实现出来。
  • 实现接口要实现所有的方法
  • Golang中实现接口是基于方法的,不是基于接口的(例如:A接口有a和b方法,B接口有a和b方法,C结构体实现了a和b方法,那么C实现了A接口,也实现了B接口。只要实现全部方法即可。和实际接口耦合性很低)
  • 接口目的是为了定义规范,具体由别人来实现即可
  • 接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量
    //SayHello是接口类型//直接用接口创建实例,会出错:
    var s SayHello   //error
    s.sayHello()       //error//但是可以指向一个实现了该接口的自定义类型的变量
    //American -> 实现了接口的自定义类型
    var am American
    var s SayHello = am
    s.sayHello()
  • 只要是自定义数据类型,就可以实现接口,不仅仅是结构体类型
    package main
    import "fmt"type Print interface{print()
    }type interger int
    func (i interger)print(){fmt.Printf("%T:%d\n",i,i)
    }type str string
    func (s str)print(){fmt.Printf("%T:%s\n",s,s)
    }func f(p Print){p.print()
    }func main(){var i interger = 11111var s str = "hello"f(i) //main.interger:11111f(s) //main.str:hello
    }
  • 一个自定义类型可以实现多个接口
  • 一个接口(比如A接口)可以继承多个别的接口(比如B、C接口),这时如果要实现A接口,也必须将B、C接口的方法也全部实现
    package main
    import "fmt"type A interface{a()
    }
    type B interface{b()
    }
    //C接口继承AB接口
    type C interface{ABc()
    }type D struct{}
    func (d D)a(){fmt.Println("a")
    }
    func (d D)b(){fmt.Println("b")
    }
    func (d D)c(){fmt.Println("c")
    }func Print(c C){c.a()c.b()c.c()
    }func main(){d := D{}Print(d) //a b c
    }
  • interface类型默认是一个指针(引用类型),如果没有对interface初始化就使用,那么会输出nil
  • 空接口没有任何方法,所以可以理解为所有类型都实现了空接口,也可以理解为我们可以把任何一个变量赋值给空接口
    var s str = str{}
    var a interface{} = s


     

6、多态

多态:变量(实例)具有多种形态。面向对象的第三大特征之一,在Go语言,多态特征是通过接口实现可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态。

package main
import "fmt"//接口的定义:定义规则,定义规范,定义某种能力
//interface{} 空接口,没有任何方法
type SayHello interface{//只声明,没有实现的方法sayHello()
}
//接口的实现:定义一个结构体
type Chinese struct{}
//实现接口的方法--具体的实现
func (ch Chinese) sayHello(){fmt.Println("你好")
}//接口的实现:定义一个结构体
type American struct{}
//实现接口的方法--具体的实现
func (am American) sayHello(){fmt.Println("hello")
}
//定义一个函数:接收具备SayHello接口的能力的变量、
func greet(s SayHello){  s.sayHello()        //s可以通过上下文识别具体是什么类型的实例,这就体现了多态
}func main(){c := Chinese{}a := American{}//调用函数greet(c)greet(a)
}

接口体现多态特征:

  1. 多态参数:例如上面greet函数中的s变量
  2. 多态数组:比如上面的示例中,定义SayHello数组,存放中国人结构体和美国人结构体
    package main
    import "fmt"//接口的定义:定义规则,定义规范,定义某种能力
    //interface{} 空接口,没有任何方法
    type SayHello interface{//只声明,没有实现的方法sayHello()
    }
    //接口的实现:定义一个结构体
    type Chinese struct{}
    //实现接口的方法--具体的实现
    func (ch Chinese) sayHello(){fmt.Println("你好")
    }//接口的实现:定义一个结构体
    type American struct{}
    //实现接口的方法--具体的实现
    func (am American) sayHello(){fmt.Println("hello")
    }
    //定义一个函数:接收具备SayHello接口的能力的变量、
    func greet(s SayHello){s.sayHello()
    }func main(){//定义一个多态数组--接口类型可以存储任何实现了该接口的变量var arr [3]SayHelloarr[0] = Chinese{}arr[1] = American{}arr[2] = Chinese{}//遍历数组for i := 0;i < len(arr);i++{greet(arr[i]) // 你好 hello 你好}
    }
    


     

7、断言

  • 在Go语言中,断言(Type Assertion)是一种用于检查接口变量的动态类型是否与指定类型相匹配的操作。它允许你将一个接口类型的变量转换为具体的类型以便访问该类型的特定方法或字段。
  • 断言的语法是 x.(T),其中 x 是一个接口类型的变量,T 是你想要断言的具体类型。
  • 如果 x 的动态类型确实是 T,那么断言会成功,并且返回 T 类型的值。如果断言失败,程序会抛出一个运行时错误。
  • 断言语法x.(T)的返回值 -> 变量,flag -> 变量用于接收T类型的值,flag用于判断类型是否转化成功 -> true--成功,false--失败。
  • 类型断言通常用于确保在调用特定方法或访问特定字段之前,接口变量确实是你所期望的类型。这有助于避免在运行时出现类型不匹配的错误。
package main
import "fmt"//接口的定义:定义规则,定义规范,定义某种能力
//interface{} 空接口,没有任何方法
type SayHello interface{//只声明,没有实现的方法sayHello()
}
//接口的实现:定义一个结构体
type Chinese struct{}
//实现接口的方法--具体的实现
func (ch Chinese) sayHello(){fmt.Println("你好")
}
func (ch Chinese) gongxi(){fmt.Println("恭喜发财")
}//接口的实现:定义一个结构体
type American struct{}
//实现接口的方法--具体的实现
func (am American) sayHello(){fmt.Println("hello")
}
//定义一个函数:接收具备SayHello接口的能力的变量、
func greet(s SayHello){s.sayHello()ch,flag := s.(Chinese)// 类型断言:看s是否能转成Chinese类型并赋给ch变量//就是把结构体转换成能实现当前接口的结构体,如果能转成,就赋值给ch,不能转成,就报错if flag==true {    //或者是 if ch,flag := s.(Chinese); flag{ch.gongxi()}else{fmt.Println("类型断言失败,美国人不会恭喜发财")}
}func main(){var ch Chinese = Chinese{}var am American = American{}greet(ch) // 你好 恭喜发财greet(am) // hello 类型断言失败,美国人不会恭喜发财
}

Type Switch的基本用法

Type Switch是Go语言中一种特殊的switch语法,它比较的是类型而不是具体的值。它判断某个接口变量的类型,然后根据具体类型再做相应处理。

package main
import "fmt"//接口的定义:定义规则,定义规范,定义某种能力
//interface{} 空接口,没有任何方法
type SayHello interface{//只声明,没有实现的方法sayHello()
}
//接口的实现:定义一个结构体
type Chinese struct{}
//实现接口的方法--具体的实现
func (ch Chinese) sayHello(){fmt.Println("你好")
}
func (ch Chinese) gongxi(){fmt.Println("恭喜发财")
}//接口的实现:定义一个结构体
type American struct{}
//实现接口的方法--具体的实现
func (am American) sayHello(){fmt.Println("hello")
}
//定义一个函数:接收具备SayHello接口的能力的变量、
func greet(s SayHello){s.sayHello()//使用Type-Switchswitch tp := s.(type) { //type属于go中的一个关键字,固定写法case Chinese:tp.gongxi()case American:tp.gun()default:fmt.Println("类型断言失败")}
}
func (am American) gun(){fmt.Println("gun之下出真知()")
}func main(){var ch Chinese = Chinese{}var am American = American{}greet(ch) // 你好 恭喜发财greet(am) // hello gun之下出真知()
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/59431.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

PHP查询实时股票行情

记录一个实时行情接口&#xff0c;通过PHP查询实时股票行情 <?php// Special Note: // GitHub: https://github.com/alltick/realtime-forex-crypto-stock-tick-finance-websocket-api // Token Application: https://alltick.io // Replace "testtoken" in the…

深入解读 Transformer 编码器中的嵌入与位置编码

10. embedding 深入解读 Transformer 编码器中的嵌入与位置编码 在搭建 Transformer 编码器时&#xff0c;有两步至关重要&#xff1a;词嵌入&#xff08;Embedding&#xff09; 和 位置编码&#xff08;Positional Encoding&#xff09;。这两者的组合让模型不仅能够理解词汇…

语音识别中的RPM技术:原理、应用与发展趋势

目录 引言1. RPM技术的基本原理2. RPM的应用领域3. RPM技术的挑战与发展趋势4. 总结 引言 在语音识别和音频处理领域&#xff0c;RPM&#xff08;Recurrent Phase Model&#xff0c;递归相位模型&#xff09;技术正逐渐崭露头角。它作为一种创新的信号处理方法&#xff0c;通过…

IntelliJ Idea设置自定义快捷键

我IDEA的快捷键是自己修改成了和Eclipse相似&#xff0c;然后想要跳转到某个方法的上层抽象方法没有对应的快捷键&#xff0c;IDEA默认的是Ctrl U &#xff08;Windows/Linux 系统&#xff09; 或 Command U &#xff08;Mac 系统&#xff09;&#xff0c;但是我的不起作用&a…

深入探讨钉钉与金蝶云星空的数据集成技术

钉钉报销数据集成到金蝶云星空的技术案例分享 在企业日常运营中&#xff0c;行政报销流程的高效管理至关重要。为了实现这一目标&#xff0c;我们采用了轻易云数据集成平台&#xff0c;将钉钉的行政报销数据无缝对接到金蝶云星空的付款单系统。本次案例将重点介绍如何通过API接…

Python 数据结构对比:列表与数组的选择指南

文章目录 &#x1f4af;前言&#x1f4af;Python中的列表&#xff08;list&#xff09;和数组&#xff08;array&#xff09;的详细对比1. 数据类型的灵活性2. 性能与效率3. 功能与操作4. 使用场景5. 数据结构选择的考量6. 实际应用案例7. 结论 &#x1f4af;小结 &#x1f4af…

Python小白学习教程从入门到入坑------第二十七课 魔法方法(语法进阶)

目录 一、什么是魔法方法&#xff1f; 二、常见的魔法方法 三、魔法方法&魔法属性 3.1 __doc__&#xff08;&#xff09; 3.2 __module__&#xff08;&#xff09; 3.3 __class__&#xff08;&#xff09; 3.4 __str__() 3.5 __del__() 一、什么是魔法方法&#xf…

代码训练营 day57

前言 这里记录一下陈菜菜的刷题记录&#xff0c;主要应对25秋招、春招 个人背景 211CS本CUHK计算机相关硕&#xff0c;一年车企软件开发经验 代码能力&#xff1a;有待提高 常用语言&#xff1a;C 系列文章目录 第57天 &#xff1a;第十一章&#xff1a;图论part03 文章目录…

【ChatGPT】如何将ChatGPT的回答与外部数据进行结合

如何将ChatGPT的回答与外部数据进行结合 在撰写内容或进行分析时&#xff0c;将ChatGPT的回答与外部数据相结合&#xff0c;可以增加信息的深度和准确性。这种方法不仅提升了内容的权威性&#xff0c;还能为读者提供更为全面的视角。本文将探讨如何有效地结合ChatGPT的回答与外…

ML 系列:机器学习和深度学习的深层次总结( 19)— PMF、PDF、平均值、方差、标准差

一、说明 在概率和统计学中&#xff0c;了解结果是如何量化的至关重要。概率质量函数 &#xff08;PMF&#xff09; 和概率密度函数 &#xff08;PDF&#xff09; 是实现此目的的基本工具&#xff0c;每个函数都提供不同类型的数据&#xff1a;离散和连续数据。 二、PMF 的定义…

string模拟实现插入+删除

个人主页&#xff1a;Jason_from_China-CSDN博客 所属栏目&#xff1a;C系统性学习_Jason_from_China的博客-CSDN博客 所属栏目&#xff1a;C知识点的补充_Jason_from_China的博客-CSDN博客 string模拟实现reserve 这里实现的是扩容 扩容这里是可以实现缩容&#xff0c;可以实现…

《JVM第8课》垃圾回收算法

文章目录 1.标记算法1.1 引用计数法1.2 可达性分析法 2.回收算法2.1 标记-清除算法&#xff08;Mark-Sweep&#xff09;2.2 复制算法&#xff08;Coping&#xff09;2.3 标记-整理算法&#xff08;Mark-Compact&#xff09; 3.三种垃圾回收算法的对比 为什么要进行垃圾回收&…

编程之路:蓝桥杯备赛指南

文章目录 一、蓝桥杯的起源与发展二、比赛的目的与意义三、比赛内容与形式四、比赛前的准备五、获奖与激励六、蓝桥杯的影响力七、蓝桥杯比赛注意事项详解使用Dev-C的注意事项 一、蓝桥杯的起源与发展 蓝桥杯全国软件和信息技术专业人才大赛&#xff0c;简称蓝桥杯&#xff0c…

Redis的内存淘汰机制

Redis的内存淘汰机制用于控制内存使用情况&#xff0c;以防止内存耗尽而导致服务崩溃。其核心思想是在内存达到限制时&#xff0c;根据不同策略淘汰一些数据&#xff0c;为新的数据腾出空间。Redis 提供了多种内存淘汰策略&#xff0c;通过配置参数 maxmemory-policy 进行设置。…

全网最适合入门的面向对象编程教程:58 Python字符串与序列化-序列化Web对象的定义与实现

全网最适合入门的面向对象编程教程&#xff1a;58 Python 字符串与序列化-序列化 Web 对象的定义与实现 摘要&#xff1a; 如果我们要在不同的编程语言之间传递对象&#xff0c;就必须把对象序列化为标准格式&#xff0c;比如XML\YAML\JSON格式这种序列化Web对象。这种序列化W…

使用YOLO 模型进行线程安全推理

使用YOLO 模型进行线程安全推理 一、了解Python 线程二、共享模型实例的危险2.1 非线程安全示例&#xff1a;单个模型实例2.2 非线程安全示例&#xff1a;多个模型实例 三、线程安全推理3.1 线程安全示例 四、总结4.1 在Python 中运行多线程YOLO 模型推理的最佳实践是什么&…

每日一题|3255. 长度为 K 的子数组的能量值 II|递增序列、计数器

同昨天的解法一样&#xff0c;遍历一遍的同时&#xff0c;统计当前最长的子串长度&#xff0c;如果>k&#xff0c;则将子串开始位置处赋值子串当前位置元素的值。 class Solution:def resultsArray(self, nums: List[int], k: int) -> List[int]:res [-1] * (len(nums)…

金华迪加现场大屏互动系统 mobile.do.php 任意文件上传漏洞复现

0x01 产品描述&#xff1a; ‌ 金华迪加现场大屏互动系统‌是由金华迪加网络科技有限公司开发的一款专注于增强活动现场互动性的系统。该系统设计用于提供高质量的现场互动体验&#xff0c;支持各种大型活动&#xff0c;如企业年会、产品发布会、展览展示等。其主要功能包…

nVisual标签打印模块的部署与使用

部署 标签打印模块部署需要注意的是 前置条件 标签打印模块是以外部模块形式依附于nVisual主模块的&#xff0c;所以要先部署好nVisual主模块的前后端程序。 部署文件下载 标签打印模块也分前端文件和后端文件&#xff0c;从微盘->软件发布->nVisual official relea…

《运维网络安全》

一、引言 在当今数字化时代&#xff0c;网络已经成为企业和组织运营的核心基础设施。随着信息技术的飞速发展&#xff0c;网络安全问题也日益凸显。运维网络安全是确保企业网络系统稳定、可靠、安全运行的关键环节。本文将深入探讨运维网络安全的重要性、面临的挑战、关键技术以…