Go Encapsulation and Access Control: Mastering Privacy with Naming Conventions

Lesson Overview

Hello! In this lesson, we're diving into Encapsulation and access control in Go. Unlike some languages, Go manages encapsulation through capitalization conventions. Imagine encapsulation as an invisible barrier that protects the internals of your code. In Go, identifiers (like struct fields and methods) are kept safe using naming conventions: uppercase indicates exported (public), while lowercase indicates unexported (private). This is crucial for creating robust and secure applications!

Into the Encapsulation

In Go, encapsulation is achieved through structs and methods. Structs bundle together data, while methods attach functionality. Please note that in Go, the distinction between exported (public) and unexported (private) identifiers in Go is meaningful only across package boundaries, so all code snippets we'll discuss today will span multiple files. As example, imagine to be coding a multiplayer game; you could create a Player struct, encapsulating fields (health, armor, stamina) and methods (ReceiveDamage, ShieldHit, RestoreHealth). File content for player/player.go : Go package player type Player struct {health int armor int stamina int} // Constructor function for creating new Player func NewPlayer(health, armor, stamina int) *Player {return &Player{health: health, armor: armor, stamina: stamina}} // Public method to receive damage func (p *Player) ReceiveDamage(damage int) {p.health -= damage // Reduce health} // Public method to decrease armor func (p *Player) ShieldHit(armorDecrease int) {p.armor -= armorDecrease // Decrease armor} // Public method to restore health func (p *Player) RestoreHealth(healthIncrease int) {p.health += healthIncrease // Restore health} File content for main.go : Go package main import ("fmt" "player") func main() {player := player.NewPlayer(100, 50, 77) player.ReceiveDamage(10) player.ShieldHit(5) player.RestoreHealth(15) fmt.Println("Player's Current Health:", player) // Output: Player's Current Health: &{105 45 77}} Here, player is an instance of the Player struct with methods you can call to manipulate its state.

Remark the Privacy

In Go, access control is managed through capitalization. An identifier, such as a field or method, is exported (similar to "public") if it begins with an uppercase letter. Conversely, if it starts with a lowercase letter, it remains unexported (similar to "private"). Note that this access control is enforced only across package boundaries. File content for privacy/privacy.go : Go package privacy type PrivateExample struct {PublicAttribute string privateAttribute string} // Constructor-like function for creating a new PrivateExample with privateAttribute func NewPrivateExample(publicAttr, privateAttr string) *PrivateExample {return &PrivateExample{PublicAttribute: publicAttr, privateAttribute: privateAttr}} // Method that prints attributes (for demonstration purposes) func (pe *PrivateExample) PrintAttributes() {fmt.Println("Public Attribute:", pe.PublicAttribute) fmt.Println("Private Attribute:", pe.privateAttribute)} File content for main.go : Go package main import ("fmt" "example") func main() {example := privacy.NewPrivateExample("Public", "Private") example.PrintAttributes() fmt.Println(example.PublicAttribute) // Output: Public // Uncommenting the following line would cause an error because privateAttribute is unexported // fmt.Println(example.privateAttribute)}

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Private Attributes

Private-like access to struct fields in Go is controlled by making struct fields unexported, limiting outside interference and ensuring data integrity. Let's consider a BankAccount use case and let's see how we can implement this.

File content for bankaccount/bankaccount.go:

package bankaccount

type BankAccount struct {
    accountNumber int
    balance       float64
}

// Constructor function for creating new BankAccount
func NewBankAccount(accountNumber int, balance float64) *BankAccount {
    return &BankAccount{accountNumber: accountNumber, balance: balance}
}

// Public method to deposit money
func (ba *BankAccount) Deposit(amount float64) {
    ba.balance += amount // Deposit money
}

// Method to print balance (for demonstration purposes)
func (ba *BankAccount) PrintBalance() {
    fmt.Println("Balance:", ba.balance)
}

package bankaccount

type BankAccount struct {
    accountNumber int
    balance       float64
}

// Constructor function for creating new BankAccount
func NewBankAccount(accountNumber int, balance float64) *BankAccount {
    return &BankAccount{accountNumber: accountNumber, balance: balance}
}

// Public method to deposit money
func (ba *BankAccount) Deposit(amount float64) {
    ba.balance += amount // Deposit money
}

// Method to print balance (for demonstration purposes)
func (ba *BankAccount) PrintBalance() {
    fmt.Println("Balance:", ba.balance)
}

File content for main.go:

package main

import (
    "bankaccount"
)

func main() {
    bankAccount := bankaccount.NewBankAccount(1234, 100.0)
    bankAccount.PrintBalance()
    // Uncommenting the following line would cause an error because balance is unexported
    // fmt.Println(bankAccount.balance)
}

package main

import (
    "bankaccount"
)

func main() {
    bankAccount := bankaccount.NewBankAccount(1234, 100.0)
    bankAccount.PrintBalance()
    // Uncommenting the following line would cause an error because balance is unexported
    // fmt.Println(bankAccount.balance)
}

Here, balance is kept unexported, safeguarding the account's integrity.

Private Methods

Private-like methods in Go are handled through naming conventions. Methods beginning with a lowercase letter are unexported and can't be accessed outside their package.