Encapsulamento (orientação a objetos)

Encapsulamento vem de encapsular, que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações[1][2].

Para exemplificar, podemos pensar em uma dona de casa (usuário) utilizando um liquidificador (sistema). O usuário não necessita conhecer detalhes do funcionamento interno do sistema para poder utilizá-lo, precisa apenas conhecer a interface, no caso, os botões que controlam o liquidificador. Outro exemplo clássico de encapsulamento é o padrão de projeto chamado Mediator.

Uma grande vantagem do encapsulamento é que toda parte encapsulada pode ser modificada sem que os usuários da classe em questão sejam afetados. No exemplo do liquidificador, um técnico poderia substituir o motor do equipamento por um outro totalmente diferente, sem que a dona de casa seja afetada - afinal, ela continuará somente tendo que pressionar o botão.

O encapsulamento protege o acesso direto (referência) aos atributos de uma instância fora da classe onde estes foram declarados. Esta proteção consiste em se usar modificadores de acesso mais restritivos sobre os atributos definidos na classe. Depois devem ser criados métodos para manipular de forma indireta os atributos da classe.

Encapsular atributos também auxilia a garantir que o estado e o comportamento de um objeto se mantenha coeso. Por exemplo, no caso da classe Semaforo poderiamos ter um método de acesso chamado lerCor(), e um modificador chamado proximaCor(). O estado é mantido pois os usuários da classe não podem alterar as cores de um semáforo ao seu bel prazer e, por exemplo, fazer a seguinte troca de cores: vermelho-amarelo-vermelho. É comum usar o padrão get<nomeDoAtributo> para o método que retorna o valor atual do atributo e set<nomeDoAtributo> para o método que modifica o valor de um atributo do objeto, como no exemplo abaixo: setComProtecao e getComProtecao.

Exemplos : 

Os exemplos de encapsulamento a seguir foram feitos usando Java, mas a ideia se aplica à qualquer linguagem orientada a objetos.

//Sem encapsulamento
class NaoEncapsulado {
// implicitamente public
int semProtecao;
}

public class TesteNaoEncapsulado {
public static void main(String[] args) {
NaoEncapsulado ne = new NaoEncapsulado(); // ne é uma instância de NaoEncapsulado
ne.semProtecao = 10; // acesso direto ao atributo
System.out.println("Valor sem proteção: " + ne.semProtecao); // acesso direto aos atributos ou nao estupor
}
}



//Com encapsulamento
class Encapsulado {
// private é um modificador de acesso de restrição máxima
private int comProtecao;

public void setComProtecao(int valor) {
comProtecao = valor;
}

public int getComProtecao() {
return comProtecao;
}
}

public class TesteEncapsulado {
public static void main(String[] args) {
Encapsulado e = new Encapsulado(); // "e" é uma instância de Encapsulado

// acesso direto a um atributo protegido implicará erro de compilação
e.comProtecao = 10;

// deve-se acessar o atributos de forma indireta, encapsulada
e.setComProtecao(10);
System.out.println("Valor com proteção: " + e.getComProtecao());
}
}