Encapsulamento em Java

Oi! Vamos dedicar a lição de hoje ao encapsulamento em Java e começar com exemplos logo de cara :) Aqui você tem uma máquina comum de distribuição de refrigerantes . Eu tenho uma pergunta para você: como isso funciona? Tente dar uma resposta detalhada: De onde vem o refrigerante? Como é mantida a temperatura interna? Onde o gelo é armazenado? Como a máquina sabe qual calda adicionar? Você provavelmente não tem respostas para essas perguntas. Ok, talvez nem todo mundo use essas máquinas. Eles não são tão populares no momento. Vamos tentar outro exemplo. Algo que você definitivamente usa muitas vezes todos os dias. Ah, eu tenho uma ideia! Diga-me como o mecanismo de pesquisa do Googlefunciona. Como exatamente ele procura informações sobre as palavras que você insere? Por que esses resultados estão no topo e não outros? Mesmo que você use o Google todos os dias, provavelmente não sabe. Mas isso não importa. Afinal, não é algo que você precisa saber. Você pode usar um mecanismo de pesquisa sem pensar exatamente em como ele funciona. Você pode comprar refrigerante de uma máquina sem saber como ele é feito. Você pode dirigir um carro sem se aprofundar no funcionamento do motor de combustão interna e sem nem mesmo saber física do ensino médio. Tudo isso é possível graças a um dos principais princípios da programação orientada a objetos: o encapsulamento. Ao ler diferentes artigos sobre o assunto, você deve ter encontrado dois conceitos de programação amplamente difundidos: encapsulamento e ocultação de informações. Acontece que pessoas diferentes entendem a palavra ' encapsulamento' para significar coisas diferentes. Vamos decifrar ambos os termos para que você tenha uma compreensão completa. Na programação, o significado original deO encapsulamento combinava dados e métodos para trabalhar com esses dados em um pacote ("cápsula"). Em Java, o pacote de encapsulamento é a classe . A classe contém dados (campos) e métodos para trabalhar com esses dados. Isso pode parecer óbvio para você, mas tudo é organizado de maneira diferente em outros paradigmas de programação. Por exemplo, na programação funcional, os dados são estritamente separados das operações de dados. Na programação orientada a objetos (OOP), os programas consistem em cápsulas (classes) que consistem em dados e funções para trabalhar com dados.

Agora vamos falar sobre ocultação de informações

Como usamos todos os tipos de mecanismos complexos sem entender como eles são construídos ou funcionam? É simples: seus criadores forneceram interfaces simples e convenientes. Em uma máquina de refrigerante, a interface são os botões do painel frontal. Um botão permite escolher o tamanho do copo. Você escolhe a calda com um segundo botão. Um terceiro é responsável por adicionar gelo. E isso é tudo que você precisa fazer. Não importa como é a máquina por dentro. O importante é que ele foi projetado para que o usuário obtenha refrigerante pressionando três botões. A mesma coisa se aplica a um carro. Não importa o que está acontecendo lá dentro. O importante é que quando você pressiona o pedal direito o carro avança, e quando você pressiona o pedal esquerdo o carro desacelera. Esta é a essência da ocultação de informações. Tudo de um programa' s 'entranhas' estão escondidas do usuário. Tais informações são supérfluas ou desnecessárias para o usuário. O usuário precisa de um resultado final, não de um processo interno. Por exemplo, vamos dar uma olhada noClasse do veículo :

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

É assim que a implementação fica oculta em um programa Java. Assim como na vida real: o usuário recebe uma interface (métodos). Em um programa, se você precisar de um carro para executar uma ação, basta chamar o método desejado. O que acontece dentro desses métodos é supérfluo. O que importa é que tudo funcione como deveria. Aqui falamos sobre ocultação de implementação. Java também possui ocultação de dados. Escrevemos sobre isso na lição sobre getters e setters, mas um lembrete não vai doer. Por exemplo, temos uma classe Cat :

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Talvez você se lembre de uma aula anterior qual é o problema com esta classe? Se não, vamos relembrar. O problema é que seus dados (campos) são abertos a todos. Outro programador poderia facilmente criar um gato sem nome com peso 0 e idade de -1000 anos:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

Nessa situação, você poderia rastrear cuidadosamente se um de seus colegas está criando objetos com estado inválido, mas seria muito melhor eliminar até mesmo a possibilidade de criar esses objetos inválidos. Conseguimos a ocultação de dados com a ajuda de:

1. modificadores de acesso ( privado, protegido, padrão do pacote );
2. getters e setters.

Nós os usamos para verificar se alguém está tentando dar uma idade negativa ao gato. Como dissemos anteriormente, os autores de vários artigos sobre encapsulamento estão, na verdade, se referindo ao encapsulamento (combinação de dados e métodos) ou ocultação de informações, ou ambos. Java possui ambos os mecanismos (isso não é necessariamente o caso em outras linguagens OOP), então a última opção é a mais correta.

O encapsulamento nos dá várias vantagens importantes:

1. Monitorando o estado correto do objeto. Demos exemplos disso acima: graças ao setter e ao modificador privado , protegemos nosso programa contra gatos com peso 0.


2. Interface amigável. Deixamos apenas os métodos expostos ao usuário. O usuário simplesmente precisa chamá-los para obter um resultado. E não há nenhuma necessidade de se aprofundar nos detalhes de como eles funcionam.


3. As alterações de código não afetam os usuários. Fazemos todas as alterações dentro dos métodos. Isso não afeta os usuários: eles escreveram vehicles.gas() para aplicar o gás, e é isso que eles continuarão fazendo. O fato de termos alterado algo dentro do método gas() permanece invisível: como antes, eles simplesmente obtêm o resultado necessário.