Encapsulamento em PHP

O encapsulamento é um dos pilares da Programação Orientada a Objetos (POO) e desempenha um papel crucial ao controlar o acesso aos dados e funcionalidades de uma classe. Em PHP, o encapsulamento é alcançado usando modificadores de acesso (public, private e protected), que determinam a visibilidade e o nível de acesso aos atributos e métodos de uma classe. Neste post, entenda o que é encapsulamento em PHP.

O que é encapsulamento?

Encapsulamento é o princípio de restringir o acesso direto aos atributos de uma classe, fornecendo métodos específicos para manipulá-los. Isso melhora a segurança do código e mantém a integridade dos dados, pois evita modificações diretas nas propriedades internas de uma classe.

Modificadores de acesso em PHP

PHP oferece três modificadores de acesso para implementar o encapsulamento:

1. public: Acessível de qualquer lugar, tanto dentro quanto fora da classe.
2. protected: Acessível apenas dentro da própria classe e em classes que a herdam.
3. private: Acessível apenas dentro da própria classe, impedindo o acesso direto de classes externas ou classes derivadas.

Exemplo básico de encapsulamento em PHP

Vamos criar uma classe ContaBancaria que implementa encapsulamento para proteger o saldo de acesso direto.

<?php
class ContaBancaria {
    private $saldo;

    public function __construct($saldoInicial) {
        $this->saldo = $saldoInicial;
    }

    // Método público para obter o saldo atual
    public function getSaldo() {
        return $this->saldo;
    }

    // Método público para depositar dinheiro
    public function depositar($quantia) {
        if ($quantia > 0) {
            $this->saldo += $quantia;
            echo "Depósito de R$ {$quantia} realizado com sucesso.";
        } else {
            echo "Quantia inválida para depósito.";
        }
    }

    // Método público para sacar dinheiro
    public function sacar($quantia) {
        if ($quantia > 0 && $quantia <= $this->saldo) {
            $this->saldo -= $quantia;
            echo "Saque de R$ {$quantia} realizado com sucesso.";
        } else {
            echo "Saldo insuficiente ou quantia inválida.";
        }
    }
}
?>

Neste exemplo:

• A propriedade $saldo é private, o que impede acesso direto a ela fora da classe.
  
  
• Os métodos getSaldo(), depositar() e sacar() são public, permitindo operações no saldo de forma controlada.

Usando a classe com encapsulamento

Veja como podemos utilizar a classe ContaBancaria:

<?php
$conta = new ContaBancaria(500); // Saldo inicial de R$ 500

// Depósito
$conta->depositar(200); // Depósito de R$ 200
echo "<br>Saldo atual: R$ " . $conta->getSaldo(); // Saldo atualizado

// Saque
$conta->sacar(100); // Saque de R$ 100
echo "<br>Saldo atual: R$ " . $conta->getSaldo(); // Saldo atualizado
?>

Vantagens do encapsulamento

1. Segurança dos dados: Ao impedir o acesso direto às propriedades, evita-se que valores inválidos sejam atribuídos.
   
   
2. Facilidade de manutenção: O encapsulamento permite que a implementação interna de uma classe seja alterada sem afetar o restante do código, desde que a interface pública (os métodos) permaneça a mesma.
   
   
3. Controle de acesso: Define claramente quais partes da classe podem ser acessadas por outras partes do programa, reduzindo a complexidade e aumentando a segurança.

Atributos protected e private

Além de public, podemos usar protected ou private para maior controle em cenários onde subclasses (ou herança) estão envolvidas:

• protected permite que subclasses acessem o atributo ou método, mas o mantém inacessível fora da hierarquia de classes.
  
  
• private restringe o acesso apenas à classe onde o atributo ou método foi declarado.

Exemplo com protected:

<?php
class Conta {
    protected $saldo;

    public function __construct($saldoInicial) {
        $this->saldo = $saldoInicial;
    }

    public function getSaldo() {
        return $this->saldo;
    }
}

class ContaCorrente extends Conta {
    public function aplicarJuros($percentual) {
        $this->saldo += $this->saldo * ($percentual / 100);
    }
}

$contaCorrente = new ContaCorrente(1000);
$contaCorrente->aplicarJuros(5); // Aplica 5% de juros
echo "Saldo após juros: R$ " . $contaCorrente->getSaldo();
?>

Encapsulamento com getters e setters

Os métodos getter e setter são usados para acessar e modificar atributos privados. Com eles, você pode aplicar validações e garantir que o valor atribuído seja válido.

Exemplo de getters e setters:

<?php
class Produto {
    private $preco;

    public function getPreco() {
        return $this->preco;
    }

    public function setPreco($novoPreco) {
        if ($novoPreco > 0) {
            $this->preco = $novoPreco;
        } else {
            echo "Preço inválido.";
        }
    }
}

$produto = new Produto();
$produto->setPreco(150); // Define o preço como R$ 150
echo "preço do produto: R$ " . $produto->getPreco();
?>

Neste exemplo:

• setPreco() verifica se o valor é positivo antes de defini-lo como preço, evitando um valor inválido.
  
  
• getPreco() permite o acesso ao preço sem expor diretamente o atributo $preco.

O encapsulamento em PHP é uma prática essencial para proteger dados e definir regras claras para o acesso e a modificação de atributos de uma classe.

Com public, protected e private, você pode controlar o acesso, tornando o código mais seguro, fácil de manter e robusto. Os getters e setters complementam esse processo ao validar e proteger os dados, ajudando a criar um código orientado a objetos mais confiável e eficiente.

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: encapsulamento php