go语言特性
- Golang语言没有C++、JAVA一样有面向对象(封装、继承、多态)相关的概念,但是面向对象只是一种编程思想,go借助于struct、interface这两个go的数据类型可以实现面向对象的处理,struct是一种包含了数据成员和方法的类型。
- Golang里面有组合的概念,也就是一个struct 里面可以包含一个或者多个struct,struct可以近似理解为面向对象编程中的class,但是不能等同,有很多区别。如果一个struct实现了某个接口的所有方法,那么只要是包含这个struct的所有其他struct也都是实现了这个接口的所有方法。
封装
封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式
1、类: 在 Go 语言中可以使用结构体(Structs)对属性进行封装,结构体就像是类的一种简化形式。
例如,我们要定义一个矩形,每个矩形都有长和宽,我们可以这样进行封装:
type Rectangle struct {
Length int
Width int
}
2、类的方法:Go 语言中也有方法),Go 方法是作用在接收者(receiver)上的一个函数,接收者是某种类型的变量,但不能是接口类型。因此方法是一种特殊类型的函数。
定义方法的格式如下:
func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }
上文中我们已经定义了一个矩形 Rectangle,现在我们要定义一个方法 Area() 来计算它的面积:
package main
import (
"fmt"
)
// 矩形结构体
type Rectangle struct {
Length int
Width int
}
// 计算矩形面积
func (r *Rectangle) Area() int {
return r.Length * r.Width
}
func main() {
r := Rectangle{4, 2}
// 调用 Area() 方法,计算面积
fmt.Println(r.Area())
}
上面的代码片段输出结果为 8。
3、访问权限:一个类的属性是公共的还是私有的,在c++、java编程语言中,我们常用 public 与 private 关键字来表达这样一种访问权限。在 Go 语言中没有 public、private、protected 这样的访问控制修饰符,它是通过字母大小写来控制可见性的。
如果定义的常量、变量、类型、接口、结构、函数等的名称是大写字母开头,这表示它们能被其它包访问或调用(相当于 public);非大写开头就只能在包内使用(相当于 private)。
如何访问未导出字段: 当遇到只能在包内使用的未导出字段时,我们又该如何访问呢?和其他面向对象语言一样,Go 语言也有实现 getter 和 setter 的方式:对于 setter 方法使用 Set大写前缀让外包调用给未导出成员赋值。对于 getter 方法使用大写前缀Get,并返回相关的未导出成员的值。例如我们现在有一个处于 person 包中的 Person 结构体:
package person
type Person struct {
firstName string
lastName string
}
//我们可以看到,它的两个成员变量都是非大写字母开头,只能在包内使用,现在我们为其中的 firstName 来定义 setter 与 getter :
// 获取 firstName
func (p *Person) FirstName() string {
return p.firstName
}
// 设置 firstName
func (p *Person) SetFirstName(newName string) {
p.firstName = newName
}
//这样一来,我们就可以在 main 包里设置和获取 firstName 的值了:
-----
package main
import (
"fmt"
"./person"
)
func main() {
p := new(person.Person)
p.SetFirstName("firstName")
fmt.Println(p.FirstName())
}
/* Output:
firstName
*/
继承
继承:使得子类具有父类的属性和方法或者重新定义、追加属性和方法等,继承在两个类之间建立的是is-a的关系。
在 Go 语言中一般使用在结构体中内嵌匿名类型的方法来实现继承。匿名类型:即这些类型没有显式的名字。匿名组合类型是相当于用其类型名称(去掉包名部分)作为成员变量的名字。go的继承可以把struct看做类,struct中可以包含其它的struct,继承内部struct的方法和变量,同时可以重写内部继承的struct的方法和变量。当外层结构体声明了一个函数与匿名内嵌成员所声明的函数同名时,再直接调用调用该函数,将会覆盖内嵌成员的同函数,也即是说,这实现了覆盖 override 效果。
引入匿名域(Person)实现了is-a关系,匿名域只给出了对象类型,而不给出类型的名字。通过匿名域,外层结构体对象可以直接调用内嵌成员所声明的方法,而无需带成员名或类型名(匿名成员本来就只有类型名,而无成员名),而这种调用方式就像是外层结构体对象在调用自己声明的方法一样。
例如:我们定义一个 Engine 接口类型,一个 Car 结构体,让 Car 结构体包含一个 Engine 类型的匿名字段:
type Engine interface {
Start()
Stop()
}
type Car struct {
Engine // 包含 Engine 类型的匿名字段
}
//此时,匿名字段 Engine 上的方法「晋升」成为了外层类型 Car 的方法。我们可以构建出如下代码:
func (c *Car) GoToWorkIn() {
// get in car
c.Start()
// drive to work
c.Stop()
// get out of car
}
虚基类
Golang可以interface + struct来实现虚基类的用法,若struct的成员是一个接口类型,若传入接口类型的成员实现了interface中定义的方法。若接口成员为匿名成员,则外层结构体可以直接调用接口中的方法。若想要某一结构体拥有某一接口不同的实现方法时,可以把接口类型作为结构体的一个类型成员。接口成员赋予不同的实现者时,结构体拥有不同的接口实现方法
type Clothe interface {
SayColor()
}
type BlueClothe struct {
Color string
}
func (b *BlueClothe) SayColor() {
log.Println("Blue")
}
type Stu struct {
Clothe
Name string
}
func main() {
blue:=&BlueClothe{Color:"Blue"}
var stu Stu
stu.Clothe = blue //匿名类型名字就是类型名
stu.Name="biningo"
stu.SayColor()
}
这种特性在一些注册插件的功能代码中较为常见,因为传入结构体的接口类型成员的实现者不同,则结构体拥有不同逻辑的接口实现方法。
type IProxy interface {
HandleFunc(url, req string) (interface{}, int, error)
}
type httpHandler struct {
IProxy
}
组合
组合:每当某个类包含另一个类的对象作为其显式成员变量之一时,就会出现类组合。组合在两个类之间建立了(Has-a)的关系
go语言中,如果一个struct嵌套了一个有名结构体,这种模式就是组合,如果是组合关系,那么在访问组合的结构体字段或方法时,就必须带上结构体的名字。
多态
多态:不同对象中同种行为的不同实现方式
在面向对象中,多态的特征为:不同对象中同种行为的不同实现方式。在 Go 语言中可以使用接口interface实现这一特征。 可以把匿名域绑定到一个接口,也能绑定到多个接口。接口和匿名域一起使用,可以起到和多态同样的效果。
我们先定义一个正方形 Square 和一个长方形 Rectangle:
// 正方形
type Square struct {
side float32
}
// 长方形
type Rectangle struct {
length, width float32
}
然后,我们希望可以计算出这两个几何图形的面积。但由于他们的面积计算方式不同,我们需要定义两个不同的 Area() 方法。于是,我们可以定义一个包含 Area() 方法的接口 Shaper,让 Square 和 Rectangle 都实现这个接口里的 Area():
// 接口 Shaper
type Shaper interface {
Area() float32
}
// 计算正方形的面积
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
// 计算长方形的面积
func (r *Rectangle) Area() float32 {
return r.length * r.width
}
我们可以在 main() 函数中这样调用 Area():
func main() {
r := &Rectangle{10, 2}
q := &Square{10}
// 创建一个 Shaper 类型的数组
shapes := []Shaper{r, q}
// 迭代数组上的每一个元素并调用 Area() 方法
for n, _ := range shapes {
fmt.Println("图形数据: ", shapes[n])
fmt.Println("它的面积是: ", shapes[n].Area())
}
}
/*Output:
图形数据: &{10 2}
它的面积是: 20
图形数据: &{10}
它的面积是: 100
*/
由以上代码输出结果可知:不同对象调用 Area() 方法产生了不同的结果,展现了多态的特征。