Go语言中的面向对象编程(OOP)

在Go语言中，虽然没有像面向对象语言那样的类，但通过结构体类型和方法，仍然支持部分面向对象编程（OOP）的概念。

封装（Encapsulation）

封装是一种将一个对象的实现细节隐藏起来，使其对其他对象不可见的做法，这样可以实现解耦。
例如，考虑以下结构体：

type Student struct{
  name string
  rollNo uint64
}

1
2
3
4
5

其中的name和rollNo字段是私有的，因为它们以小写字母开头。为了提供公共访问，可以为这些字段定义对应的getter和setter方法。

func (s *Student) GetName() string {
  return s.name
}

func (s *Student) SetName(name string) {
  s.name = name
}

func (s *Student) GetRollNo() uint64 {
  return s.rollNo
}

func (s *Student) SetRollNo(roll uint64) {
  s.rollNo = roll
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

现在，程序的其他部分也可以创建Student结构体的对象，并通过公共的getter和setter方法访问name和rollNo，从而实现了封装。

抽象（Abstraction）

数据抽象是一种设计模式，其中数据仅对语义相关的函数可见，以防止误用。数据抽象的成功导致在面向对象和纯函数式编程中频繁地将数据隐藏作为设计原则。
在Go语言中，可以通过接口实现抽象。接口定义了一组必须实现的方法，以满足接口的要求。
例如，考虑以下接口：

type iStudent interface{
  calcPercentage() float64
}

1
2
3
4

该接口定义了一个名为calcPercentage()的方法，用于计算学生的百分比。

继承（Inheritance）

在Go语言中，不支持传统意义上的继承。相反，Go使用组合来实现类似的功能。一个结构体可以嵌入另一个结构体，从而继承其字段和方法。
例如，考虑以下结构体：

type Person struct {
 name string
 age  uint64
}

type Student struct {
 Person
 studentID uint64
}

1
2
3
4
5
6
7
8
9
10

在这里，Student结构体嵌入了Person结构体，这意味着它继承了Person的name字段。Student结构体还有自己的studentID字段。现在，任何对Person操作的方法也可以对Student操作，因为Student是一个带有额外字段的Person。

多态（Polymorphism）

多态是指调用代码可以独立于所支持层次结构中的类（父类或其子类）而运行的情况。
在Go语言中，可以通过使用接口来实现多态。由于Go是一种静态类型的语言，变量的类型必须在编译时已知。然而，通过使用接口，可以编写可以在满足相同接口要求的不同类型上操作的代码，而无需在编译时知道其具体类型。
例如，考虑以下代码：

func PrintStudentDetails(s *Student) {
  fmt.Println("Student Name:", s.GetName())
  fmt.Println("Student Age:", s.GetAge())
  fmt.Println("Percentage",s.CalcPercentage())
}

1
2
3
4
5
6

现在，我们可以将任何实现了PrintStudentDetails()方法的类型作为参数调用该函数，比如Student类型，它会显示该学生的详细信息。这就是多态的实现。

完整的面向对象编程在Go中的示例：

package main

import "fmt"

type Shape interface {
 Area() float64
}

type Triangle struct {
 Base, Height float64
}

func (t Triangle) Area() float64 {
 return 0.5 * t.Base * t.Height
}

type Square struct {
 Side float64
}

func (s Square) Area() float64 {
 return s.Side * s.Side
}

type Rectangle struct {
 Length, Breadth float64
}

func (r Rectangle) Area() float64 {
 return r.Length * r.Breadth
}

func printArea(s Shape) {
 fmt.Println("Area of shape is : ", s.Area())
}

func main() {
 t := Triangle{Base: 10, Height: 20}
 printArea(t)    //Area of shape is :  100

 s := Square{Side: 20}
 printArea(s)    //Area of shape is :  400

 r := Rectangle{Length: 20, Breadth: 10}
 printArea(r)    //Area of shape is :  200
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47