Encapsulamento

"Olá, Amigo! Quero dedicar a palestra de hoje ao encapsulamento . Você já tem uma idéia geral do que seja."

Então, quais são as vantagens do encapsulamento? São muitos, mas vou apontar quatro que são, a meu ver, os mais importantes:

1) Estado interno válido.

Frequentemente, os programas têm várias classes que interagem com o mesmo objeto. Ao interagir simultaneamente com os dados internos do objeto, eles podem violar a integridade dos dados do objeto, fazendo com que o objeto pare de funcionar corretamente.

Portanto, o objeto deve rastrear quaisquer alterações em seus dados internos ou, melhor ainda, deve ser ele quem fará essas alterações.

Se não quisermos que alguma variável de classe seja alterada por outras classes, então a declaramos private , o que significa que somente os métodos dessa classe podem acessá-la. Se quisermos que as variáveis ​​sejam somente leitura para outras classes, adicionamos o getter público a essas variáveis.

Por exemplo, podemos querer que todos saibam quantos elementos existem em nossa coleção, mas ninguém deve poder alterá-la sem nossa permissão. Neste caso, declaramos uma variável private int count e um método public getCount() .

O encapsulamento adequado garante que outras classes não possam acessar diretamente os dados internos de nossa classe e, consequentemente, não possam alterá-los sem que possamos controlar suas ações. Eles devem chamar os métodos da classe que contém as variáveis ​​que serão alteradas.

É melhor presumir que outros programadores sempre usarão suas classes da maneira mais conveniente para eles, não da maneira mais segura para você (ou sua classe). Esta é uma fonte de bugs e uma maneira de evitá-los.

2) Verificação de parâmetros.

Às vezes você precisa verificar os parâmetros passados ​​para os métodos de sua classe. Por exemplo, suponha que temos uma classe que representa uma "pessoa" e você pode especificar sua data de nascimento. Devemos verificar se todos os dados passados ​​correspondem à lógica do programa e à lógica da classe. Por exemplo, não há 13º mês, 30 de fevereiro, etc.

"Por que alguém indicaria uma data de nascimento de 30 de fevereiro?"

"Bem, em primeiro lugar, pode ser o resultado de um erro de entrada de dados."

Em segundo lugar, antes de um programa funcionar como um relógio, ele pode ter muitos bugs. Por exemplo, algo assim pode acontecer.

Um programador escreve um código que determina quem faz aniversário depois de amanhã. Digamos que hoje seja 3 de março. O programa adiciona 2 à data atual e localiza todos os que nasceram em 5 de março. Até aqui, tudo bem.

Mas quando chega o dia 30 de março, o programa não encontra ninguém, já que não existe o dia 32 de março. Os programas têm muito menos bugs quando os métodos executam a verificação de parâmetros."

"Lembro que, quando estudamos ArrayList, observei seu código e havia verificações nos métodos get e set para garantir que o parâmetro index fosse maior ou igual a zero e menor que o comprimento da matriz. O código lançaria um exceção se o array não tiver um elemento correspondente ao índice.

"Sim, isso é verificação de entrada clássica. "

3) Menos bugs ao alterar o código dentro das classes.

Suponha que escrevemos uma classe realmente útil como parte de um grande projeto. Todo mundo gosta tanto que outros programadores começaram a usá-lo em centenas de lugares em seu próprio código.

A aula provou ser tão útil que você decidiu melhorá-la. Mas se você se livrar de qualquer um dos métodos da classe, o código de dezenas de outros programadores não será mais compilado. Eles teriam que reescrever rapidamente seu código. E quanto mais reescritas acontecerem, mais oportunidades haverá para bugs. Se você quebrar regularmente a construção, será odiado.

Mas se alterarmos os métodos marcados como privados, saberemos que esses métodos não são chamados pelo código de ninguém em nenhum lugar. Podemos reescrevê-los e alterar o número e o tipo de parâmetros, e o código dependente ainda funcionará. Ou pelo menos ainda irá compilar.

4) Definimos como outros objetos irão interagir com nosso objeto.

Podemos restringir quais ações podem ser executadas em nosso objeto. Por exemplo, podemos querer que apenas uma instância de uma classe seja criada - mesmo que seja criada em vários lugares simultaneamente no projeto. E podemos conseguir isso usando encapsulamento.

O encapsulamento nos permite impor restrições adicionais que podem se transformar em benefícios adicionais . Por exemplo, a classe String é implementada como um objeto imutável . Uma instância da classe String não pode ser alterada entre sua criação e sua destruição. Todos os métodos da classe String (remove, substring, ...) retornam uma nova string e não alteram de forma alguma o objeto no qual são chamados.

"Caramba. Então é assim."

"O encapsulamento é intrigante."

"Concordo."