深入理解 Go 语言中的封装机制

什么是封装

封装，也就是所谓的信息隐藏，是面向对象编程的一个重要方面。封装被定义为将数据包裹在一个单一的单元下。它是将代码和它所操作的数据绑定在一起的机制。从另一个角度来说，封装是一个保护罩，防止数据被这个保护罩外的代码访问。

在面向对象的语言中，一个类的变量或数据是隐藏的，不受任何其他类的影响，只能通过它们所声明的自己类的任何成员函数来访问。但是 Go 语言不支持类和对象。因此，在 Go 语言中，封装是通过使用包来实现的。Go 语言提供两种不同类型的标识符，即可导出 exported 的和不被导出 unexported 的标识符。封装是通过从包中导出的元素（变量、函数、方法、字段、结构）实现的，它有助于控制元素（变量、函数、方法、字段、结构）的可见性。如果定义这些元素的包在你的程序中可用，那么这些元素就是可见的。

Go 中的封装

Go 与经典的 OOP 语言不同。它没有类、对象和访问修改器的概念。相反，它有一个包的概念。

Golang 在包的层次上提供封装。Go 没有任何 public、private 或 protected 关键字。控制可见性的唯一机制是使用大写和非大写的格式：

• 大写的标识符是可以导出的。大写字母表示这是一个导出的标识符。

• 非大写的标识符不被导出。小写表示该标识符不被导出，只在同一包内被访问。

有五种可以导出或不能被导出的标识符：

1. 结构体

2. 结构体方法

3. 结构体字段

4. 函数

5. 变量

让我们看一个显示上述所有标识符的导出和不导出的示例。请参阅下面的 data.go:

package model

import "fmt"

var (
	SchoolName     = "test"
	schoolLocation = "somecity"
)

//Person struct
type Person struct {
	Name string
	age  int
}

//GetAge of person
func (p *Person) GetAge() int {
	return p.age
}

func (p *Person) getName() string {

	return p.Name

}

type school struct {
}

//GetPerson get the person object

func GetPerson() *Person {
	p := &Person{
		Name: "test",
		age:  21,
	}

	fmt.Println("Model Package:")

	fmt.Println(p.Name)

	fmt.Println(p.age)

	return p
}

func getSchoolName() string {

	return SchoolName

}

测试 test.go

package model

import "fmt"

//Test function
func Test() {

	p := &Person{
		Name: "Jimmy",
		age:  26,
	}
	fmt.Println(p)
	c := &school{}
	fmt.Println(c)

	//STRUCTURE'S METHOD
	fmt.Println(p.GetAge())
	fmt.Println(p.getName())

	//STRUCTURE'S FIELDS
	fmt.Println(p.Name)
	fmt.Println(p.age)

	//FUNCTION
	person2 := GetPerson()
	fmt.Println(person2)
	schoolName := getSchoolName()
	fmt.Println(schoolName)

	//VARIBLES
	fmt.Println(schoolLocation)
	fmt.Println(SchoolName)
}

在运行这个文件时，它能够访问 data.go 中所有导出的和未导出的字段，因为两者都在同一个包模型中。没有编译错误，它的输出如下:

&{test 26}
&{}
26
test
test
26
Model Package:
test
26
&{test 26}
test
somecity
test

让我们把上述文件 test.go 移到另一个名为 view 的包中。现在注意运行 go build 的输出。它给出了编译错误。所有的编译错误都是由于不能引用未导出的字段造成的:

package view

import "fmt"

//Test function
func Test() {
    //STRUCTURE IDENTIFIER
    p := &model.Person{
        Name: "test",
        age:  21,
    }
    fmt.Println(p)
    c := &model.company{}
    fmt.Println(c)
    
    //STRUCTURE'S METHOD
    fmt.Println(p.GetAge())
    fmt.Println(p.getName())
    
    //STRUCTURE'S FIELDS
    fmt.Println(p.Name)
    fmt.Println(p.age)
    
    //FUNCTION
    person2 := model.GetPerson()
    fmt.Println(person2)
    schoolName := model.getSchoolName()
    fmt.Println(companyName)
    
    //VARIBLES
    fmt.Println(model.schoolLocation)
    fmt.Println(model.SchoolName)
}

输出：

test.go:13:3: unknown field 'age' in struct literal of type model.Person
test.go:17:8: cannot refer to unexported name model.school
test.go:17:8: undefined: model.school
test.go:22:15: p.getName undefined (cannot refer to unexported field or method model.(*Person).getName)
test.go:26:15: p.age undefined (cannot refer to unexported field or method age)
test.go:31:17: cannot refer to unexported name model.getSchoolName
test.go:31:17: undefined: model.getSchoolName
test.go:35:14: cannot refer to unexported name model.schoolLocation
test.go:35:14: undefined: model.schoolLocation