Princípios de encapsulamento em Java

Olá! A palestra de hoje será dedicada ao encapsulamento e começaremos imediatamente com exemplos :) Na sua frente está uma máquina de refrigerante familiar. Tenho uma pergunta para você: como funciona? Procure responder detalhadamente: de onde vem o copo, como é mantida a temperatura interna, onde o gelo é armazenado, como a máquina entende que calda adicionar, etc. Muito provavelmente você não tem respostas para essas perguntas. Bem, talvez nem todo mundo use essas máquinas; elas não são tão populares hoje em dia. Vamos tentar dar outro exemplo. Algo que você sabe que usa muitas vezes ao dia. Ah, eu tenho uma ideia! Conte-nos como funciona o mecanismo de busca do Google . Como exatamente ele busca informações com base nas palavras que você digitou? Por que esses resultados estão no topo e outros não? Mesmo que você use o Google todos os dias, provavelmente não sabe disso. Mas não é importante. Afinal, você não precisa saber disso. Você pode inserir consultas em um mecanismo de pesquisa sem pensar exatamente como ele funciona. Você pode comprar refrigerante em uma máquina de venda automática sem saber como funciona. Você pode dirigir um carro sem se aprofundar no funcionamento do motor de combustão interna e sem saber nada de física, mesmo no nível escolar. Tudo isso é possível graças a um dos princípios básicos da programação orientada a objetos - o encapsulamento . Ao ler vários artigos sobre este tópico, você provavelmente percebeu que existem dois conceitos comuns em programação - encapsulamento e ocultação . E com a palavra “encapsulamento” os autores querem dizer uma coisa ou outra (na verdade). Iremos dividir os dois termos para que você tenha um entendimento completo. O significado original da palavra “ encapsulamento ” em programação é a combinação de dados e métodos para trabalhar com esses dados em um pacote (“cápsula”). Em Java, a classe atua como um pacote cápsula . Uma classe contém dados (campos de classe) e métodos para trabalhar com esses dados. Isso parece óbvio para você, mas em outros conceitos de programação tudo funciona de forma diferente. Por exemplo, na programação funcional, os dados são estritamente separados das operações neles realizadas. Na OOP (programação orientada a objetos), os programas consistem em classes cápsula, que são tanto dados quanto funções para trabalhar com eles. Agora vamos falar sobre esconder . Como é que usamos todos os tipos de mecanismos complexos sem compreender como funcionam e em que se baseia o seu trabalho? É simples: seus criadores forneceram uma interface simples e amigável. Em uma máquina de refrigerante, a interface são botões em um painel. Ao pressionar um botão, você seleciona o volume do vidro. Ao pressionar o segundo, você seleciona a calda. O terceiro é responsável por adicionar gelo. E isso é tudo que você precisa fazer. Não importa exatamente como a máquina é projetada por dentro. O principal é que ele foi projetado de forma que, para conseguir refrigerante, o usuário precise apertar três botões . É a mesma coisa com um carro. Não importa o que esteja acontecendo dentro dele. O principal é que ao pisar no pedal direito o carro avança e ao pisar no pedal esquerdo ele desacelera . Esta é precisamente a essência da ocultação. Todos os “interiores” do programa ficam ocultos ao usuário. Para ele, essa informação é supérflua e desnecessária. O usuário precisa do resultado final, não do processo interno. Vejamos a classe como exemplo Auto:

public class Auto {

   public void gas() {

       /*some complicated things are happening inside the car
       as a result of which it goes forward*/
   }

   public void brake() {

       /*some complicated things are happening inside the car
       as a result of which it slows down*/
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // How everything looks to the user

       //pressed one pedal - went
       auto.gas();

       //pressed another pedal - braked
       auto.brake();
   }
}

É assim que se parece a ocultação de implementação em um programa Java. Tudo é como na vida real: o usuário dispõe de uma interface (métodos). Se ele precisar do carro do programa para realizar uma ação, basta chamar o método desejado. E o que acontece dentro desses métodos são informações desnecessárias, o principal é que tudo funcione como deveria. Aqui falamos sobre ocultar a implementação . Além disso, Java também possui ocultação de dados . Escrevemos sobre isso na palestra sobre getters e setters , mas não faria mal nenhum lembrar. 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 da última palestra qual é o problema desta aula? Se não, vamos lembrar. O problema é que seus dados (campos) estão abertos a todos, e outro programador pode facilmente criar um gato sem nome no programa 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;

}

Em tal situação, você pode monitorar de perto se um de seus colegas está criando objetos com o estado errado, mas seria muito melhor excluir a possibilidade de criar tais “objetos errados”. Eles nos ajudam a ocultar dados:

1. modificadores de acesso ( private , protected , package default );
2. getters e setters.

Lá podemos, por exemplo, verificar se alguém está tentando atribuir um número negativo ao gato como a sua idade. Como dissemos anteriormente, os autores de vários artigos sobre encapsulamento significam encapsulamento (combinando dados e métodos) ou ocultação, ou ambos. Java possui ambos os mecanismos (este não é necessariamente o caso em outras linguagens OOP), portanto a última opção é a mais correta. Usar o encapsulamento nos oferece várias vantagens importantes:

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


2. Facilidade de uso devido à interface. Deixamos apenas métodos “de fora” para acesso do usuário. Tudo o que ele precisa fazer é ligar para eles para saber o resultado, e ele não precisa se aprofundar nos detalhes do trabalho deles.


3. As alterações no código não afetam os usuários. Fazemos todas as alterações dentro dos métodos. Isso não afetará o usuário: ele escreveu auto.gas() para a gasolina do carro, então ele irá escrever. E o fato de termos mudado algo no funcionamento do método gas() permanecerá invisível para ele: ele, como antes, simplesmente receberá o resultado desejado.