Praticando Java: encapsulamento

Encapsulamento - Apresentação

Olá. Meu nome é Jacqueline Oliveira, sou engenheira de software e instrutora na Alura.

Audiodescrição: Jacqueline se descreve como uma mulher de pele branca, olhos castanhos, cabelos longos com reflexos louros. Está com uma blusa rosa e brincos. Ao fundo, há uma parede com iluminação azul.

O que aprenderemos?

Neste curso, vamos discutir e praticar o encapsulamento, um dos pilares da programação orientada a objetos, que é de extrema importância para a segurança do nosso código.

Vamos compreender com mais profundidade o que é o encapsulamento, como implementá-lo e quais são seus benefícios. Esperamos que você curta este conteúdo e nos encontramos em breve para iniciar o curso. Até mais!

Encapsulamento - Encapsulamento

É importante entender o pilar de encapsulamento na programação orientada a objetos.

O encapsulamento é um conceito fundamental que restringe o acesso direto aos atributos de uma classe, fornecendo métodos específicos para esse acesso.

O benefício desse princípio é garantir a segurança dos dados, ter maior controle sobre as modificações e facilitar a manutenção do código.

Com o encapsulamento, asseguramos que apenas a própria classe pode modificar ou alterar dados importantes, pois teremos métodos específicos para controlar o acesso e proteger o código, evitando a exposição de informações vitais ou sigilosas.

Conhecendo o projeto

Vamos aplicar esse conceito, na prática, para facilitar o entendimento. Vamos abrir o IntelliJ, onde temos uma classe Principal que instancia um funcionário.

Principal.java:

public class Principal {
        public static void main(String[] args) {
                Funcionario funcionario = new Funcionario();
                funcionario.nome = "João";
                funcionario.cargo = "Desenvolvedor";
                funcionario.salario = 8500;

                funcionario.exibirInformacoes();
                funcionario.reajustarSalario(5);
                funcionario.exibirInformacoes();
        }
}

Esta classe Funcionario foi criada no curso de "Praticando Java: Orientação a objetos com classes, atributos e métodos" e representa um funcionário com nome, cargo e salário. Ela possui dois métodos: exibirInformacoes(), que mostra as informações do funcionário e reajustarSalario(), que ajusta o salário do funcionário.

Funcionario.java:

public class Funcionario {
        String nome;
        String cargo;
        double salario;

        public void exibirInformacoes() {
                System.out.printf("\nFuncionario %s - Cargo: %s - Salário %.2f",
                        nome, cargo, salario);
        }

        public void reajustarSalario(double percentual) {
                salario += salario * (percentual / 100);
                System.out.printf("\nNovo salario de %s é %.2f ", nome, salario);
        }
}

Na classe Principal, instanciamos um funcionario chamado João, que é um desenvolvedor com salário de R$ 8500. Em seguida, solicitamos a exibição das informações de João, realizamos um reajuste de salário de 5% e exibimos as informações novamente.

Vamos executar o código do arquivo Principal.java, clicando no botão "Run" (ou atalho "Shift + F10") localizado na barra superior da IDE.

Saída:

Funcionario João - Cargo: Desenvolvedor - Salário 8500,00
Novo salario de João é 8925,00
Funcionario João - Cargo: Desenvolvedor - Salário 8925,00

Com isso, verificamos que o salário de João é atualizado de R$ 8500 para R$ 8925. No entanto, se após o reajuste, atribuirmos diretamente um novo valor ao salario, o salário será reduzido. Por exemplo, vamos definir funcionario.salario igual a 8000.

Principal.java:

funcionario.exibirInformacoes();
funcionario.reajustarSalario(5);
funcionario.salario = 8000;
funcionario.exibirInformacoes();

Saída:

Funcionario João - Cargo: Desenvolvedor - Salário 8500,00
Novo salario de João é 8925,00
Funcionario João - Cargo: Desenvolvedor - Salário 8000,00

Isso ocorre porque a classe Principal pode alterar o salário sem proteção, anulando o reajuste feito anteriormente. Ou seja, uma informação tão vital quanto o salário de um funcionário não está protegida.

Essa situação não é a ideal. Nesse exemplo, estamos usando informações em memória. Mas, em geral, trabalhamos com informações provenientes de um banco de dados. E não é qualquer pessoa que pode visualizar ou alterar o salário.

Aplicando encapsulamento de atributos

Idealmente, essas regras e proteções devem estar na classe Funcionario, para impedir alterações diretas. Teoricamente, o salário só deveria ser reajustado através de um método específico.

Para isso, na classe Funcionario, vamos tornar os atributos nome, cargo e salario privados, utilizando a palavra reservada private. Assim, esses atributos não serão acessíveis por outras classes.

Funcionario.java:

public class Funcionario {
        private String nome;
        private String cargo;
        private double salario;

        // código omitido…
}

Com isso, a classe Principal apresentará alguns erros ao tentar atribuir valores diretamente. Para atribuir esses valores de duas maneiras: podemos criar métodos assessores, conhecidos como getters* e *setters; ou utilizar um construtor.

Atualmente, ao criar uma nova instância da classe Funcionario, utilizamos new Funcionario(). Não precisamos passar nenhum parâmetro, pois é um construtor vazio. Idealmente, podemos criar um construtor que exija nome e salario, garantindo assim que todo funcionário tenha essas informações ao ser criado.

Além disso, devemos impedir modificações posteriores no salario. Para os demais atributos que podem ser modificados, aí, sim, podemos criar métodos getters e setters específicos.

Criando um construtor

Na classe Funcionario, vamos pedir que a IDE crie um novo construtor. Basta apertar atalho "Alt + Insert", clicar na opção "Constructor" e escolher os campos nome:String e salario:double. Por fim, apertamos em "OK" e conferimos o código gerado:

public Funcionario(String nome, double salario) {
        this.nome = nome;
        this.salario = salario;
}

Na classe Principal, será necessário informar o nome e o salário na instância de new Funcionario(). Nos parâmetros, passamos uma string com o nome do João e um número com o salário de R$ 8500.

Com isso, também podemos apagar as linhas que atribuíam valores para nome e salario diretamente, pois isso não é mais permitido.

Principal.java:

Funcionario funcionario = new Funcionario("João", 8500);

Criando métodos assessores

Com o construtor, resolvemos o problema do nome e salário, mas como atribuir valores ao cargo? Para isso, criaremos métodos assessores.

Na classe Funcionario, após o construtor e antes do método eExibirInformacoes(), utilizamos "Alt + Insert" para criar "Getter and Setter" para o campo cargo:String.

O getter permite buscar o valor, enquanto o setter permite inserir um valor.

Com isso, a IDE automaticamente cria os métodos getCargo() e setCargo(), assim podemos visualizar e alterar o cargo do funcionário.

Funcionario.java:

public String getCargo() {
        return cargo;
}

public void setCargo(String cargo) {
        this.cargo = cargo;
}

Na classe Principal, iremos apagar a linha em que funcionario.cargo recebe a string "Desenvolvedor". A partir de agora, devemos fazer funcionario.setCargo(), passando a string "Desenvolvedor" como parâmetro.

Principal.java:

funcionario.setCargo("Desenvolvedor");

Dessa forma, encapsulamos os atributos nome, cargo e salario, garantindo que só possam ser alterados pelo construtor ou pelos getters e setters.

O getter é útil para exibir informações sem usar o método exibirInformacoes(). Por exemplo, para exibir o cargo de um funcionário, podemos utilizar System.out.println() com a string "Funcionário tem o cargo: " somado ao funcionario.getCargo(). Isso se aplica a qualquer atributo que desejamos tornar visível.

System.out.println("Funcionário tem o cargo: " + funcionario.getCargo())

Se não queremos permitir a visualização do salário, basta não criar um método get para o salário. Se não queremos permitir que o salário seja alterado sem ser através de um método de reajuste, também não fazemos um método set para o salário.

Essa é uma informação muito importante! Normalmente, quando criamos uma classe, colocamos os atributos como privados. No entanto, não é recomendado criar getters e setters para todos os atributos.

Devemos analisar o que de fato precisamos deixar visível e o que queremos permitir que seja modificado. Com isso, podemos criar os getters e setters à medida que percebemos essa necessidade. Afinal, se fizéssemos um método set para o salário, seu valor poderia ser facilmente alterado - o que não o protegeria adequadamente.

Controlando exibição de informações

No nosso contexto, podemos permitir a impressão separada do cargo, nome e também do salário. Por isso, na classe Funcionario, faremos apenas os getters para nome e salario, pois queremos que a classe Principal exiba o valor, mas não o modifique.

Vamos utilizar o atalho "Alt + Insert" e solicitar apenas o "Getter" para o campo nome:String e salario:double.

Funcionario.java:

public String getNome() {
        return nome;
}

public String getSalario() {
        return salario;
}

Dessa forma, podemos exibir essas dados individualmente, em vez de usar o método exibirInformacoes().

Na classe Principal, vamos excluir a primeira chamada do exibirInformacoes() e fazer o System.out.println() de cargo, nome e salário individualmente. Basta usar getCargo(), getNome() e getSalario().

O método reajustaSalarios() continua a funcionar, mas não podemos mais definir o salario diretamente. Por isso, vamos apagar funcionario.salario. Nesse caso, sempre precisaremos usar o método reajustarSalario para qualquer reajuste. Assim, garantimos que não será possível alterar o valor livremente. Uma vez que criamos um novo funcionario com salário de R$ 8500, só podemos alterá-lo através de reajuste.

Principal.java:

public class Principal {
        public static void main(String[] args) {
                Funcionario funcionario = new Funcionario("João", 8500);
                funcionario.setCargo("Desenvolvedor");

                System.out.println("Funcionário tem o cargo: " + funcionario.getCargo())
                System.out.println("Funcionário tem o nome: " + funcionario.getNome())
                System.out.println("Funcionário tem o salario: " + funcionario.getSalario())

                funcionario.reajustarSalario(5);
                funcionario.exibirInformacoes();
}

Vamos executar a aplicação para verificar o resultado no console.

Saída:

Funcionário tem o cargo Desenvolvedor
Funcionário tem o nome João
Funcionário tem o salário 8500.0

Novo salario de João é 8925,00
Funcionario João - Cargo: Desenvolvedor - Salário 8925,00

O novo funcionário chamado João, tem o cargo de desenvolvedor e ganha R$ 8500. Após o reajuste, o salário aumenta para R$ 8925.

Implementando regras de negócio

Além disso, podemos adicionar outras proteções, como controlar que só pode haver um reajuste salarial. Na classe Funcionario, no método reajustarSalario(), podemos ter um controlador para verificar se já foi feito um reajuste.

Para isso, ciamos um novo atributo private int chamado controleReajuste, que será iniciado com zero. Cada vez que ocorrer um reajuste, incrementamos esse valor. Basta colocar controleReajuste++ no método reajustarSalario().

Podemos controlar para que o reajuste só ocorra se não houver reajustes anteriores, ou seja, se controleReajuste estiver com valor zero. Se já houve um reajuste, não permitiremos mais um. Para isso, utilizamos uma condicional: if (controleReajuste >= 1). Caso isso seja verdadeiro, imprimimos a mensagem "Não pode fazer mais reajustes".

Também faremos um else, que conterá o restante do código. Assim, caso não houver reajustes anteriores, podemos prosseguir com o ajuste do salário.

Funcionario.java:

private int controleReajuste = 0;

public void reajustarSalario(double percentual) {
        if (controleReajuste >= 1) {
                System.out.println("\nNão pode fazer mais reajustes.");
        } else {
                controleReajuste++;
                salario += salario * (percentual / 100);
                System.out.printf("\nNovo salario de %s é %.2f ", nome, salario);
        }
}

Vamos testar esse código na classe Principal. Já fizemos um reajuste de salário de 5%. Agora, tentaremos fazer um segundo. Solicitamos um novo reajuste com percentual de 10%.

Principal.java:

funcionario.reajustarSalario(5);
funcionario.reajustarSalario(10);
funcionario.exibirInformacoes();

Primeiro, exibimos os dados dos funcionários através dos getters, depois reajustamos e, por fim, exibimos as informações.

Saída:

Funcionário tem o cargo Desenvolvedor
Funcionário tem o nome João
Funcionário tem o salário 8500.0

Novo salario de João é 8925,00
Não pode fazer mais reajustes.
Funcionario João - Cargo: Desenvolvedor - Salário 8925,00

Ao executar, conferimos que o novo salário depois do primeiro reajuste foi para R$ 8925. No entanto, não foi possível fazer um segundo reajuste, mantendo o salário em R$ 8925.

Assim, não foi possível definir o valor do salário diretamente nem fazer mais reajustes do que o permitido. O encapsulamento garantiu a segurança da classe, controlando a modificação e impedindo múltiplos reajustes em um período. Poderíamos ter um atributo que controla a data do último reajuste para garantir que reajustes só ocorram com, no mínimo, seis meses de intervalo.

Também poderíamos fazer proteções na alteração do cargo, permitindo alterações apenas se estivermos logados com a senha de administrador.

Compreendendo vantagens do encapsulamento

Quando usamos a palavra reservada private nos atributos e controlamos o acesso através de métodos, seja pelo construtor, métodos assessores ou métodos adicionais, o encapsulamento força seu uso correto e controla os tipos de modificações permitidas.

No caso da classe Principal, a pessoa é obrigada a utilizar o método reajustarSalario(), passando um percentual, mas a regra de como o reajuste é feito não é visível para a classe Principal. Ela não sabe se analisamos faltas ou se já houve um reajuste. A pessoa usuária apenas solicita o reajuste e recebe uma informação.

Usamos os métodos para encapsular informações importantes que somente a classe pode acessar. Somente a classe conhece as regras de negócio. Inclusive, isso facilita alterações, pois não importa quantos lugares na aplicação chamem o reajustarSalario(), a correção é feita apenas na classe Funcionario.

De forma resumida, as vantagens do encapsulamento incluem:

• proteção de dados;
• facilidade de manutenção;
• maior controle, pois permite validações antes de aceitar dados e gravá-los no banco de dados;
• flexibilidade, pois expõe apenas as informações desejadas.

Por exemplo, criamos um controlador para a quantidade de reajustes, mas não expusemos isso na classe Principal. Assim, conseguimos mais proteção e qualidade nas aplicações que aplicam esse pilar.

Próximos passos

Pratique bastante para consolidar seus conhecimentos. Esperamos que você tenha gostado do conteúdo. Deixe sua avaliação e nota para o curso, pois nosso objetivo é sempre trazer conteúdos melhores.

Em caso de dúvidas, você pode postar no fórum ou no Discord da Alura. Te esperamos em um próximo curso. Até mais!

Sobre o curso Praticando Java: encapsulamento

O curso Praticando Java: encapsulamento possui 21 minutos de vídeos, em um total de 17 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Encapsulamento