Encapsulamento

Origem: Wikipédia, a enciclopédia livre.

Em programação orientada a objetos, encapsulamento é o mecanismo que permite separar um mecanismo de funcionamento de sua interface. Um exemplo disso é que para utilizarmos um liquidificador, não precisamos saber detalhes do funcionamento de seu motor. A única interface que conhecemos são seus botões. Um exemplo clássico de encapsulamento é o padrão Mediator.

Uma grande vantagem do encapsulmento é que toda parte encapsulada pode ser modificada sem que os usuários da classe em questão sejam afetados. Novamente, no exemplo do liquidificador, o 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 semáforo poderiamos ter um método de acesso chamado lerCor(), e um modicador 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.

[editar] Exemplos

[editar] Sem encapsulamento

class NaoEncapsulado {
   //implicitamentamente há modificador, mas não é o mais restritivo
   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 ao atributo
    }
}

[editar] Com encapsulamento

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

   public void setComProtecao(int comProtecao) {
       this.comProtecao = comProtecao;
   }

   public int getComProtecao() {
       return this.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á em 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());
   }
}

OBS.: Estes exemplos logo acima estão em Java. Mesmo assim, a idéia aplica-se a qualquer linguagem de programação OO. Atente ao fato de que cada linguagem de programação define os literais de palavra reservada para definir seus modificadores de acesso.