Encapsulation is defined as the wrapping up of data under a single unit. It is the mechanism that binds together code and the data it manipulates. In a different way, encapsulation is a protective shield that prevents the data from being accessed by the code outside this shield.
In object-oriented languages, the variables or data of a class are hidden from any other class and can be accessed only through any member function of own class in which they are declared. But Go language does not support classes and objects. So, in the Go language, encapsulation is achieved by using packages. Go provides two different types of identifiers, i.e. exported and unexported identifiers. Encapsulation is achieved by exported elements(variables, functions, methods, fields, structures) from the packages, it helps to control the visibility of the elements(variables, functions, methods, fields, structures). The elements are visible if the package in which they are defined is available in your program.
1. Exported Identifiers: Exported identifiers are those identifiers which are exported from the package in which they are defined. The first letter of these identifiers is always in capital letter. This capital letter indicates that the given identifier is exported identifier. Exported identifiers are always limited to the package in which they are defined. When you export the specified identifier from the package you simple just export the name not the implementation of that identifier. This mechanism is also applicable for function, fields, methods, and structures.
GEEKSFORGEEKS GEEKS GFG
Explanation: In the above example, we convert the case of the elements of the slc slice to uppercase by exporting ToUpper() function from strings package.
res := strings.ToUpper(slc[x])
Here, the first letter of the ToUpper() function is in uppercase, which indicates that this function is exported function. If you try to change the case of the ToUpper() function into lowercase, then the compiler will give an error, as shown below:
res := strings.toUpper(slc[x]) Output: ./prog.go:22:9: cannot refer to unexported name strings.toUpper ./prog.go:22:9: undefined: strings.toUpper
So, this process(exporting of variables, fields, methods, functions, structures) is known as encapsulation. Due to encapsulation we only export the name of the function not the whole definition of the function in our program and the definition of the ToUpper() function is wrapped inside strings package, so for exporting ToUpper() function first you need to import strings package in your program.
2. Unexported Identifiers: Unexported identifiers are those identifiers which are not exported from any package. They are always in lowercase. As shown in the below example addition function is not related to any package, so it is an unexported function and the visibility of this method is limited to this program only.
Total Sum: 788
Benefits of Encapsulation:
- Hiding implementation details from the user.
- Increase the reusability of the code.
- It prevents users from setting the function’s variables arbitrarily. It only sets by the function in the same package and the author of that package ensure that the function maintain their internal invariants.
- Zero value in Golang
- How to use Ellipsis (...) in Golang?
- Strings in Golang
- Reflection in Golang
- Golang Maps
- Using WaitGroup in Golang
- Composition in Golang
- Methods With Same Name in Golang
- Methods in Golang
- Hello World in Golang
- Interfaces in Golang
- Channel in Golang
- Recover in Golang
- Panic in Golang
- What is Regex in Golang?
- Closures in Golang
- How to copy a map to another map in Golang?
- Polymorphism in GoLang
- Packages in Golang
- Inheritance in GoLang
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to email@example.com. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.