Programação Orientada a Objetos: Encapsulamento
Tags: programming, braziliandevs, poo
Published: 2024-06-27 00:41:39

---
title: "Programação Orientada a Objetos: Encapsulamento"
published: true
description: Encapsulamento
series: Programação Orientada a Objetos
tags: programming, braziliandevs, poo
cover_image: https://i.ibb.co/m69Qnf6/Screenshot-2024-06-26-at-21-39-20.png
---

# Encapsulamento

é um dos princípios fundamentais da programação orientada a objetos (POO). O encapsulamento consiste em ocultar os detalhes internos de um objeto e expor apenas a interface necessária. Essa prática tem como objetivo proteger o estado interno do objeto contra acessos diretos e não autorizados, promovendo a modularidade e facilitando a manutenção do código.

## Principais Conceitos

**Atributos Privados:** Variáveis que armazenam o estado interno de um objeto e são acessíveis apenas dentro da classe onde são definidas. Em linguagens como Java e Python, usa-se o modificador de acesso private ou o prefixo _ para denotar atributos privados.

**Métodos Públicos:** Funções que permitem a interação com o objeto e seu estado de forma controlada. Estes métodos expõem a funcionalidade do objeto sem revelar os detalhes de implementação.

**Getters e Setters:** Métodos específicos para acessar e modificar atributos privados. Um getter permite ler o valor de um atributo privado, enquanto um setter permite modificá-lo.

## Como funciona em Go

**Campos e Funções não Exportados:** Em Go, se um campo ou uma função começa com uma letra minúscula, ele é acessível apenas dentro do pacote onde foi definido. Esse é o modo como Go implementa encapsulamento.

**Campos e Funções Exportados:** Se um campo ou uma função começa com uma letra maiúscula, ele é exportado e pode ser acessado de outros pacotes.

```go
package main

import "fmt"

// Conta é uma estrutura que representa uma conta bancária.
type Conta struct {
    numero int
    saldo  float64
}

// Depositar é um método que adiciona um valor ao saldo da conta.
func (c *Conta) Depositar(valor float64) {
    c.saldo += valor
}

// Sacar é um método que subtrai um valor do saldo da conta.
func (c *Conta) Sacar(valor float64) {
    c.saldo -= valor
}

// Saldo é um método que retorna o saldo da conta.
func (c *Conta) Saldo() float64 {
    return c.saldo
}

func main() {
    // Cria uma nova conta com saldo inicial de 100.0.
    conta := Conta{numero: 123, saldo: 100.0}

    // Tell, Don't Ask - Princípio de design de software.
    // Depositar e Sacar são métodos que informam a conta sobre as ações a serem realizadas.
    conta.Depositar(50.0)
    conta.Sacar(25.0)

    fmt.Println(conta.Saldo())
}
```

```shell
encampulamento ➜ go run main.go
125
```

Neste exemplo, a estrutura `Conta` possui dois campos privados (`numero` e `saldo`) e três métodos públicos (`Depositar`, `Sacar` e `Saldo`). Dessa forma, o estado interno da conta é protegido contra acessos diretos e não autorizados, garantindo que as operações de depósito e saque sejam realizadas de forma segura.

# Tell, Don't Ask

Tell, Don't Ask é um princípio de design de software que sugere que os objetos devem ser responsáveis por realizar ações e não por fornecer informações. Em vez de perguntar a um objeto sobre seu estado interno e tomar decisões com base nesse estado, o princípio Tell, Don't Ask recomenda que o objeto seja informado sobre o que deve ser feito e tome as ações necessárias.

## Afirmando o Princípio

No mesmo exemplo acima, a estrutura `Conta` possui três métodos públicos (`Depositar`, `Sacar` e `Saldo`) que permitem interagir com o objeto sem acessar diretamente seu estado interno. Dessa forma, o princípio `Tell, Don't Ask` é seguido, pois o objeto `Conta` é informado sobre as ações a serem realizadas (`depósito` e `saque`) e toma as ações necessárias.

# Conclusão

O encapsulamento é um conceito fundamental da programação orientada a objetos que visa proteger o estado interno de um objeto contra acessos diretos e não autorizados. Em Go, o encapsulamento é implementado por meio de campos e funções não exportados, que são acessíveis apenas dentro do pacote onde foram definidos. Dessa forma, é possível garantir a integridade e a segurança do objeto, promovendo a modularidade e facilitando a manutenção do código.

## Projeto

[Github](https://github.com/fabianoflorentino/poo/tree/main/encapsulamento)

# Agradecimento

Deixo aqui meu agradecimento ao @moretoend (fala comigo!), como sempre ajudando a melhorar o conteúdo dos meus artigos, e nesse em especial, me ajudando a entender melhor o conceito de `Tell, Don't Ask`. vlw!

# Referências

- [Wikipedia](https://pt.wikipedia.org/wiki/Programação_orientada_a_objetos#Encapsulamento)
- [Devmedia](https://www.devmedia.com.br/os-4-pilares-da-programacao-orientada-a-objetos/9264)
- [The Go Programming Language Specification](https://go.dev/ref/spec#Exported_identifiers)
- [Effective Go](https://go.dev/doc/effective_go#names)
- [Tell, Don't Ask (Robson Castilho)](https://robsoncastilho.com.br/2014/05/11/conceitos-tell-dont-ask/)
- [Tell, Don't Ask (Martin Fowler)](https://martinfowler.com/bliki/TellDontAsk.html)