Encapsulamento no Nível de Pacote

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 48 de 107.

Embora a lição anterior tenha abordado a visibilidade no nível dos campos, o encapsulamento do Go, na verdade, opera no nível do pacote. Tudo dentro do mesmo pacote, independentemente do arquivo em que esteja, pode acessar campos e funções não exportados.

Considere um pacote com vários arquivos:

// account/account.go
package account

type Account struct {
    balance int  // não exportado
}

func (a *Account) Deposit(amount int) {
    a.balance += amount
}

// account/helper.go
package account

func ResetAccount(a *Account) {
    a.balance = 0  // funciona - mesmo pacote
}

Ambos os arquivos pertencem ao pacote account, portanto helper.go pode acessar diretamente o campo não exportado balance. Isso é intencional. Isso permite dividir a lógica do pacote entre arquivos, mantendo o acesso interno.

No entanto, o código fora do pacote não pode acessar membros não exportados:

// main.go
package main

import "account"

func main() {
    acc := &account.Account{}
    acc.Deposit(100)        // funciona - método exportado
    // acc.balance = 50     // erro - campo não exportado
    // account.ResetAccount // funciona se ResetAccount fosse exportado
}

Esse limite no nível do pacote é o principal mecanismo de encapsulamento do Go. Você projeta os pacotes como unidades coesas, nas quais o código interno colabora livremente, enquanto o código externo interage apenas por meio da API exportada. Pense em cada pacote como um módulo autocontido com uma interface pública clara.

Desafio

Fácil

Vamos criar um sistema de gerenciamento de estoque que demonstra como vários arquivos dentro do mesmo pacote podem colaborar acessando diretamente campos não exportados, mantendo esses dados ocultos do código externo.

Você criará três arquivos que trabalham juntos no pacote main:

product.go: Defina uma struct Product com um campo exportado Name e um campo não exportado quantity (int). Adicione um método exportado Info() string que retorne o formato: [Name]: [quantity] in stock
inventory.go: Crie funções auxiliares que trabalhem com produtos acessando diretamente o campo não exportado quantity (isso é possível porque elas estão no mesmo pacote). Implemente:
- Restock(p *Product, amount int) - adiciona o valor à quantidade do produto
- Sell(p *Product, amount int) bool - subtrai o valor da quantidade se houver estoque suficiente; retorna true se for bem-sucedida ou false se não houver estoque suficiente
- NewProduct(name string, initialQty int) *Product - construtor que cria um produto com o nome e a quantidade inicial fornecidos
main.go: Leia os detalhes do produto da entrada, crie um produto usando o construtor, execute operações de estoque e exiba os resultados. Após cada operação, imprima as informações do produto para mostrar o estado atualizado.

As seguintes entradas serão fornecidas:

Linha 1: Nome do produto
Linha 2: Quantidade inicial (inteiro)
Linha 3: Quantidade de reposição (inteiro)
Linha 4: Quantidade de venda (inteiro)

Após criar o produto, imprima suas informações iniciais. Em seguida, reponha o estoque e imprima as informações novamente. Por fim, tente realizar a venda e imprima as informações atualizadas (se for bem-sucedida) ou Sale failed: insufficient stock (se não houver quantidade suficiente).

Por exemplo, dadas as entradas Laptop, 10, 5 e 8, sua saída deverá ser:

Laptop: 10 in stock
Laptop: 15 in stock
Laptop: 7 in stock

E, dadas as entradas Phone, 3, 2 e 10, sua saída deverá ser:

Phone: 3 in stock
Phone: 5 in stock
Sale failed: insufficient stock

A principal ideia aqui é que inventory.go pode ler e modificar diretamente o campo não exportado quantity porque está no mesmo pacote que product.go. Isso é o encapsulamento no nível do pacote em ação: a colaboração interna acontece livremente, enquanto os dados permanecem protegidos contra pacotes externos.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Ler o nome do produto
	name, _ := reader.ReadString('\n')
	name = strings.TrimSpace(name)

	// Ler a quantidade inicial
	initialQtyStr, _ := reader.ReadString('\n')
	initialQty, _ := strconv.Atoi(strings.TrimSpace(initialQtyStr))

	// Ler a quantidade de reposição
	restockStr, _ := reader.ReadString('\n')
	restockAmount, _ := strconv.Atoi(strings.TrimSpace(restockStr))

	// Ler a quantidade de venda
	sellStr, _ := reader.ReadString('\n')
	sellAmount, _ := strconv.Atoi(strings.TrimSpace(sellStr))

	// TODO: Criar um novo produto usando o construtor NewProduct

	// TODO: Imprimir as informações iniciais do produto

	// TODO: Reabastecer o produto e imprimir as informações

	// TODO: Tentar vender e imprimir o resultado
	// Se a venda for bem-sucedida, imprimir as informações atualizadas
	// If sale fails, print "Sale failed: insufficient stock"

	fmt.Println() // Substituir pela saída real
}