DEV Community: guilhermegarcia86

Primeiros Passos no MIT App Inventor: Um Guia para Iniciantes

guilhermegarcia86 — Thu, 22 May 2025 22:19:48 +0000

Introdução

Se você é estudante de programação ou quer apenas criar aplicativos para Android ou iOS sem precisar aprender linguagens complexas de programação, o MIT App Inventor é uma excelente porta de entrada. Esta plataforma gratuita permite desenvolver apps de forma visual, usando blocos lógicos e uma interface drag-and-drop (arrasta e solta).

Neste artigo, você aprenderá como criar sua conta e iniciar seu primeiro projeto no MIT App Inventor, pronto para ser testado no seu celular.

O que é o MIT App Inventor?

O MIT App Inventor é uma ferramenta criada pelo Massachusetts Institute of Technology que permite a qualquer pessoa criar apps por meio de uma interface visual. É ideal para iniciantes, escolas técnicas, e projetos rápidos de prototipagem.

Requisitos

Uma conta Google (Gmail)
Navegador (Chrome, Firefox, Edge, etc.)
Smartphone com Android ou iOS para testes (opcional, mas recomendado)

Passo 1 – Acessando o site

Acesse o site oficial: https://appinventor.mit.edu
Clique no botão "Create apps!" no canto superior direito.

Passo 2 – Fazendo login com o Google

Você será redirecionado para a página de login do Google. Faça login com a conta que deseja usar para salvar seus projetos.

⚠️ Importante: o MIT App Inventor salva seus projetos automaticamente na nuvem, vinculados à sua conta Google.

Passo 3 – Criando seu primeiro projeto

Após o login:

Clique em "New project"

Digite um nome para o projeto, como MeuPrimeiroApp (sem espaços ou acentos)
Clique em OK

Passo 4 – Conhecendo a interface

Você será levado para a tela principal do editor, com duas abas importantes:

Designer: para montar a interface do app
Blocks: para programar a lógica com blocos visuais

Neste primeiro momento, seu projeto estará em branco. Isso é normal! A partir daqui, você poderá adicionar botões, campos de texto, listas e programar seus comportamentos.

Passo 5 – Testando o app no celular

Se quiser visualizar o app no seu celular:

Baixe o app MIT AI2 Companion na Play Store ou App Store
No MIT App Inventor, clique em "Connect" > "AI Companion"
Escaneie o QR code usando o app no celular

Conclusão

Parabéns! Agora você está com sua conta criada e seu primeiro projeto em branco pronto para ser desenvolvido. A partir daqui, você pode começar a montar interfaces e adicionar lógica com blocos de programação.

Nos próximos tutoriais, vamos mostrar como:

Adicionar itens em uma lista com TinyDB
Criar apps de cadastro simples
Trabalhar com variáveis e estruturas de decisão

Dúvidas frequentes

Preciso instalar algo no computador?

Não. Tudo é feito pelo navegador.

Funciona no iPhone?

Sim. Mas no iOS, você só pode testar via QR Code no app Companion — não é possível instalar o APK.

Preciso saber programar?

Não. O sistema usa blocos visuais, ideal para iniciantes.

Gostou do conteúdo?

Se esse tutorial te ajudou, compartilhe com outras pessoas que também querem começar a programar! 🚀

Primeiros passos com Java IX - Trabalhando com Enums

guilhermegarcia86 — Tue, 30 Nov 2021 00:00:01 +0000

Nos artigos anteriores estava sendo abordado o tema do básico de Programação Orientada a Objetos no Java ; porém existem outros tópicos da linguagem que seria bom serem apresentados. Iniciaremos com Enumerações e no final desse artigo você será capaz de entender o que são, como criá-las e usar.

Enumerações foram introduzidas no Java5 e são uma forma dos desenvolvedores trabalharem melhor com dados que não podem ser alterados do que usando constantes , ela foi introduzida como sendo um tipo novo na linguagem o que significa que os desenvolvedores ganharam uma forma de checagem de tipos em tempo de compilação, o que ajuda muito no desenvolvimento principalmente por que possíveis erros são apontados no momento em que estamos escrevendo o código ao invés de só perceber, se perceber, o erro quando o código já está rodando e sendo usado. Juntamente com a tipagem foi adicionado um pacote novo, o java.lang.Enum e com isso uma série de métodos foram herdados quando uma Enum é criada.

Para entender a motivação para adicionar Enums no Java vamos supor que temos um código que valida o dia da semana, sabemos que os nomes dos dias da semana são imutáveis então podemos criar constantes para isso da seguinte forma:

public class DiaDaSemana {

    public static final String DOMINGO = "DOMINGO";
    public static final String SEGUNDA = "SEGUNDA";
    public static final String TERCA = "TERCA";
    public static final String QUARTA = "QUARTA";
    public static final String QUINTA = "QUINTA";
    public static final String SEXTA = "SEXTA";
    public static final String SABADO = "SABADO";

}

Tendo em mãos as contantes podemos criar o método que lida com o dia da semana e a partir dele toma alguma decisão:

public static void avaliaDiaDaSemana(String diaDaSemana){
    switch (diaDaSemana){
        case DiaDaSemana.DOMINGO:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DO DOMINGO");
            break;
        case DiaDaSemana.SEGUNDA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA SEGUNDA");
            break;
        case DiaDaSemana.TERCA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA TERCA");
            break;
        case DiaDaSemana.QUARTA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA QUARTA");
            break;
        case DiaDaSemana.QUINTA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA QUINTA");
            break;
        case DiaDaSemana.SEXTA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA SEXTA");
            break;
        case DiaDaSemana.SABADO:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DO SABADO");
            break;
    }
}

No código acima foi feito uso de um switch-case sem uma cláusula default pois o desenvolvedor assumiu que como esse método sempre vai receber dias da semana não haveria o por que adicionar um default pois não seria executado. Agora vamos simular um caso de uso e testar essa hipótese:

public static void main(String[] args) {

    String diaDaSemana = "JANEIRO";

    avaliaDiaDaSemana(diaDaSemana);
}

Ao executar esse código nada será impresso pois houve uma falha no dado de entrada e isso não ficou explícito em nenhum ponto do código, uma possível solução aqui seria adicionar o default porém só estaríamos contornando o problema pois esse método permite a entrada de Strings mas no desenvolvimento nós queremos apenas dias da semana como uma entrada válida e se tentassem passar qualquer valor que não seja um dia da semana não poderia ser executado, graças as Enums isso se torna possível.

Criando Enums

Criar uma Enum é como criar uma classe porém utilizamos a palavra reservada enum , para ficar claro o código abaixo é a criação de uma Enum representando os dias da semana:

public enum DiaDaSemana {
    DOMINGO,
    SEGUNDA,
    TERCA,
    QUARTA,
    QUINTA,
    SEXTA
}

Foi criado uma Enum simples e iremos evoluí-la ao passar do artigo e ver outras vantagens que ganhamos com iso. Uma enum carrega consigo um valor que por padrão é o próprio nome do item na Enum , então conseguimos fazer validações do tipo:

System.out.println(DiaDaSemana.valueOf("DOMINGO"));

O método valueOf que vem herdado do pacote java.lang.Enum retorna o item da Enum correspondente se o valor combinar com algum valor da Enum ou lança uma exceção IllegalArgumentException caso não encontre nenhum valor que combine com a String informada, você pode ter notado que bastou adicionar a palavra enum e automaticamente ganhamos vários métodos como o valueOf , name , ordinal e etc.

Usando Enums

Agora vamos alterar o método avaliaDiaDaSemana para trabalhar com a Enum DiaDaSemana :

public static void avaliaDiaDaSemana(DiaDaSemana diaDaSemana){
    switch (diaDaSemana){
        case DOMINGO:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DO DOMINGO");
            break;
        case SEGUNDA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA SEGUNDA");
            break;
        case TERCA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA TERCA");
            break;
        case QUARTA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA QUARTA");
            break;
        case QUINTA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA QUINTA");
            break;
        case SEXTA:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DA SEXTA");
            break;
        case SABADO:
            System.out.println("EXECUTANDO REGRA DE NEGÓCIO DO SABADO");
            break;
    }
}

Agora o método recebe a Enum DiaDaSemana e não há como passar outro valor que não seja um DiaDaSemana para o método avaliaDiaDaSemana :

avaliaDiaDaSemana(DiaDaSemana.DOMINGO);

Se tentarmos usar outro tipo que não seja um DiaDaSemana o código não irá compilar e se forçarmos o uso de outro valor será lançada uma Exception :

//Não compila
avaliaDiaDaSemana("OutroValor");

//IllegalArgumentException
avaliaDiaDaSemana(DiaDaSemana.valueOf("DIA QUE NÃO EXISTE"));

Atributos e métodos com Enums

Vimos o exemplo de como criar uma Enum do jeito mais simples possível, porém Enums podem ter atributos e métodos associados a elas. Isso ocorre pois uma Enumeração se comporta como se fosse uma classe estática, uma classe que não pode ser instanciada, então se é uma classe é possível existir atributos e métodos, a própria utilização de uma Enum se assemelha ao uso de um método estático, exemplo: DiaDaSemana.DOMINGO. Por conta disso caso seja necessário ter métodos ou atributos que auxiliem na execução de Enums podemos adicionar da seguinte maneira, começando pelo atributos:

public enum DiaDaSemana {
    DOMINGO("Domingo"),
    SEGUNDA("Segunda"),
    TERCA("Terça"),
    QUARTA("Quarta"),
    QUINTA("Quinta"),
    SEXTA("Sexta"),
    SABADO("Sábado");

    private String nome;

    DiaDaSemana(String nome){
        this.nome = nome;
    }
}

Como Enums se comportam como classes, com a exceção de que não podem ser instanciadas, podemos criar atributos mas para ligá-los ao itens da Enum DiaDaSemana é necessário que esses itens, da Enum , estejam instanciados dentro da Enum e para isso foi criado um construtor, que não é público, fazendo a ligação do atributo nome para cada item no Enum e por fim foi criado um valor para cada um deles.

Para criar métodos em Enums é o mesmo que criar métodos em classes:

public String getNome(){
    return this.nome;
}

A utilização dos métodos é muito parecido com o que vemos em métodos estáticos:

System.out.println(DiaDaSemana.DOMINGO.getNome());

E o resultado é o atributo nome que está associado ao item DOMINGO :

Domingo

Para esclarecer um pouco mais vamos criar outro método para verificar se o dia é final de semana:

public boolean verificaFinalDeSemana(){
    if(this == SABADO || this == DOMINGO){
        return true;
    }

    return false;
}

O método acima verifica se o dia testado é um sábado ou domingo e retorna um true caso seja e um false caso não seja, perceba que é passado o operador this e ele se refere a instancia do item do Enum que irá chamar o método verificaFinalDeSemana :

System.out.println(DiaDaSemana.SEGUNDA.verificaFinalDeSemana());
System.out.println(DiaDaSemana.SABADO.verificaFinalDeSemana());

Então quando o Enum DiaDaSemana.SEGUNDA chamar o método verificaFinalDeSemana o this se refere a SEGUNDA e assim em todos os itens da Enum , rodando esse código o resultado é:

false
true

Conclusão

Quando se trabalha com Enum na maioria das vezes é por que existe uma coleção de dados que devem constante e queremos que isso seja garantido, Enums suprem muito bem essa necessidade. Existem outras maneiras de trabalhar com Enums como EnumSet e EnumMap porém esses são tópicos mais avançados de Enums e não tão comumente usados no dia-a-dia, porém com o que foi passado você será capaz de entender quando usar Enums e como usá-las para tirar o máximo proveito possivel delas.

O código deste artigo se encontra no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java VIII - Polimorfismo e Interface

guilhermegarcia86 — Wed, 17 Nov 2021 00:00:01 +0000

Polimorfismo e Interface

No último artigo foi mostrado a Herança e como podemos fazer uso de Classes Abstratas , para criar estruturas que podem ser usadas para realizar Herança mas sem que sejam criadas classes a partir delas. Agora vamos abordar o tema Polimorfismo e como é importante esse conhecimento para se trabalhar de forma orientada a objetos com Java.

Polimorfismo significa múltiplas formas e aqui veremos como podemos tirar vantagem de um código que pode assumir muitas formas e deixar todo o processamento mais fluído e flexível.

Ao fim desse artigo você será capaz de saber usar e identificar o Polimorfismo em seu código e também estará ciente das vantagens que esse recurso trás.

Antes mesmo de entrar no assunto de Polimorfismo é extremamente importante entender o que é uma Interface na Java , pois é um recurso muito usado em conjunto com Polimorfismo.

Uma Interface é um contrato que define “esqueletos” de métodos para que sejam implementados por classes. Muito similares com a ideia de Classes Abstratas , é uma estrutura que não pode ser instanciada porém existem diferenças entre Interfaces e Classes Abstratas e iremos ver algumas no decorrer do artigo.

Voltando ao exemplo base que está sendo usado nos outros artigos, a nossa aplicação bancária possui uma Classe Abstrata que se refere a uma Conta e não faz sentido nessa aplicação que seja possível criar uma conta sem dizer se é de pessoa física ou jurídica, então a classe Conta foi definida como uma Classe Abstrata onde através de Herança foi definido classes filhas ou sub-classes de Conta ( PessoaFisica e PessoaJuridica ), então podemos concluir que as classes PessoaFisica e PessoaJuridica são do mesmo tipo da classe Conta já que são filhas e isso é chamado de relacionamento É-UM onde a classe PessoaFisica é considerada uma Conta. Podemos definir outro tipo de relacionamento no Java onde a classe também será do tipo É-UM porém com uma ideia mais voltada para a capacidade que essa classe irá possuir e fazemos isso com Interface.

Para ficar mais claro vamos criar uma Interface que será responsavel pelos serviços de financiamentos, vamos chamá-la de Financiamento :

public interface Financiamento {

    boolean pegaEmprestimo(Conta conta);

    BigDecimal liberaEmprestimo(Conta conta, BigDecimal valor);
}

No código anterior foi definido dois métodos, um chamado pegaEmprestimo que recebe uma Conta como argumento e devolve um boolean e outro chamado liberaEmprestimo que também recebe uma Conta e devolve um BigDecimal que seria referente ao valor do emprestimo liberado. Podemos ver que uma Interface define os contratos de métodos porém não provê uma implementação, também não foi passado nenhum modificador de acesso, porém no caso de interfaces isso não significa que esses métodos sejam default como vimos em artigos anteriores, nesse caso não precisamos informar mas todo método em uma Interface é automaticamente public e abstract sempre.

Com a Interface criada iremos criar uma classe chamada Banco e iremos fazer com que essa classe possa ter a capacidade de fornecer financiamentos:

public class Banco implements Financiamento{

    private String nome;
    private List<Conta> contas;

    public Banco(String nome, List<Conta> contas) {
        this.nome = nome;
        this.contas = contas;
    }

    @Override
    public boolean pegaEmprestimo(Conta conta) {
        return new Random().nextBoolean();
    }

    @Override
    public BigDecimal liberaEmprestimo(Conta conta, BigDecimal valor) {
        if (this.pegaEmprestimo(conta)) {
            return valor;
        }
        return valor.divide(new BigDecimal(2));
    }

    public String getNome() {
        return nome;    
    }

    public List<Conta> getContas() {
        return List.copyOf(contas);
    }
}

Nesse exemplo temos a classe Banco e quando queremos usar Interfaces adicionamos a palavra reservada implements que como o próprio nome diz irá implementar aquela Interface e criar um relacionamento entre a Classe e a Interface , também foi necessário implementar os métodos pegaEmprestimo e liberaEmprestimo, onde o pegaEmprestimo só devolve um boolean aleatório e o método liberaEmprestimo que se baseia no retorno do pegaEmprestimo para saber a quantidade que será liberada de crédito, caso a analise de crédito retorne um true ele poderá pegar o valor total solicitado e caso retorne false poderá pegar a metade.

Podemos começar a ver um pouco de Polimorfismo nesse código onde os métodos pegaEmprestimo e liberaEmprestimo recebem como argumento uma Conta sem fazer distinção se é uma conta de pessoa física ou jurídica e se por acaso no futuro existir outro tipo de conta esse código está preparado para recebê-lo, o que torna o nosso código mais flexível e desacoplado das implementações como PessoaFisica ou PessoaJuridica.

Agora podemos criar uma instância de Banco e fazer as operações de Financiamento para as Contas :

public class Main {

    public static void main(String[] args) {

        Conta contaFisicaGuilherme = new PessoaFisica("Guilherme");
        Conta contaJuridicaGuilherme = new PessoaJuridica("Empresa do Guilherme");

        Banco banco = new Banco("MeuBanco", List.of(contaFisicaGuilherme, contaFisicaGuilherme));

        BigDecimal valorLiberado = banco.liberaEmprestimo(contaFisicaGuilherme, new BigDecimal("1000"));
        System.out.println("Valor liberado %s para conta %s".formatted(valorLiberado, contaFisicaGuilherme));

        valorLiberado = banco.liberaEmprestimo(contaJuridicaGuilherme, new BigDecimal("10000"));
        System.out.println("Valor liberado %s para conta %s".formatted(valorLiberado, contaJuridicaGuilherme));
    }
}

Explicando o código acima, primeiramente criamos duas classes, uma para PessoaFisica e outra para PessoaJuridica porém as duas foram atribuídas para variáveis do tipo Conta , isso também é o Polimorfismo em ação pois como foi dito anteriormente tanto a classe PessoaFisica quanto PessoaJuridica são filhas ou sub-classes da classe Conta e por isso podemos referenciar dessa maneira, e podemos passar para o método liberaEmprestimo uma PessoaFisica ou PessoaJuridica que são uma Conta também, porém poderíamos passar uma variável do tipo PessoaFisica ou PessoaJuridica pois como dissemos elas também são do tipo Conta.

Um ponto diferente entre Interfaces e Classes Abstratas é que pode haver múltiplas implementações de Interfaces para uma classe, coisa que não pode acontecer com Classes Abstratas já que não existe Herança múltipla no Java mas com Interfaces podemos adicionar esse comportamento e para exemplificar isso iremos criar outra Interface para serviços de transferências do banco:

public interface Transferencia {

    void realizaTransferencia(Conta origem, Conta destino, BigDecimal valor);
}

Criamos uma Interface Transferencia com um método realizaTransferencia que recebe a Conta de origem, a Conta de destino e o valor da transferência, e aqui fica bem claro a ideia de Polimorfismo já que não amarramos uma transferência para uma conta jurídica ou física; vamos adicionar essa funcionalidade na classe Banco :

public class Banco implements Financiamento, Pagamento{

    //TODO O RESTO OMITIDO

    @Override
    public void realizaTransferencia(Conta origem, Conta destino, BigDecimal valor) {
        BigDecimal valorSacado = origem.saca(valor);
        destino.deposita(valorSacado);
    }

}

Como visto no código acima para fazer a implementação de múltiplas Interfaces no Java basta adicioná-las após a palavra implements separadas por vírgula. Nesse exemplo foi implementado a transferência entre contas onde basicamente é feito o saque de uma conta e o depósito em outra, como fazemos uso do Polimorfismo nesse caso não ficamos amarrados ou presos a detalhes de implementação de como as contas fazem esse procedimento, após declararmos o que queremos que seja feito sabemos que as implementações irão executar suas responsabilidades. Foram feitos alguns ajustes para que esse lógica funcionasse, primeiramente olhando a classe Conta :

public abstract class Conta {

    protected BigDecimal saldo;

    public Conta() {
        this.saldo = new BigDecimal("1000");
    }
}

Foi adicionado o atributo saldo que também foi adicionado ao construtor da classe Conta para que na inicialização aja saldo com valor de 1000 quando uma conta nova é criada, uma observação é que mesmo não podendo criar uma instância de uma Classe Abstrata podemos ter um construtor que será usado pelas classe filhas, já nas classes PessoaFisica e PessoaJuridica foi adicionado ao construtor a chamada para o construtor da classe mãe. E adicionamos a lógica para subtrair ou adicionar ao saldo quando ocorrer um saque ou um depósito, segue o exemplo na classe PessoaFisica :

public class PessoaFisica extends Conta {
    public static final String TIPO_DE_DOCUMENTO = "CPF";

    public PessoaFisica(String nome){
        //CHAMADA AO CONSTRUTOR DA CLASSE MÃE
        super();
        this.documento = TIPO_DE_DOCUMENTO;
        this.nome = nome;
    }

    @Override
    public BigDecimal saca(BigDecimal quantidade) {
        System.out.println("APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE");
        System.out.println("SAQUE PARA PESSOA " + this.nome + " COM DOCUMENTO " + this.documento);
        //LÓGICA PARA ADICIONAR AO SALDO
        this.saldo = this.saldo.subtract(quantidade);
        return quantidade;
    }

    @Override
    public BigDecimal deposita(BigDecimal quantidade) {
        System.out.println("APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE");
        System.out.println("DEPOSITANDO PARA PESSOA " + this.nome + " COM DOCUMENTO " + this.documento);
        //LÓGICA PARA SUBTRAIR DO SALDO
        this.saldo = this.saldo.add(quantidade);
        return quantidade;
    }
}

As mudanças no código foram:

No construtor foi adicionado uma chamada ao construtor da classe mãe através do super().
Tanto no método saca quanto no deposita foi chamado o atributo saldo para adicionar fundos, no método saca , ou para subtrair fundos, método deposita.

E agora executando esse código:

public class Main {

    public static void main(String[] args) {

        Conta contaFisicaGuilherme = new PessoaFisica("Guilherme");
        Conta contaJuridicaGuilherme = new PessoaJuridica("Empresa do Guilherme");

        Banco banco = new Banco("MeuBano", List.of(contaFisicaGuilherme, contaFisicaGuilherme));

        banco.realizaTransferencia(contaFisicaGuilherme, contaJuridicaGuilherme, new BigDecimal("10"));

        System.out.println(contaFisicaGuilherme);
        System.out.println(contaJuridicaGuilherme);
    }
}

Teremos como saída o seguinte:

Conta{nome='Guilherme', documento='CPF', saldo=990}
Conta{nome='Empresa do Guilherme', documento='CNPJ', saldo=1010}

Uma novidade que passou a existir a partir do Java 8 foi a possibilidade de haver um método implementado em uma Interface , antes só as Classes Abstratas poderiam possuir métodos implementados. Vamos ver isso em ação criando uma Interface para Auditoria :

public interface Auditoria {

    default void audita(){
        System.out.println("REALIZANDO AUDITORIA");
    };
}

A Interface Auditoria possui um método chamado audita e este método já possui uma implementação e indicamos isso através da palavra default seguido do método e de sua implementação, se quisermos implementar essa Interface na classe Banco não será mais obrigatório fornecer uma implementação para esse método:

public class Banco implements Financiamento, Pagamento, Auditoria{
    //TODO RESTO OMITIDO
}

Não foi obrigatório fornecer uma implementação porém se for necessário podemos sobrescrever o método audita:

@Override
public void audita() {
    Auditoria.super.audita();
    System.out.println("AUDITORIA CUSTOMIZADA");
}

Sobrescrevemos o método audita porém é possível manter a implementação padrão através da chamada Auditoria.super.audita() onde o super serve para invocar o método que está na Interface. Se executarmos esse código agora:

Conta contaFisicaGuilherme = new PessoaFisica("Guilherme");
Conta contaJuridicaGuilherme = new PessoaJuridica("Empresa do Guilherme");

Banco banco = new Banco("MeuBano", List.of(contaFisicaGuilherme, contaFisicaGuilherme));
banco.audita();

O resultado será:

REALIZANDO AUDITORIA
AUDITORIA CUSTOMIZADA

O último ponto entre Interfaces e Classes Abstratas é que não podemos adicionar atributos em Interfaces mas conseguimos fazer isso em Classes Abstratas.

Problema Diamante

No último artigo falamos que não existe Herança múltipla no Java pois se houverem dois métodos com a mesma assinatura em classes diferentes qual método seria executado. Porém o mesmo problema pode ocorrer com Interfaces e é permitido implementar múltiplas Interfaces , como esse problema é contornado nesses casos?

Vamos criar duas Interfaces , Log e Logger e as duas irão conter um método chamado log:

public interface Log {

    default void log(){
        System.out.println("REALIZANDO LOG");
    };
}

public interface Logger {

    default void log(){
        System.out.println("REALIZANDO LOGGER");
    };
}

As duas Interfaces possuem a mesma assinatura e as duas possuem métodos já implementados, se adicionarmos essas Interfaces na classe Banco o código irá parar de compilar. Isso ocorre pois o compilador consegue identificar esse problema e irá nos obrigar a fornecer uma implementação para esse método.

public class Banco implements Log, Logger{

    @Override
    public void log() {
        Log.super.log();
        Logger.super.log();
    }

}

No exemplo acabamos por usar as duas implementações porém poderíamos escolher entre uma delas ou até mesmo criar uma implementação customizada na classe Banco.

Para saber mais sobre o Problema Diamante.

Quando usar Interface ou Classe Abstrata?

Não existe uma resposta padrão para essa pergunta porém podemos analisar qual usar de acordo com alguns critérios:

|---------------------------------------|---------------------------------------------------------|
| Interface                             | Classe Abstrata         
|---------------------------------------|---------------------------------------------------------|
| Várias implementações que compartilham| Compartilhar código em classes relacionadas que possuem | 
| a mesma assinatura de método          | um comportamento em comum 
|---------------------------------------|---------------------------------------------------------|
| Adicionar comportamento mesmo sem     | Compartilhar atributos entre classes 
| ter total certeza de como será        | 
| a implementação 
|---------------------------------------|---------------------------------------------------------|
| Fazer uso de múltiplas implementações | Controle de acesso através de modificadores de acessos  |
|---------------------------------------|---------------------------------------------------------|

Utilização de Polimorfismo pela linguagem

A própria linguagem Java faz muito uso de Polimorfismo por padrão, um exemplo disso é a Interface List que possui diversas implementações:

List<String> lista = new ArrayList<>();
lista = new LinkedList<>();
lista = new Vector<>();
lista = new Stack<>();

Podemos ver que a variável lista pode carregar várias implementações pois todas essas classes implementam direta ou indiretamente a Interface List.

Conclusão

Neste artigo exploramos Interfaces e como podemos fazer uso delas para criar código Polimórficos.

O código deste artigo se encontra no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java VII - Herança e Abstração

guilhermegarcia86 — Tue, 09 Nov 2021 00:00:01 +0000

No último artigo iniciamos o assunto sobre Herança e neste artigo será concluído o tema e apresentado o assunto de abstração. Você verá formas de usar esses conceitos para construção de códigos mais consistentes e legíveis.

No projeto que foi apresentado existe a seguinte situação, em um sistema bancário podemos ter dois tipos de conta, a conta para pessoa física e a conta para pessoa jurídica, para isso foi criado uma classe chamada Conta que serve de molde para as classes PessoaFisica e PessoaJuridica e fazendo uso de Herança isso é possível, porém no decorrer percebemos que era possível criar uma instância da classe Conta e para a regra dessa aplicação isso não deveria ser possível, mas como podemos fazer uso de Herança sem que aja uma breja que pode ser usada de forma equivocada? Iremos ver nesse artigo como podemos fazer uso de Abstração para suprir isso.

Classes Abstratas

No nosso exemplo de código seria muito útil se houvesse uma forma de ter uma estrutura de dados que guardasse os atributos e métodos em comum de uma Conta mas que não pudesse ser instanciada e que permitisse o uso de Herança. Essa estrutura existe e é chamada de Classe Abstrata , vamos ver como criar e depois entenderemos melhor os seus benefícios:

public abstract class Conta {

    private String nome;
    private String documento;

    public BigDecimal deposita(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO GENERALISTA");
        return BigDecimal.ZERO;
    }

    public BigDecimal saca(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO GENERALISTA");
        return BigDecimal.ZERO;
    }

    //Todo o resto omitido
}

Reaproveitamos a classe Conta e adicionamos o modificador de acesso abstract , isso já serve em partes pois se tentarmos instanciar uma classe Conta não será mais possível:

Conta conta = new Conta();

Isso gera erro de compilação:

'Conta' is abstract; cannot be instantiated

Agora vamos entender um pouco mais o que é uma Classe Abstrata. Uma Classe Abstrata é uma classe que não pode ser instanciada somente herdada, ela também tem a capacidade de definir métodos sem implementação, chamado de métodos abstratos que são métodos que contém somente a assinatura e que a classe que herdar da Classe Abstrata deve se preocupar com a sua implementação, porém também é possível ter métodos implementados em uma Classe Abstrata e através de sobrescrita de métodos customizá-los nas classes que herdarem a Classe Abstrata.

*OBS: Porém qual estratégia é melhor usar? Deixar métodos implementados nas classes abstratas que podem ser sobrescritos ou deixá-los para serem implementados nas classes filhas? Essa pergunta não é tão simples de responder e cabe a você como desenvolvedor pensar no que faz sentido para cada caso.

Para deixar mais claro vamos ver como ficou o código na classe Conta :

public abstract class Conta {

    protected String nome;
    protected String documento;

    public abstract BigDecimal deposita(BigDecimal quantidade);

    public BigDecimal saca(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO GENERALISTA");
        return BigDecimal.ZERO;
    }

    //Restante omitido
}

Tem alguns pontos significativos que foram alterados porém agora vamos focar na alteração do método deposita onde foi adicionado o modificador abstract e removido a implementação do método. Isso significa que esse método deve ter obrigatoriamente uma implementação válida na classe que herdar da classe Conta , essa é uma forma de garantirmos que iremos ter um método customizado sendo implementado na classe que for filha da classe Conta , se tentarmos herdar uma Classe Abstrata com um método abstrato e não implementarmos nada para esse método iremos receber um erro de compilação.

Outro ponto que vimos no código acima é a utilização de atributos com o modificador protected , poderíamos ter atributos private ou até mesmo public em uma Classe Abstrata porém como o conceito de uma Classe Abstrata é ser um “molde” que não pode ser instanciado somente herdado faz muito sentido ser usado o modificador protected pois ele irá garantir que esses campos só poderão ser usados em sub-classes por meio de Herança.

*OBS: Até o Java 7 esse era o único modo de termos métodos concretos e métodos não implementados em um unico arquivo, porém a partir do Java 8 é possível termos métodos implementados em Interfaces porém esse assunto ainda será abordado mais a frente.

Então usando essa ideia podemos fazer da seguinte maneira nas sub-classes de Conta :

public class PessoaFisica extends Conta{
    public static final String TIPO_DE_DOCUMENTO = "CPF";

    public PessoaFisica(String nome){
        this.documento = TIPO_DE_DOCUMENTO;
        this.nome = nome;
    }

    @Override
    public BigDecimal saca(BigDecimal quantidade) {
        System.out.println("APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE");
        System.out.println("SAQUE PARA PESSOA " + this.nome + " COM DOCUMENTO " + this.documento);
        return quantidade;
    }

    @Override
    public BigDecimal deposita(BigDecimal quantidade) {
        System.out.println("APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE");
        System.out.println("DEPOSITANDO PARA PESSOA " + this.nome + " COM DOCUMENTO " + this.documento);
        return quantidade;
    }
}

Explicando as alterações que foram feitas acima:

Foi criado um construtor para receber o nome do titular da conta e atribuído ao atributo nome que está na super-classe Conta.
O método saca está sobrescrito na classe PessoaFisica porém como existe uma implementação na super-classe Conta não seria necessário existir aqui, mas podemos fazer uso desse recurso de sobrescrita para customizações.
O método deposita necessita obrigatoriamente de uma implementação na sub-classe pois foi definido como um método abstrato na super-classe.

Agora executando esse código:

Conta conta = new PessoaFisica("Guilherme");
conta.saca(BigDecimal.ZERO);

Antes de ver o resultado desse código reflita um pouco sobre o que deveria acontecer nesse caso? Nós criamos uma instância de PessoaFisica porém atribuímos para uma variável do tipo Conta e depois chamamos o método saca ; tanto a classe Conta quanto a classe PessoaFisica possuem implementações desse método, qual será executado então?

Analisando o resultado:

APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE
SAQUE PARA PESSOA Guilherme COM DOCUMENTO CPF

Ele executou o que havia dentro da classe PessoaFisica pois por mais que tenhamos atribuído a uma variável do tipo Conta a instância é do tipo PessoaFisica mas por qual razão foi possível atribuir uma instancia de PessoaFisica em uma variavel do tipo Conta?

Isso acontece graças ao Polimorfismo porém esse assunto será visto no próximo artigo, por enquanto entenda que é possível atribuir uma sub-classe para uma variável do tipo da super-classe.

Conclusão

Nessa segunda parte do artigo de Herança entendemos um pouco mais sobre como podemos fazer uso de Abstração com Classes Abstratas para poder criar “moldes” de classes que não podem ser criadas sozinhas e que dependem de sub-classes herdadas para serem usadas. No próximo artigo iremos iniciar o assunto de Polimorfismo e Interfaces.

O código deste artigo se encontra no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java VI - POO Herança parte 1

guilhermegarcia86 — Tue, 26 Oct 2021 00:00:01 +0000

Neste artigo iremos abordar a Herança no Java , sendo esse um dos pilares para a Programação Orientada a Objetos. Iremos ver como se comportam relacionamentos de herança, o que é e para que serve a Sobrescrita de métodos. Por se tratar de um assunto mais extenso primeiramente será abordado os conceitos sobre herança e sobrescrita de métodos e posteriormente iremos nos aprofundar em conceitos como Abstração e entrar em Polimorfismo.

Quando se pesquisa sobre esses temas em alguns tutoriais na internet não é incomum encontrar exemplos explicando Herança com classes como Animal e sub-classes como Humano e Cachorro. Entendo que possa ser didático para quem nunca viu esse assunto antes porém nesse artigo tentaremos ir um pouco além e mostrar exemplos um pouco mais próximos da realidade que uma pessoa desenvolvedora irá encontrar no seu dia-a-dia.

Introdução

Herança é um mecanismo que permite ao desenvolvedor aplicar abstrações no código criando uma classe-mãe que possuem atributos ou métodos que podem ser reutilizados por sub-classes que fazem sentido terem aqueles comportamentos e até mesmo permitindo customizações nessas sub-classes.

Para ficar mais claro vamos pensar que trabalhamos em um banco e que nele existe somente dois tipos de conta, uma para pessoas físicas e outra para pessoas jurídicas, podemos criar duas classes nesse caso:

public class ContaPessoaFisica {

    private String nome;
    private String documento;

    public BigDecimal deposita(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO ESPECÍFICO PARA CONTA FISICA");
        return BigDecimal.ZERO;
    }

    public BigDecimal saca(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO ESPECÍFICO PARA CONTA FISICA");
        return BigDecimal.ZERO;
    }
}

public class ContaPessoaJuridica {

    private String nome;
    private String documento;

    public BigDecimal deposita(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO ESPECÍFICO PARA CONTA JURIDICA");
        return BigDecimal.ZERO;
    }

    public BigDecimal saca(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO ESPECÍFICO PARA CONTA JURIDICA");
        return BigDecimal.ZERO;
    }
}

Podemos perceber que essas duas classes são identicas até o momento, com exceção da lógica que cada uma iria realizar. Mas será que é saudável para um projeto de software ter que lidar com duplicações desse jeito? Imaginando um projeto maior isso logo cresce de uma maneira descontrolada o que vai deixar imprevisível o comportamento do sistema em casos de mudanças pois provavelmente se em algum momento for necessário aplicar uma mesma regra de negócio para contas físicas ou juridicas pode ocorrer desse comportamento não se propagar da forma que foi planejada ou mesmo se for criada outra modalidade de conta nesse projeto será necessário duplicar tudo novamente.

Pensando em resolver essas complicações a Herança foi adotada na linguagem Java onde podemos ter a classe-mãe, nesse caso Conta e suas filhas PessoaFisica e PessoaJuridica :

public class Conta {

    private String nome;
    private String documento;

    public BigDecimal deposita(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO GENERALISTA");
        return BigDecimal.ZERO;
    }

    public BigDecimal saca(BigDecimal quantidade){
        System.out.println("EXECUTA REGRA DE NEGÓCIO GENERALISTA");
        return BigDecimal.ZERO;
    }

}

public class PessoaFisica extends Conta{

    public static final String TIPO_DE_DOCUMENTO = "CPF";
}

public class PessoaJuridica extends Conta{

    public static final String TIPO_DE_DOCUMENTO = "CNPJ";
}

Podemos ver que a classe Conta funciona com a responsabilidade de guardar dados e comportamentos que serão comuns entre as contas físicas e juridicas e por sua vez as classes-filhas guardam atributos e métodos que são específicos para elas. Outro ponto importante é que foi usado a palavra reservada extends , essa palavra é o que irá indicar que está sendo feito um relacionamento do tipo Herança , onde após a palavra extends adicionamos a classe que está sendo herdada. Tem alguns pontos de melhoria em toda essa abordagem e até o fim do artigo iremos explorá-los.

Agora podemos usar tanto uma conta fisica quanto uma jurídica:

public class Main {

    public static void main(String[] args) {

        PessoaFisica contaPessoaFisica = new PessoaFisica();
        contaPessoaFisica.deposita(BigDecimal.valueOf(10));

        PessoaJuridica contaPessoaJuridica = new PessoaJuridica();
        contaPessoaJuridica.saca(BigDecimal.valueOf(10));
    }
}

Mas o que irá acontecer se quiséssemos criar uma instância de Conta? Será que nesse modelo ter uma conta que não é nem física e nem jurídica faz sentido?

Conta conta = new Conta();
conta.deposita(BigDecimal.valueOf(10));

Só não é possível como também é possível depositar e sacar de uma classe que idealmente existe como um molde para outros tipos de conta, porém iremos ver como solucionar esse problema; outro problema que pode ter ficado menos evidente é que agora a regra de negócio para contas físicas e jurídicas é a mesma e não era essa a intenção, precisamos de um jeito melhor de lidar com essas situações e o Java fornece as ferramentas para isso.

Object

Antes mesmo de continuar é bom ter em mente que na linguagem Java tudo, com exceção dos tipos primitivos, tem relação com a classe Object. Então concluímos que tudo no Java herda de Object. Isso significa que no nosso exemplo a classe Conta herda de Object mas como pode isso se a classe Conta não tem uma declaração extends?

Isso acontece pois a própria linguagem se encarrega disso e nos artigos anteriores já havíamos utilizado métodos da classe Object sem perceber, quando usamos métodos como toString, equals ou hashCode estamos fazendo uso de métodos da classe Object :

public class Conta {

    //RESTANTE DO CÓDIGO OMITIDO

    @Override
    public String toString() {
        return "Conta{" +
                "nome='" + nome + '\'' +
                ", documento='" + documento + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Conta conta = (Conta) o;
        return Objects.equals(nome, conta.nome) && Objects.equals(documento, conta.documento);
    }

    @Override
    public int hashCode() {
        return Objects.hash(nome, documento);
    }
}

Essa foi uma decisão de projeto dos criadores da linguagem, pois eles entenderam que esses métodos são comuns a todas as classes, o método toString retorna uma String para que nós pessoas possamos entender a representação daquela instância de objeto, o equals e o hashCode são muito importantes quando trabalhamos com coleções de dados e iremos ver a importância deles futuramente.

Uma dúvida que pode ter ficado após ver o código acima, como o toString da classe Conta sabe que precisa ser formatado dessa forma ou como os métodos equals e hashCode sabem que precisam dos atributos nome e documento e o que é esse @override escrito acima dos métodos? A resposta mais curta é que esses métodos não sabem e cabe a você dizer isso a eles.

O @override é uma Annotation do Java , não vamos entrar em detalhes agora mas basta entender que Annotations como essa indicam alguma coisa no código, nesse caso ela indica que esse método foi sobrescrito, criando assim um marcador sobre esse método, as Annotations também lidam com outras questões que serão abordadas mais pra frente.

Sobrescrita

Voltando ao problema do nosso projeto, agora a regra de negócio está compartilhada entre as contas e não é isso que queríamos. Como podemos manter a classe Conta com o que queremos mas sem propagar comportamentos que queremos que sejam próprios das classes filhas? Usando sobrescrita de métodos isso é possível, mas o que é sobrescrita de métodos?

Voltando ao exemplo do método toString da classe Object :

public String toString(){
    return getClass().getName() + '@' + Integer.toHexString(hashCode());
}

Na classe Object essa é a declaração do método toString, o nome da classe seguido do hexadecimal da classe indicando o endereço de memória do objeto que chamou o método, agora imagine se em todo objeto que chamássemos o toString fosse essa informação que fosse devolvida, será que seria útil para nós saber onde na memória o objeto está alocado? Pensando nisso existe a sobrescrita de métodos que permite customizações específicas para métodos que são herdados, logo com isso foi possível customizar o toString da classe Conta para que ele devolvesse uma String que seres humanos consigam ler e entender o seu significado.

E como as classes PessoaFisica e PessoaJuridica herdam de Conta é possível customizar os métodos para a realidade de negócio delas, primeiramente mostrando a classe PessoaJuridica :

public class PessoaJuridica extends Conta{

    public static final String TIPO_DE_DOCUMENTO = "CNPJ";

    @Override
    public BigDecimal saca(BigDecimal quantidade) {
        System.out.println("VALIDANDO...");
        if(quantidade.compareTo(BigDecimal.ZERO) <= 0){
            System.out.println("VALIDAÇÃO RETORNA ERRO");
            throw new IllegalArgumentException("VALOR DEVE SER MAIOR DO QUE ZERO");
        }
        return super.saca(quantidade);
    }

    @Override
    public BigDecimal deposita(BigDecimal quantidade) {
        System.out.println("VALIDANDO...");
        if(quantidade.compareTo(BigDecimal.ZERO) <= 0){
            System.out.println("VALIDAÇÃO RETORNA ERRO");
            throw new IllegalArgumentException("VALOR DEVE SER MAIOR DO QUE ZERO");
        }
        return super.deposita(quantidade);
    }
}

Na classe PessoaJuridica sobrescrevemos os métodos saca e deposita e com isso ganhamos mais flexibilidade pois agora podemos executar uma validação, que poderia estar na super classe Conta mas para fins didáticos vou deixar aqui para ficar claro que podemos executar regras diferentes em métodos sobrescritos, perceba também que apesar dos métodos estarem sobrescritos no final de cada um deles é feito uma chamada super.saca(quantidade) e super.deposita(quantidade) esse exemplo foi deixado aí para que você entenda que é possível executar um método na sub-classe e delegar para a super classe o restante da execução, basta usar o operador super que delega para a super classe a chamada do método. Contudo podemos querer, por vários motivos, que a execução do método sobrescrito fique contido somente na classe específica e para isso podemos fazer do jeito como foi feito na classe PessoaFisica :

public class PessoaFisica extends Conta{

    public static final String TIPO_DE_DOCUMENTO = "CPF";

    @Override
    public BigDecimal saca(BigDecimal quantidade) {
        System.out.println("APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE");
        return quantidade;
    }

    @Override
    public BigDecimal deposita(BigDecimal quantidade) {
        System.out.println("APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE");
        return quantidade;
    }
}

Bastou retirar o operador super para que o método fosse isolado dentro da classe, agora executando o código:

PessoaFisica contaPessoaFisica = new PessoaFisica();
contaPessoaFisica.deposita(BigDecimal.valueOf(10));

PessoaJuridica contaPessoaJuridica = new PessoaJuridica();
contaPessoaJuridica.saca(BigDecimal.valueOf(10));

Teremos a seguinte saída:

APLICANDO REGRA MUITO ESPECÍFICA SEM CHAMAR A SUPER CLASSE
VALIDANDO...
EXECUTA REGRA DE NEGÓCIO GENERALISTA

Agora resolvemos o problema de ter regras distribuídas para classes que não fazem sentido ter aquela regra, porém ainda temos o problema de poder criar uma classe Conta e iremos ver agora como solucionar isso com Classes Abstratas no próximo artigo.

Limitações

A Herança é uma grande ferramenta que auxilia o desenvolvimento de sistemas porém existem algumas limitações e a mais importante no que tange a linguagem Java é que só podemos fazer herança de uma única classe pois no Java não existe herança múltipla. Por exemplo vamos supor que no futuro exista um tipo bem especial de Conta onde ela é ao mesmo tempo uma conta de pessoa física e uma conta de pessoa jurídica, eu sei que pode ser estranho isso mas estamos só supondo para explicar o conceito. Agora imagine que você como pessoa desenvolvedora queira utilizar de Herança para resolver esse problema e pensou que poderia criar um classe ContaHibrida que herde de PessoaFisica e de PessoaJuridica ao mesmo tempo e resolveu fazer isso:

public class ContaHibrida extends ContaPessoaFisica, ContaPessoaJuridica{
}

Nesse momento o compilador irá reclamar e exibir uma mensagem parecida com isso:

Class cannot extend multiple classes

Agora vamos ir um passo além na nossa imaginação e pensar que isso não gerasse erro e deu tudo certo na sua classe ContaHibrida e você tentou usá-la assim:

ContaHibrida contaHibrida = new ContaHibrida();
contaHibrida.saca(BigDecimal.valueOf(10));

Qual método saca será executado? O da PessoaFisica ou o da PessoaJuridica? Esse problema é chamado de problema diamante onde teríamos duas classes com o mesmo método, com a mesma assinatura, parâmetros e com uma sub-classe tentando executá-lo, o compilador não tem condições de saber qual executar e por conta disso a herança múltipla não foi adotada na linguagem Java.

Conclusão

Essa é a primeira parte que falamos sobre Herança , nesse artigo foi mostrado o que é Herança no Java e qual tipo de problema ela resolve. Também entendemos mais como a sobrescrita de métodos nos auxilia com classes que herdam métodos que precisam ser customizados. Foi mostrado também uma limitação da Herança no Java que é a questão de heranças múltiplas. No próximo artigo iremos adentrar um pouco mais no conceito É-UM da Herança e serão apresentados as Classes Abstratas.

O código deste artigo se encontra no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java V - Sobrecarga, Wrappers e Autoboxing

guilhermegarcia86 — Wed, 13 Oct 2021 00:00:01 +0000

Para este artigo será mostrado como podemos ter maior flexibilidade através da Sobrecarga de métodos. Também será apresentado as Classes Wrappers e o Autoboxing do Java.

Sobrecarga

A sobrecarga de métodos permite a pessoa que estiver desenvolvendo ter maior flexibilidade sobre um determinado método, onde pode haver vários métodos com o mesmo nome porém com parâmetros diferentes, para exemplificar vamos imaginar que você está desenvolvendo um jogo onde o personagem pode correr com algum veículo ou a pé, para esse caso pode haver várias abordagens mas para explicar sobrecarga de métodos iremos criar classes para cada tipo de veículo, então teremos as classes Carro , Moto e Bicicleta e também iremos criar a classe Personagem que irá conter a ação de acelerar:

public class Carro {

    private String nome;

    public Carro(String nome) {
        this.nome = nome;
    }    

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }
}

Esse é o exemplo da classe Carro , onde ela só possui o atributo nome, o construtor recebendo o nome e os métodos getter/setters, as outras classes Moto e Bicicleta seguem o mesmo padrão, e agora vamos ver a classe Personagem :

public class Personagem {

    private String nome;

    public Personagem(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }
}

A classe Personagem possui, por enquanto, apenas o atributo nome e agora vamos implementar o método acelera que irá retornar uma String com a informação que o Personagem está acelerando:

public String acelera(){
    return "Acelerando";
}

O método acelera informa que o Personagem está acelerando mas não diz se é a pé ou com algum veículo. Poderíamos fazer da seguinte maneira:

public String aceleraDeBicicleta(){
    return "Acelerando com bicicleta";
}

public String aceleraComMoto(){
    return "Acelerando com moto";
}

public String aceleraComCarro(){
    return "Acelerando com carro";
}

public String acelera(){
    return "Acelerando a pé";
}

Mas com a sobrecarga podemos criar métodos mais específicos mantendo o mesmo nome, contanto que o parâmetro de entrada seja diferente no método, então podemos fazer da seguinte maneira:

public String acelera(Bicicleta bicicleta){
    return "Acelerando com a bicicleta: " + bicicleta.getNome();
}

public String acelera(Moto moto){
    return "Acelerando com a moto: " + moto.getNome();
}

public String acelera(Carro carro){
    return "Acelerando com o carro: " + carro.getNome();
}

public String acelera(){
    return "Acelerando a pé";
}

Foram criados mais três métodos com o mesmo nome porém com entradas diferentes, cada um recebendo um tipo diferente de veículo e o primeiro método foi melhorado para retornar um texto mais compreensível. Você pode ter notado que para a sobrecarga ocorrer não foi necessário alterar o tipo do retorno mas isso também pode ser feito porém para que isso funcione não pode haver ambiguidade para o compilador, pois pense o que iria acontecer se criássemos um método que recebe os mesmos parâmetros mas tem um retorno diferente?

public String acelera(){
    return "Acelerando a pé";
}

public int acelera(){
    return 1;
}

Aqui temos dois métodos acelera porém com retornos diferentes e se fossemos usar personagem.acelera(); qual dos dois deveria ser executado? O compilador não tem como identificar isso e por isso esse código não compila. Agora se alterarmos:

public String acelera(){
    return "Acelerando a pé";
}

public int acelera(int kmH){
    return kmH;
}

Pensando em um método acelera que recebe a quantidade quilometros por hora que deve ser acelerado; esse código compila pois o compilador já sabe diferenciar pelo parâmetro o que cada método recebe.

Agora exemplificando como usar o código que foi criado:

public static void main(String[] args) {

    Carro ferrari = new Carro("Ferrari");

    Moto harley = new Moto("Harley");

    Bicicleta caloi = new Bicicleta("Caloi");

    Personagem heroi = new Personagem("Heroi");

    System.out.println(heroi.acelera());
    System.out.println(heroi.acelera(10));
    System.out.println(heroi.acelera(harley));
    System.out.println(heroi.acelera(ferrari));
    System.out.println(heroi.acelera(caloi));
}

E a saída será:

Acelerando a pé
10
Acelerando com o moto: Harley
Acelerando com o carro: Ferrari
Acelerando com o bicicleta: Caloi

Classe Wrapper

As classes Wrappers são classes que foram criadas na linguagem Java para representar um tipo primitivo, elas são classes empacotadoras desses tipos primitivos. Quando em um programa usamos um tipo primitivo, por exemplo um int por padrão ele recebe um valor padrão caso nenhum valor seja passado diretamente para ele, no caso de int o valor é 0. Isso é um detalhe do Java , quer seja tipo primitivo ou não tudo recebe um valor padrão, nos casos de classes o valor padrão é null , que significa ausência de valor.

No exemplo abaixo será mostrado a diferença entre o tipo primitivo int e a classe Integer que empacota o tipo int :

public class Wrapper {
    private int numero;
    private Integer numeroWrapper;

    public static void main(String[] args) {
        Wrapper wrapper = new Wrapper();

        System.out.println(wrapper.getNumero());
        System.out.println(wrapper.getNumeroWrapper());
    }
}

Executando esse código teremos a seguinte saída:

0
null

Preste atenção que ao executar o programa é exibido o valor 0 para a variável com nome numero que é um tipo primitivo int e para a variável numeroWrapper o valor exibido é null significando que não existe um valor definido para essa variável.

Pensando nisso foram criadas as classes Wrappers que representam os tipos primitivos, com isso é possível ter uma classe que representa um valor primitivo, como ocorre com int , porém sem ter um valor padrão definido a ele. Fora que por ser uma classe existem vários métodos que podem ser utilizados e que auxiliam a pessoa que estiver desenvolvendo porém não são muito usados no dia-a-dia a vantagem que particularmente eu vejo é a capacidade que uma classe Wrapper tem de não possuir um valor o que também pode ser perigoso pois se tentarmos usar um atributo que for null será lançado uma Exception do tipo NullPointerException então lembre-se de sempre atribuir um valor quando estiver usando uma classe Wrapper.

Autoboxing

Classes Wrappers possuem alguns métodos, como foi citado anteriormente, entre esses métodos existe o valueOf que faz conversão de um valor primitivo para a uma classe Wrapper :

Boolean booleanWrapper = Boolean.valueOf(true);

E o oposto também pode ocorrer com o método booleanValue, no caso da classe Wrapper Boolean mas para cada Wrapper existe o seu método equivalente para conversão de um objeto para o seu tipo primitivo correspondente:

booleanWrapper.booleanValue();

Porém no Java existe o que é chamado Autoboxing e Unboxing que é a capacidade da própria linguagem realizar essas conversões para nós:

boolean falso = Boolean.FALSE;

Boolean verdadeiro = true;

Conclusão

Nesse artigo entendemos um pouco melhor a Sobrescrita de métodos e como ela pode fornecer maior flexibilidade na hora do desenvolvimento, também vimos as Classes Wrappers e o recurso de Autoboxing e Unboxing da linguagem Java.

O código deste artigo se encontra no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java IV - POO Classes e Encapsulamento

guilhermegarcia86 — Mon, 04 Oct 2021 00:00:01 +0000

Nesse artigo chegamos a Orientação a Objetos , no últimos artigos foi mostrado a parte básica da linguagem e de sua sintaxe e agora será mostrado Classes , que sem isso não haveria Orientação a Objetos no Java , também será mostrado Encapsulamento e como ele é importante na linguagem.

Orientação a Objetos

Antes de iniciarmos qualquer explicação sobre Classes é necessário entender o que é Orientação a Objetos e como esse paradigma é tratado no Java. Antes de existir a Orientação a Objetos o paradigma que dominava o mercado era o paradigma procedural, e resumidamente esse paradigma é sobre escrever métodos ou procedimentos que deveriam ser executados no código enquanto que Orientação a Objetos consiste em criação de Objetos que contém tanto métodos quanto atributos , que são dados referentes aquele Objeto.

O paradigma orientado a objetos trás consigo quatro fundamentos básicos que o torna diferente do paradigma procedural:

Abstração
Encapsulamento
Herança
Polimorfismo

Iremos tratar de cada um desses temas nos próximos artigos.

Classe

Para entender um Objeto é mais fácil explicar o que é uma Classe já que a classe seria o “molde” para um objeto. Para entender melhor vamos pensar em um sistema de Recursos Humanos onde temos o cadastro de Funcionários :

public class Funcionario {

    private String nome;
    private String sobrenome;
    private int idade;
    private String endereco;
    private String departamento;

}

Daqui a pouco será explicado o que são as palavras public e private mas por enquanto iremos focar na declaração da classe e seus atributos. No código acima foi criada a classe Funcionário e não um objeto Funcionario mas o que isso significa? Significa que foi criado um “molde” ou um “esqueleto” do que é um funcionário para o nosso código, foi definido que todo Funcionário possui um nome e sobrenome , uma idade , um endereço e um departamento mas ainda não foi criado nenhum funcionário no sistema.

Antes de ver como criar um objeto do tipo Funcionário veremos a sintaxe de uma classe:

class NomeDaClasse {

}

Essa é sintaxe mais básica para existir uma classe, é necessária a palavra reservada class , no nome seguimos o padrão camel case seguido de chaves {}.

Os dados da classe Funcionário são chamados de atributos e possuem e sintaxe básica assim:

String nome;
String sobrenome;
int idade;
String endereco;
String departamento;

É necessário informar qual é o tipo que representa esse atributo no Java então temos o primeiro atributo (nome) do tipo String (texto), idade do tipo int , numérico e etc. A palavra reservada private não é obrigatória porém será entendida mais adiante nesse artigo quando for explicado sobre Encapsulamento.

Para criar um Objeto no Java é usado a palavra reservada new , que irá criar um Objeto na memória e será possível manipular dados desse objeto:

Funcionario funcionario = new Funcionario();

Pronto, só com isso já temos em mãos um objeto do tipo Funcionario , também é possível fazer dessa forma:

var funcionario = new Funcionario();

Como foi dito em artigos anteriores o Java agora é capaz de realizar inferência de tipos, que é capacidade de “saber” qual é o tipo de uma variável mesmo sem declarar explicitamente o seu tipo, como no caso do código acima onde foi criado um objeto do tipo Funcionário e passado para a variável var funcionario sem dizer qual é o seu tipo, o compilador consegue entender que aquela variável é do tipo Funcionario.

Um ponto importante é que foi necessário colocar parenteses () após a palavra new , isso acontece pois Funcionario() é um método. Um método especial do Java que se chama Construtor e ele é responsável pela inicialização dos objetos , por padrão toda classe no Java possui um método construtor sem argumentos então seria como se a classe Funcionario fosse assim:

public class Funcionario {

    public Funcionario(){}

    private String nome;
    private String sobrenome;
    private int idade;
    private String endereco;
    private String departamento;

}

O método construtor é um método que tem o mesmo nome da classe e não possui um retorno em sua assinatura e com ele conseguimos criar os objetos.

Agora já sabemos como criar objetos, mas o objeto Funcionario possui atributos que não foram preenchidos, como nome, idade, endereço e departamento. Para lidar com isso é possível criar um método construtor onde passamos esses atributos:

public class Funcionario {

    public Funcionario(String nome, String sobrenome, int idade, String endereco, String departamento) {
        this.nome = nome;
        this.sobrenome = sobrenome;
        this.idade = idade;
        this.endereco = endereco;
        this.departamento = departamento;
    }

    private String nome;
    private String sobrenome;
    private int idade;
    private String endereco;
    private String departamento;

}

Modificamos o método construtor de Funcionario e agora ele recebe todos os dados, porém agora se tentarmos rodar o código como estava antes ele não irá compilar:

Funcionario funcionario = new Funcionario();

'Funcionario(java.lang.String, java.lang.String, int, java.lang.String, java.lang.String)' in 'br.com.company.artigoiv.Funcionario' cannot be applied to '()'

Isso ocorre pois quando explicitamente escrevemos um método construtor o método construtor padrão deixa de existir se por acaso quiséssemos ter os dois construtores, nós podemos mas é necessário escrever isso no código:

public class Funcionario {

    public Funcionario(String nome, String sobrenome, int idade, String endereco, String departamento) {
        this.nome = nome;
        this.sobrenome = sobrenome;
        this.idade = idade;
        this.endereco = endereco;
        this.departamento = departamento;
    }

    public Funcionario() {}
}

Inclusive podemos ter quantos métodos construtores forem necessários porém não é uma boa prática ter muitos métodos construtores, em casos que seja necessário existem outras abordagens e padrões como o Builder.

Outro ponto que é bom mostrar é que dentro do construtor criado foi usado a palavra this. Entender isso é de grande importância pois o this no Java faz referência a própria classe, é ela se auto referenciando e aqui no construtor isso é importante pois as variáveis que são passadas nos argumentos do construtor possuem o mesmo nome das atributos e para saber em qual variável será guardado o valor o this nos auxilia:

private String nome;
private String sobrenome;
private int idade;
private String endereco;
private String departamento;

public Funcionario(String nome, String sobrenome, int idade, String endereco, String departamento) {
    this.nome = nome;
    this.sobrenome = sobrenome;
    this.idade = idade;
    this.endereco = endereco;
    this.departamento = departamento;
}

O this.nome dentro do construtor significa que ela se refere a variável nome da classe Funcionario e não a variável nome do método construtor, se por acaso você retirar o this a variável nome da classe Funcionario não receberá valor e na verdade você estará reatribuindo o valor da variável nome do método construtor para ela mesma. Então conseguimos ver o significado do this dentro de uma classe, sempre que houver this dentro de uma classe significa que está ocorrendo uma referência para ela mesma.

Uma classe também pode ter métodos, o que faz muito sentido pois uma classe que somente tenha atributos não teria conseguiria executar muita coisa dentro do seu código ela serviria como uma objeto de transporte de dados talvez, existe um padrão chamado DTO onde as classes executam esse papel de transporte de dados mas podemos fazer mais com as classes quando adicionamos métodos a elas. Na classe Funcionario podemos adicionar um método para exibir o nome completo de um funcionário:

public String nomeCompleto(){
    return this.nome + " " + this.sobrenome;
}

O método nomeCompleto retorna uma String que é a junção, usamos o termo concatenação nesses casos, do valor da variável nome , uma String vazia para fazer o espaço e o valor da variável sobrenome , se executarmos o programa teremos o resultado:

public static void main(String[] args) {
    Funcionario funcionario = new Funcionario("Guilherme", "Alves", 35, "São Paulo", "Desenvolvimento");
    System.out.println(funcionario.nomeCompleto());
}

Resultado:

Guilherme Alves

Então no código acima foi criado um objeto do tipo Funcionario , usando o método construtor para adicionar valores a ele, atribuído esse objeto para a variável funcionario e executado o método nomeCompleto. Dois pontos são importantes de serem analisados no código acima, o primeiro é que para executarmos um método de uma classe ou até mesmo para acessar os atributos de uma classe usamos o . (ponto) que nesse caso serve como operador de acesso aos elementos de uma classe, então nesse caso foi usado o operador . (ponto) para acessar e executar o método nomeCompleto e o segundo ponto que talvez não possa ter ficado claro é que quando criamos um objeto no Java estamos criando algo que é único, por mais que eu possa criar vários objetos do tipo Funcionario com os mesmos valores eles serão objetos diferentes para o Java pois serão criados e alocados em diferentes espaços de memória, para ficar claro vamos criar dois objetos com os mesmos dados e fazer uma comparação entre eles:

public static void main(String[] args) {
    Funcionario funcionario = new Funcionario("Guilherme", "Alves", 35, "São Paulo", "Desenvolvimento");
    Funcionario funcionarioII = new Funcionario("Guilherme", "Alves", 35, "São Paulo", "Desenvolvimento");
    System.out.println(funcionario.equals(funcionarioII));
    System.out.println(funcionario.toString());
    System.out.println(funcionarioII.toString());
}

Criamos dois objetos do tipo Funcionario e usamos o método equals , logo falaremos sobre ele, para saber se os objetos são iguais, logo após foi executado o método toString , também falaremos sobre ele, para imprimir na tela o valor textual desses objetos, o resultado foi:

false
br.com.company.artigoiv.Funcionario@27f674d
br.com.company.artigoiv.Funcionario@1d251891

O resultado foi false para a verificação de igualdade entre os objetos; o resultado irá variar em cada computador pois o método toString do jeito que está agora exibe o nome da classe completo mais o valor hexadecimal que representa o endereço de memória onde está o objeto e podemos entender que apesar de terem os mesmos valores esses objetos estão em endereços de memória diferentes.

Aproveitando o assunto de classes, no artigo anterior foi comentado sobre o modificador static e que ao usá-lo o atributo ou método passa a pertencer a classe e não mais uma instância, vamos entender um pouco melhor o que isso significa.

Vamos imaginar que todo funcionário possua um CPF , é só um exemplo hipotético para explicar o conceito de static , então como todo funcionário possui esse atributo poderíamos deixar esse tipo de documento como sendo uma constante:

public static final String TIPO_DOCUMENTO = "CPF";

E podemos usar essa constante em qualquer lugar sem ter a necessidade de ter uma instância de Funcionario para funcionar:

public static void main(String[] args) {

    System.out.println("O tipo de documento de todo funcionario é o " + Funcionario.TIPO_DOCUMENTO);

}

Bastando importar essa constante diretamente a partir da classe Funcionario e o mesmo é válido para métodos que também podem ser estáticos, em casos onde algum comportamento independa de um objeto criado, para esse exemplo vamos criar um método estático dessa mensagem que imprimimos na tela:

public class Funcionario {

    public static final String TIPO_DOCUMENTO = "CPF";

    public static String imprimeTipoDeDocumentoDosFuncionarios(){
        return "O tipo de documento de todo funcionario é o " + Funcionario.TIPO_DOCUMENTO;
    }
}

E para usar:

public static void main(String[] args) {

    Funcionario.imprimeTipoDeDocumentoDosFuncionarios();

}

Da mesma forma como foi feito com a constante, não é necessário existir uma instância de Funcionario para esse método funcionar.

Encapsulamento

Após essa introdução às classes, construtores e atributos já é possível entender que uma classe é um container que guarda atributos (dados) sobre um determinado assunto, no nosso exemplo dados de um Funcionário e métodos (ações) que podemos executar a partir de uma instância de um objeto.

No exemplo anterior foi criado um objeto Funcionario usando o construtor e passando todos os dados de um funcionário, porém nem sempre isso está disponível, pense em um empresa onde na contratação de um funcionário ele pode enviar depois alguns documentos como o comprovante de endereço por exemplo e nesse caso o que poderíamos fazer?

Podemos criar mais um construtor sem o atributo endereço por exemplo, mas já temos dois construtores criados e o nosso código pode ficar poluído. Existia um padrão que era chamado de Construtor Telescópio que consistia em criar vários construtores começando desde o construtor sem argumentos e aumentando até o construtor com todos os argumentos, no nosso código ficaria assim:

public Funcionario() {
}

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

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

public Funcionario(String nome, String sobrenome, int idade) {
    this.nome = nome;
    this.sobrenome = sobrenome;
    this.idade = idade;
}

public Funcionario(String nome, String sobrenome, int idade, String endereco) {
    this.nome = nome;
    this.sobrenome = sobrenome;
    this.idade = idade;
    this.endereco = endereco;
}

public Funcionario(String nome, String sobrenome, int idade, String endereco, String departamento) {
    this.nome = nome;
    this.sobrenome = sobrenome;
    this.idade = idade;
    this.endereco = endereco;
    this.departamento = departamento;
}

A classe Funcionario está ficando cada vez maior e até o momento só temos um método, se essa classe adicionar mais um atributo terá que acrescentar mais um construtor e quando tiver mais métodos a leitura e o entendimento vão ficar muito difíceis por conta de um código que só existe para criar um objeto. Então você pode perceber que esse padrão não é mais usado, mas agora ainda temos que resolver o problema de como criar um objeto Funcionario sem o endereço ou outros dados e depois adicioná-los.

Podemos criar um objeto Funcionario com o construtor padrão e depois atribuir os valores a ele:

Funcionario funcionarioIII = new Funcionario();
funcionarioIII.nome = "Jose";
funcionarioIII.sobrenome = "Alves";

Se você tentou fazer isso percebeu que esse código não compila pois o atributo nome e sobrenome não são acessíveis. Mas por que isso acontece? Isso se deve ao fato de que na classe Funcionario os atributos estão com o modificador de acesso private tornando-os inacessíveis para outras classes.

Isso significa que ler esses atributos agora também se tornou impossível:

System.out.println(funcionarioIII.nome);

Esse código também não compila pelo mesmo motivo. Mas como poderemos trabalhar com os atributos e por que usar o modificador private para deixar os atributos inacessíveis?

Antes de mais nada vamos pensar que estamos trabalhando em uma grande equipe e que hoje escrevemos esse código e que não foi colocado o modificador private e depois de um tempo outro desenvolvedor sem saber muito bem as regras de um funcionário no sistema de RH modifica o código que atribui o nome a um funcionário e faz algo assim:

Funcionario funcionarioIII = new Funcionario();
funcionarioIII.nome = null;

O código vai continuar compilando e vai executar sem dar algum problema visível porém estará com uma falha pois agora o nome do funcionário é null. Para impedir esse tipo comportamento de acessar diretamente dados de uma classe é que o encapsulamento foi pensado.

Mas nesses casos como poderá ser resolvido o problema de acesso as variáveis pois é necessário adicionar ou ler valores na classe Funcionario?

Para esses casos existem dois métodos especiais que nos auxiliam que são os chamados métodos getters e setters , onde o get é usado para leitura de dados e o set para adição de valores, então o código da classe Funcionario ficaria assim:

public class Funcionario {

    private String nome;
    private String sobrenome;

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getSobrenome() {
        return sobrenome;
    }

    public void setSobrenome(String sobrenome) {
        this.sobrenome = sobrenome;
    }

}

No código acima voltamos o modificador private e foi adicionado os métodos get e set para cada atributo; o método getNome oferece acesso ao valor do atributo nome e método setNome recebe uma String e atribui o seu valor para a variável nome da classe, isso já cria uma camada sobre os atributos mas aparentemente nós só movemos o comportamento de ler/adicionar valores para uma complexidade maior porém existe uma vantagem aqui que nem sempre é compreendida, nós conseguimos através dessa camada bloquear ou validar informações de entrada ou saída como no exemplo a seguir:

public String getNome() {
    if(nome == null || nome.isEmpty() || nome.isBlank()){
        System.out.println("Valor do nome não foi preenchido");
        return "";
    }
    return nome;
}

public void setNome(String nome) {
    if(nome == null || nome.isEmpty() || nome.isBlank()){
        System.out.println("Valor deve ser preenchido");
        return;
    }
    this.nome = nome;
}

Foi feita uma validação prévia tanto na entrada como na leitura dos dados e para usar essa nova abordagem podemos fazer da seguinte maneira:

Funcionario funcionarioIII = new Funcionario();
funcionarioIII.setNome(null);
System.out.println(funcionarioIII.getNome());
funcionarioIII.setNome("Guilherme");
System.out.println(funcionarioIII.getNome());

No codigo acima criamos uma instância de Funcionario e atribuímos a variável funcionarioIII , depois usamos o método setNome porém passando null , após isso usamos o método getNome para imprimir na tela o valor que nome possui, e por fim usamos novamente o método setNome porém agora passando um valor real e novamente usamos o getNome para recuperar o seu valor. O resultado é:

Valor deve ser preenchido
Valor do nome não foi preenchido

Guilherme

Então foi possível um certo nível de proteção aos dados da classe Funcionario. Então com encapsulamento podemos ver que temos como proteger e controlar melhor os atributos dentro de uma classe, também existe uma flexibilidade maior caso quiséssemos deixar os valores impedidos de ser escritos, pois poderíamos facilmente retirar os métodos setters e deixar para atribuição de valores apenas no momento da criação da classe através do construtor do objeto e ter os atributos como apenas leitura que é um conceito muito utilizado quando é pensado em objetos imutáveis.

Existem outros modificadores de acesso que são tanto utilizados para controle de acesso quanto para outros comportamentos e irei citá-los aqui porém serão vistos com mais profundidade em outros assuntos mais pra frente:

public : Esse modificador já vimos tanto nas classes, métodos e atributos, quando algo é marcado com esse modificador tem o seu escopo mais abrangente podendo ser usado em todos pacotes ou lugares do código.
protected : Com esse modificador o atributo ou método só será visível em suas subclasses , será visto quando for falado sobre Herança.
default : Quando usado esse modificador o código só é acessível dentro do seu próprio pacote. Para usar esse modificador basta deixar sem nenhuma palavra reservada antes da classe, método ou atributo, se tentar um código default em outro pacote irá ocorrer o mesmo erro de compilação de quando tentamos acessar um atributo private.

Outros modificadores, que alguns já fora abordados, são:

final : Quando utilizado em classes significa que esta não pode ser herdada por outras classes; quando usado em métodos ou atributos significa que os mesmos não podem ser sobrescritos.
abstract : Quando utilizado em classes significa que esta classe é uma Classe Abstrata , um tipo diferente de classe que veremos mais a frente; quando utilizada em métodos dentro de uma Classe Abstrata é para que sua implementação seja realizada na subclasse.
static : Utilizado em métodos ou atributos que são pertencentes a classe e não a instância.
transient : Utilizado em métodos ou atributos faz com que não sejam serializados. Utilizado em alguns casos no contexto de envio de informações para banco de dados onde alguns atributos não devem ser persistidos, mas não se preocupe com isso agora pois mesmo a sua utilização não é tão frequente.
synchronized : Utilizados em métodos quando escrevemos códigos de acesso paralelo, mas novamente não muito utilizado.

Conclusão

Vimos nesse artigo como criar e usar classes, desde a sua sintaxe até como proteger dados com encapsulamento. Vimos que criar métodos getters/setters acaba deixando um voluma alto de código que é usado apenas para cumprir com requisitos da linguagem mas sem lógica para o problema que desejamos resolver, chamados de códigos boilerplate , porém existe hoje muitas ferramentas que auxiliam o desenvolvedor nesse aspecto, as próprias IDEs ajudam muito na geração automática desse código, como é o caso do IntelliJ , Eclipse ou VSCode , porém existem bibliotecas escritas no Java que foram feitas para nos ajudar como é o caso do projeto Lombok.

O código deste artigo se encontra no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java III - Métodos, escopo e recursão

guilhermegarcia86 — Mon, 27 Sep 2021 00:00:01 +0000

Dando continuidade a série de artigos sobre o Java hoje erá abordado métodos , escopo e recursão. Ao fim desse artigo você será capaz de entender esses conceitos e também conseguirá aplicá-los em projetos.

Métodos

Nos artigos anteriores foi mostrado alguns métodos porém não entramos a fundo sobre o que significava aquilo, porém agora chegou a hora de entendê-los a fundo. Um método é uma ação que é desenvolvida porém só deve ser executada em algum momento programado, um método é um bloco de código que deve ser executado em um momento específico do programa.

A vantagem de usar métodos é o reaproveitamento de códigos onde podemos escrever uma vez aquele bloco e ele poderá ser executado em outros pontos sem que aja a necessidade de reescrever sempre a mesma funcionalidade.

No código abaixo será escrito um método simples mas onde poderemos ver a sintaxe de um método no Java :

public String helloWorld(){
    return "Olá Mundo!";
}

O método que foi criado irá exibir a mensagem Olá Mundo! , porém o que é necessário prestar atenção é a sintaxe como isso foi feito. Um método pode ter um modificador de acesso que significa basicamente se esse método pode ser visto por outros arquivos dentro do seu programa, esse assunto será explorado de melhor forma quando for abordado o tema de programação orientada a objetos, mas saiba que são quatro os modificadores de acesso:

public : Com esse modificador queremos dizer que ele é público e pode ser usado em outros pontos e pacotes.
protected : O protected é usado em casos de Herança e veremos mais a frente.
private : Ele só poderá ser usado dentro do arquivo onde foi escrito.
sem modificador : Podemos não colocar nenhum modificador e isso indica que ele é visivel apenas dentro do pacote onde ele foi criado, se tentarmos usar um método em outro pacote ele não estará disponível para uso.

O segundo ponto é que após a palavra public existe a palavra String e esse é um ponto obrigatório na linguagem, todo método necessita de um retorno que indica o que aquele método irá devolver ao final do processamento, nesse caso o código retorna uma String , que pode ser visto com o trecho return “Olá Mundo” onde a palavra return também é obrigatória quando existe algum retorno, pode parecer contraditório estar escrito que é obrigatório haver um retorno de método sempre mas não ser obrigatório a palavra return mas isso acontece pois nem todo método retorna alguma coisa mas todo método precisa de um retorno. Pode ter ficado meio confuso mas já explico, um método por vezes pode ser somente uma execução sem ter um valor para retornar, para ser mais claro segue um exemplo de um método que exibe um texto no console:

public void printHelloWorld(){
    System.out.println("Olá Mundo!");
}

O método printHelloWorld não tem um valor para ser retornado após a sua execução, ele só exibe uma mensagem e acaba, para esses casos ainda assim é necessário informar um retorno na assinatura desse método e pensando nisso é usada a palavra reservada void que indica que esse método é uma execução mas que não retorna nada após o seu fim, sendo assim não é necessário a palavra return dentro do método.

Após isso é necessário definir o nome do método, em Java usamos o que chamamos de camel case para nomenclaturas tanto de métodos como variáveis ou classes onde escrevemos tudo junto em minúsculo e separamos as palavras com letras maiúsculas então nesse caso o nome do método ficou printHelloWorld.

Todo método após o seu nome possui parênteses () isso serve para quando é necessário passar argumentos para um método, você já viu isso antes no método main onde ele possui String[] args, um array de argumentos, porém mesmo que não exista argumentos em um método é necessário ter os parênteses , para deixar claro como é um método onde existem argumentos segue o exemplo abaixo:

public void printHelloWorld(String nome){
    System.out.println("Olá Mundo " + nome + "!");
}

O método acima possui o que é chamado de parâmetros, que é a forma de passar informação para a execução de um método. Nesse caso é passado a variável chamada nome que é do tipo String para que seja executada dentro do método printHelloWorld.

Um método pode ter nenhum ou vários parâmetros como no exemplo abaixo:

public void printHelloWorld(String nome, int idade){
    System.out.println("Olá " + nome + " que tem " + idade + " anos!");
}

Toda essa sintaxe de modificadores de acesso , retorno do método , nomenclatura e argumentos é chamado de assinatura do método.

Em um método que possui um retorno diferente de void é possível que o seu valor seja atribuído a uma variável para que seja usado em outros pontos do programa:

public int soma(int x, int y){
    return x + y;
}

int resultado = soma(1, 2);

System.out.println("O valor da soma é " + resultado);

No exemplo acima foi definido o método soma que recebe dois argumentos como parâmetros do tipo int , executa a soma e retorna o valor. Foi possível capturar o retorno do método e atribuí-lo à variável resultado que foi usada mais abaixo para exibir a mensagem.

Para que os métodos acima sejam executadas e funcionem é necessário uma instância de classe pois todo método ou variável que não for static pertence a uma instância de classe, esse assunto será amplamente abordado em orientação a objetos. Isso significa que é necessário construir um objeto e usar o operador de acesso . (ponto):

public class ExemploMetodos {

    public void helloWorld(){
        System.out.println("Olá Mundo!");
    }

    public static void main(String[] args) {
        ExemploMetodos exemploMetodos = new ExemploMetodos();

        exemploMetodos.helloWorld();
    }

}

No exemplo acima foi criada a classe ExemploMetodos que possui o método helloWorld mas só será possível usar o método se existir uma instância ou objeto criado da classe ExemploMetodos e para acessar o método dessa instância é necessário usar o operador . (ponto).

Escopo

No Java uma variável é acessível dentro do bloco onde ela foi criada e isso é chamado de escopo.

Para entender o que é escopo é necessário ver os códigos que foram feitos até aqui:

public class ExemploEscopo{

    public void mostraIdade(int idade){
        System.out.println("A idade é " + idade);
    }

    public void mostraIdadeII(){
        System.out.println("A idade é " + idade);
    }
}

O código acima não compila no método mostraIdadeII com o erro: Cannot resolve symbol ‘idade’. Mesmo a variável idade existindo no método mostraIdade o escopo dela é pertencente ao método onde ela foi declarada então ela se torna inacessível fora do método mostraIdade. Para o código acima funcionar seria necessário definir a variável idade em um escopo onde ela fosse visível nos dois métodos:

public class ExemploEscopo{

    int idade = 20;

    public void mostraIdade(){
        System.out.println("A idade é " + idade);
    }

    public void mostraIdadeII(){
        System.out.println("A idade é " + idade);
    }
}

Agora a variável idade está em um escopo maior e é visível em dentro da classe ExemploEscopo.

Todos os blocos no Java possuem contexto de escopo, seja classes, métodos, condicionais ou laços de repetição isso significa que uma variável definida dentro de um bloco if/else só existe dentro do bloco, ela nasce e morre dentro do bloco não sendo acessível fora:

public void metodoEscopoIf(){

    if(true){
        int valor = 0;
    }

    System.out.println("O valor é " + valor);
}

O código acima também não compila com o erro: Cannot resolve symbol ‘valor’. Isso ocorre por que mesmo que esse bloco if sempre seja executado, pois é um bloco if com true , a variável valor é inciada dentro do bloco if e “vive” somente dentro do bloco if após encerrar o bloco a variável valor deixa de existir.

O mesmo é válido para laços de repetição:

for (int indice = 0; indice <= 10; indice++){
    System.out.println("O valor do indice é " + indice);
}

System.out.println(indice);

Mais uma vez esse código não compila e o erro é o mesmo, pois a variável indice foi inicializada dentro do bloco for e não existe e não é visível fora do bloco.

O conceito de escopo é aplicável para todos os bloco de códigos sejam eles os outros blocos condicionais, estruturas de repetição ou classes.

Recursão

Recursividade é a capacidade de um código se executar repetidas vezes. Para explicar melhor será mais fácil exemplificar a recursão com exemplos, então imaginando um problema onde desejamos exibir na tela a sequência de um número até 0:

public void exibirSequencia(int numero) {

    if (numero == 0) {
        return;
    }

    System.out.println(numero);

    exibirSequencia(--numero);
}

Esse código usa recursão para exibir a sequência de números. Mas vamos entender linha por linha como a recursão é executada nesse código:

Quando o valor de numero for igual a 0 (zero), para a chamada do método recursivo.
O valor atual da variável número é exibida.
O método exibirSequencia é executado novamente porém agora com o valor da variável numero é pré-decrementado, diminuído, em menos 1.

Um cuidado em chamadas recursivas é que facilmente podem gerar loops infinitos e erros do tipo Estouro de pilha ou StackOverflowError onde a memória de execução do programa estoura, para simular esse erro não é difícil no código que testamos, basta alterar o pré-decremento da variável numero para pós-decremento e testar:

public void exibirSequencia(int numero) {

    if (numero == 0) {
        return;
    }

    System.out.println(numero);

    exibirSequencia(numero--);
}

Esse código irá executar várias vezes com o mesmo resultado mas em algum momento irá quebrar com o seguinte erro:

Exception in thread "main" java.lang.StackOverflowError

Por esses motivos é recomendado só usar recursão em casos pequenos ou fáceis de monitorar, pois algoritmos mais complexos podem causar erros que só podem ser percebidos posteriormente ou que são difíceis de entender.

Conclusão

Nesse artigo foi apresentado métodos, como criá-los e usá-los, também foi mostrado sobre assinatura de métodos, modificadores de acesso , retorno e parâmetros ; aprendeu também sobre escopos e como o Java lida com blocos de contexto.

E por fim também foi apresentado recursão que é uma ferramenta muito importante da linguagem mas que deve ser usada com cuidado para não gerar erros inesperados.

No próximo artigo iremos entrar em Programação Orientada a Objetos.

O código dos exemplos está no GitHub

Visite também o nosso canal no Youtube para mais acompanhar essa série de Primeiros passos com o Java e muito mais conteúdos sobre programação.

Primeiros passos com Java II - Estruturas condicionais, laços de repetição e arrays

guilhermegarcia86 — Tue, 21 Sep 2021 13:11:13 +0000

No artigo anterior foi apresentado a linguagem Java, foi abordado um pouco da história, como criar um projeto Java no IntelliJ, variáveis, contantes, tipos e operadores.

Dando continuidade nesse artigo será abordado as estruturas de controle do Java como condicionais, laços de repetição e arrays. No final desse artigo você será capaz de entender o propósito de cada uma dessas estruturas de controle, saberá como usá-las e também será abordado o tema arrays e como eles se relacionam com laços de repetição.

If/Else

A primeira estrutura de controle a ser abordada será a estrutura de controle condicional If/Else que pode ser traduzido para Se/Senão. Essa estrutura faz uso direto da lógica Booleana que foi vista no primeiro artigo para que alguma decisão seja tomada no código.

A estrutura if/else funciona a partir de um valor booleano onde caso seja verdadeiro entrará na primeira condição e caso não seja verdadeiro entrará na segunda opção:

if(*declaração*){

}else{

}

Para entender melhor vamos explorar um exemplo básico onde temos um software que precisa avaliar se uma pessoa é maior de 18 anos e caso seja irá exibir uma mensagem e caso não seja irá exibir outra, vamos também aproveitar para começar a ver algumas bibliotecas padrão do Java que nos auxiliam como a API java.time:

LocalDate dataNascimento = LocalDate.of(1986, 03, 25);

var dataHoje = LocalDate.now();

Period period = Period.between(dataNascimento, dataHoje);

if(period.getYears() > 18){
    System.out.println("É maior de idade");
}else{
    System.out.println("Não é maior de idade");
}

System.out.println("Fim da execução");

Entendo o código acima temos a utilização da classe LocalDate que vem do pacote java.time que foi inserido no Java 8 e facilita muito o trabalho com datas, fazemos uso do método of, não se preocupe agora em entender o que é um método mas saiba que ele representa uma ação que será executada, onde é passado o ano, mês e dia e então é atribuído a uma variável chamada dataNascimento, logo abaixo é usado novamente a classe LocalDate porém com o método now que é usado quando queremos capturar a data atual e por fim atribuímos ele na variável dataHoje, note que foi utilizado a palavra reservada var ao invés da classe LocalDate que é um recurso do Java 9 e foi deixado aqui pra exemplo, em um caso real é bom manter um padrão onde deixamos todas as variáveis com var ou com o seu retorno para não haver confusão no código. Por fim logo abaixo foi utilizado a classe Period e o método between que faz a comparação entre duas data e conseguimos extrair o período entre elas.

A classe Period possui algumas informações que podemos trabalhar e entre elas trás o período de anos entre as duas datas e com isso conseguimos aplicar a lógica que pretendemos, que é verificar se pela data de nascimento já se passaram 18 anos ou não, então focando no trecho que interessa para entender a estrutura if:

if(period.getYears() > 18)

Se fossemos ler esse trecho poderíamos ler da seguinte forma: Se for verdade que o período de anos é maior do que 18 então...

Dessa forma caso isso seja verdade então o código a ser executado será o que estiver entre as chaves:

if(period.getYears() > 18){
    System.out.println("É maior de idade");
}

E para entender a estrutura else basta entender que caso a condição dentro do bloco if não seja verdadeira quem será executado será o que estiver entre chaves após a palavra else:

if(period.getYears() > 18){
    System.out.println("É maior de idade");
}else{
    System.out.println("Não é maior de idade");
}

Então rodando o exemplo acima de uma pessoa com data de nascimento em 25 de Março de 1986 (35 anos) a saída no terminal será:

É maior de idade
Fim da execução

Repassando mais uma vez passo a passo a execução do código dando foco ao bloco if/else:

1° Dentro do bloco if foi avaliado se 35 é maior do que 18.
2° Isso sendo verdade true ele "entrou" dentro da primeira condição e executou o que tinha lá dentro, nesse caso o print com a frase É maior de idade.
3° Não será executado o que tem dentro do else já que o primeiro bloco foi executado.
4° Prosseguiu com o programa e printou a frase Fim da execução.

Um último ponto importante do if/else no Java é que as chaves {} no if não são obrigatórias porém caso sejam omitidas somente a primeira linha após o if será executada como sendo parte do bloco if, isso facilita a escrita mas pode gerar confusões e bugs onde comportamentos que só deveriam ser executados dentro do if aparentemente estão sendo executados fora:

if(period.getYears() > 40)
    System.out.println("Executa lógica do if");
    System.out.println("Só pode executar se for maior de 40");

System.out.println("Fim da execução");

Olhando para o código acima parece que a intenção é executar os dois prints somente se for maior de 40 anos, porém rodando esse código a saída será:

Só pode executar se for maior de 40
Fim da execução

Isso ocorreu por que somente a primeira linha após o if foi considerada ao bloco, é como se para o compilador o código estivesse assim:

if(period.getYears() > 40){
    System.out.println("Executa lógica do if");
}
System.out.println("Só pode executar se for maior de 40");

System.out.println("Fim da execução");

E nesse caso foi avaliado que 35 não é maior do que 40 e não foi executado a primeira linha porém o programa prosseguiu e executou a linha que o desenvolvedor não queria que fosse executada caso a idade fosse menor do que 40, gerando um bug no código que nem sempre é fácil de entender a primeira vista.

Switch

Agora vamos imaginar que você é um desenvolvedor em uma empresa de pagamentos eletrônicos e você precisa receber os pagamentos de diversas bandeiras de cartão e processá-los, nesse exemplo hipotético você poderia usar uma estrutura if/else if/if para processar essa lógica:

String cartao = "Master";

if(cartao.equals("Master")){
    System.out.println("Processa Master");
}else if(cartao.equals("Visa")){
    System.out.println("Processa Visa");
}else if(cartao.equals("Amex")){
    System.out.println("Processa Amex");
}else if(cartao.equals("Elo")){
    System.out.println("Processa Elo");
}else {
    System.out.println("Não sei o cartão");
}

A estrutura if/else if/else não foi abordada no tópico anterior por um motivo, esse código é difícil de ler e dar manutenção e eu considero uma má prática.

Pensando nisso existe a estrutura switch onde existe um pouco mais de legibilidade do código, apresentando a estrutura switch:

switch(*declaração*){
  case *condição*:
    //Ação
    break;
  default:
    //Ação
    break;
}

A estrutura do switch é maior mas não é complicada, na inicialização do bloco switch informamos o dado que deve ser avaliado, e aqui entra um ponto importante do switch já que ele trabalha com outros tipos de dados diferentemente do if/else que só trabalha com boolean, podendo trabalhar com os tipos primitivos byte, short, char, e int, também trabalha com Enums, ainda não chegamos nesse assunto mas em breve chegaremos, Strings e as classes Wrappers Character, Byte, Short, e Integer, também não chegamos nelas mas logo será abordado.

Voltando ao switch, informamos o que será avaliado e caso seja algum dos valores que determinamos nas cláusulas case o código é executado, por fim caso nenhum dos case seja executado a cláusula default é executada, vamos ver como ficaria o exemplo de cartões utilizando essa abordagem:

String cartao = "Master";

switch (cartao){
    case "Master":
        System.out.println("Processa Master");
        break;
    case "Visa":
        System.out.println("Processa Visa");
        break;
    case "Amex":
        System.out.println("Processa Amex");
        break;
    case "Elo":
        System.out.println("Processa Elo");
        break;
    default:
        System.out.println("Não sei o cartão");
}

Executando esse código a saída será:

Processa Master

O código fica mais fácil de ler, você pode estar se perguntando: O que significa o break dentro do switch?

Ele serve como cláusula de escape do bloco switch, isso significa que se não fosse adicionado o break em cada case a partir do momento em que um case fosse executado todos os abaixo seriam executados, vamos tirar o break e executar o código para deixar claro:

String cartao = "Master";

switch (cartao){
    case "Master":
        System.out.println("Processa Master");
    case "Visa":
        System.out.println("Processa Visa");
    case "Amex":
        System.out.println("Processa Amex");
    case "Elo":
        System.out.println("Processa Elo");
    default:
        System.out.println("Não sei o cartão");
}

A saída será:

Processa Master
Processa Visa
Processa Amex
Processa Elo
Não sei o cartão

Como o valor era Master e ele era o primeiro case após ele ser executado todos os outros case foram executados e até mesmo o default foi executado.

Outra combinação possível é a situação onde mais de um case possui o mesmo processamento, vamos imaginar que queremos processar os meses do ano que tem 30 dias ou 31 dias podemos fazer assim:

 int mes = 3;

switch (mes) {
    case 1: case 3: case 5:
    case 7: case 8: case 10:
    case 12:
        System.out.println("Mês com 31 dias");
        break;
    case 4: case 6:
    case 9: case 11:
        System.out.println("Mês com 30 dias");
        break;
    case 2:
        System.out.println("Fevereiro pode ter 28 ou 29 dias");
        break;
    default:
        System.out.println("Mês inválido");
        break;
}

A saída desse programa será:

Mês com 31 dias

É possível aninhar cláusulas case mas tomando cuidado para isso não ferir a legibilidade do código.

While

O bloco while inaugura um tipo diferente de estrutura de controle, pois ele é uma estrutura de repetição e ele pode ser traduzido como enquanto, isso significa que ele irá se repetir enquanto uma condição for verdadeira, então podemos entender que o bloco while trabalha com booleanos. Para ficar mais claro segue a declaração do bloco while:

while(*condição*){

}

Como podemos ver é bem curta a declaração dele.

Então vamos imaginar um problema simples onde queremos mostrar na tela os números de 0 à 5, o while poderia ser usado nesses casos:

int indice = 0;

while (indice <= 5){
    System.out.println(indice);
    indice++;
}

Rodando o código termos como saída:

O interessante nesse código é que foi feito uso de pós-incremento com o operador ++, então analisando passo-a-passo o código:

1° A variável indice começa com o valor 0.
2° O bloco while faz a checagem se o valor de indice é menor ou igual a 5, se for executa o que estiver dentro do bloco while.
3° Dentro do bloco while printa na tela o valor atual da variável indice.
4° Pós-incrementa o valor da variável indice em 1 então nesse momento ela irá valer 1.
5° Retorna para o início do bloco while e verifica se o valor da variável indice é menor ou igual a 5, se for executa tudo de novo e se não for sai do laço de repetição.

O laço while também é muito usado quando se trabalha com Iterators que são coleções de dados no Java ligadas umas as outras onde cada uma sabe se existe um próximo na lista, mas não veremos isso por enquanto pois hoje em dia os Iterators perderam um pouco da força que tinham pois existem outras formas que as versões mais novas do Java lidam com esse tipo de estrutura de dados.

Do/While

Agora iremos entender a estrutura Do/While, que seria algo mais parecido com Faça/Enquanto traduzindo literalmente para o português, apesar da palavra while existir a ideia dele é um pouco diferente da estrutura while do tópico acima. A ideia por trás desse laço de repetição é que uma ação seja executada primeiramente e após isso seja avaliado se deve ser repetida ou não, a declaração dele é assim:

do {
    *declaração*
} while (*expressão*);

No trecho de código acima existe a inicialização do bloco com a palavra do, então o que estiver dentro desse bloco será executado pelo menos uma vez e após isso existe a palavra while onde será avaliada alguma expressão booleana e caso seja true irá repetir o que estiver dentro do bloco do.

Vamos pensar em um exemplo onde queremos mostrar na tela os números de 0 até 10 usando a estrutura do/while:

int contador = 0;
do {
    System.out.println("Contador é: " + contador);
    contador++;
} while (contador < 11);

System.out.println("Finalizado programa");

Rodando esse programa a saída na tela será assim:

Contador é: 0
Contador é: 1
Contador é: 2
Contador é: 3
Contador é: 4
Contador é: 5
Contador é: 6
Contador é: 7
Contador é: 8
Contador é: 9
Contador é: 10
Finalizado programa

Perceba que no início do código o bloco do é executado de primeira, imprime na tela a mensagem, após isso o valor da variável contador é incrementada, na sequência é avaliado dentro do while se o valor da variável contador é menor do que 11 e caso seja verdade (true) é repetido o fluxo dentro do bloco do, quando a variável contador chega o valor 11 o programa sai da estrutura do/while e o programa continua.

Para deixar um exemplo um pouco mais real ao invés de ficar percorrendo por números, vamos imaginar um programa que simule um despertador, ele irá tocar a primeira vez e depois irá verificar se está no modo soneca, caso ainda esteja irá tocar até que a pessoa desligue o alarme.

public static void main(String[] args) throws InterruptedException {

    do{
        System.out.println("SOAR ALARME: dim! drim! alarme de relógio");
    }while (despertadorEstaNaSoneca());

    System.out.println("Finalizado programa");

}

private static boolean despertadorEstaNaSoneca() throws InterruptedException {
    Thread.sleep(1000);
    return new Random().nextBoolean();
}

Explicando o código acima temos o bloco do que inicia o despertador, na sequência temos um método chamado despertadorEstaNaSoneca que verifica se ainda está na soneca e devolve um booleano, ele usa o Thread.sleep(1000); para esperar um segundo e depois executa o new Random().nextBoolean(); que escolhe se será true ou false randomicamente, isso significa que aleatoriamente vai ser escolhido se será true ou false, enquanto o despertadorEstaNaSoneca rodar e for true o bloco do irá se repetir. Não se preocupe muito com toda a sintaxe pois tudo isso será explicado mais pra frente, no momento em que foi rodado esse programa a saída foi:

SOAR ALARME: dim! drim! alarme de relógio
SOAR ALARME: dim! drim! alarme de relógio
Finalizado programa

Se for executado de novo esse programava pode haver mudança pois como é escolhido de forma aleatoria se é true ou false pode ser que demore mais.

For

O laço de repetição for é uma estrutura de repetição para situações onde é conhecido quantas vezes é necessário repetir uma tarefa. Em comparação com while e do/while onde o laço será repetido até que uma condição seja atendida a declaração do for já pede de antemão que seja informado a quantidade de vezes que será executado o código:

for (declaração 1; declaração 2; declaração 3) {
  // código a ser executado
}

Entendendo cada parte da declaração:

A primeira declaração é executada uma vez dentro do bloco for e é a inicialização da variável de controle.
A segunda declaração define a condição que será executada no bloco for.
A terceira declaração será executada sempre que houver uma repetição no bloco for.

Adicionando um exemplo mais prático iremos imprimir na tela os números de 0 até 10:

for (int indice = 0; indice <= 10; indice++){
    System.out.println(indice);
}

E a saída será:

Podemos ver que as três condições do bloco for foram atendidas, primeiro iniciamos uma variável chamada indice com valor 0, depois foi definido a condição de parada desse bloco sendo o valor da variável indice menor ou igual a 10 e por fim declaramos que a cada fez que o bloco for repetido o valor de indice deve ser incrementado em 1 e dentro do bloco mandamos imprimir o valor atual da variável indice.

É muito útil esse laço de repetição quando estamos trabalhando com listas do Java pois essa estrutura de dados já possui formas para sabermos o seu tamanho total, no exemplo abaixo fica um pouco mais claro:

var lista = List.of("Arroz", "Feijão", "Macarrão", "Óleo");

for (int indice = 0; indice < lista.size(); indice++) {
    System.out.println(lista.get(indice));
}

No código acima simulamos que temos uma lita de mercado e no laço for fazemos uso do método size que já diz qual é o tamanho dessa lista e dentro do bloco for mandamos imprimir o valor da lista de acordo com o índice. Valendo ressaltar que ainda não foi abordado listas e coleções de dados mas adiantando que listas no Java são coleções de dados que começam com o seu índice em 0.

Executando esse código a saída será:

Arroz
Feijão
Macarrão
Óleo

Existe outra forma de executar o laço for que é chamado de Enhanced-for ou for melhorado em tradução livre e é assim:

for (String l : lista){
    System.out.println(l);
}

Ele possui uma forma mais curta para escrever o código for porém ele só é possível de ser feito em coleções de dados que tenham o método size implementado pois por debaixo dos panos ele vai executar um for tradicional, ele é mais uma facilidade para o desenvolvedor.

Break/Continue

Agora que foi apresentado as estruturas de controles e repetições iremos ver as cláusulas break e continue, o break foi previamente apresentado na explicação do switch e agora ele será aprofundado em detalhes.

Imagine a seguinte situação onde você, como desenvolvedor, precisa escrever um código onde você possui uma lista e se houver algum valor específico nessa lista você precisa que pare todo o processamento ou dependendo do valor você quer ignorar e ir para o próximo valor, como poderia ser feito isso? É isso que o break e o continue fazem, vamos abordar primeiramente o break.

A cláusula break interrompe um laço de repetição ou no caso do switch para sair do bloco, vamos ver no exemplo:

for (int i = 0; i <= 10; i++){
    System.out.println("i = " + i);
    if(i == 5){
        System.out.println("Vai sair do for no valor 5");
        break;
    }
    System.out.println("proxima iteracao");
}

System.out.println("Finalizou");

E a saída desse programa será:

i = 0
Proxima iteracao
i = 1
Proxima iteracao
i = 2
Proxima iteracao
i = 3
Proxima iteracao
i = 4
Proxima iteracao
i = 5
Vai sair do loop no valor 5
Finalizou

Se não houvesse o break nesse código ele iria imprimir até o valor 10 pra depois finalizar mas o break forçou o encerramento dele, o mesmo podemos fazer com while:

int i = 0;
while (i <= 10){
    System.out.println("i = " + i);
    if(i == 7){
        System.out.println("Vai sair do while no valor 7");
        break;
    }
    i++;
}

E teremos como saída:

i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
Vai sair do while no valor 7
Finalizou

Mas e se precisarmos somente ignorar algum valor mas sem parar o processamento?

Para esse caso entra a cláusula continue que vai pular aquela iteração e passar para a próxima, vamos ver no exemplo abaixo para ficar mais claro:

for (int i = 0; i <= 10; i++){
    if(i == 5){
        System.out.println("Vai pular no valor 5");
        continue;
    }
    System.out.println("i = " + i);
    System.out.println("Proxima iteracao");
}

System.out.println("Finalizou");

E teremos como saída:

i = 0
Proxima iteracao
i = 1
Proxima iteracao
i = 2
Proxima iteracao
i = 3
Proxima iteracao
i = 4
Proxima iteracao
Vai pular no valor 5
i = 6
Proxima iteracao
i = 7
Proxima iteracao
i = 8
Proxima iteracao
i = 9
Proxima iteracao
i = 10
Proxima iteracao
Finalizou

Aqui podemos ver que no momento em que a variável i estava com valor 5 a cláusula continue pulou para o próximo valor e continuou o processamento.

Arrays

Arrays em Java são uma forma de guardar múltiplos valores em uma única variável e isso é algo muito útil para trabalhar com coleções de dados, conjuntos ou listas.

Existe duas formas de inicializar um array:

int[] array = new int[10];

Aqui podemos ver a sintaxe de um array onde é obrigatório definir o tipo desse array, o seu tamanho inicial e é necessário os colchetes [], podemos também declarar um array da seguinte forma:

int outroArray[] = new int[10];

Onde os colchetes [] estão após o nome da variável mas não é muito usual e também agora podemos declarar um array sem precisar dizer explicitamente o seu tipo:

var arraySemTipoExplicito = new int[10];

Apesar desse array não possuir o seu explicitamente tipado na variável o compilador consegue inferir o seu tipo então apesar da variável arraySemTipoExplicito não ter um tipo declarado o compilador entende que é um array de int com 10 posições.

Um ponto em comum com essas três declarações é que quando criamos um array utilizando a palavra reservada new, que é a palavra usada para criarmos em memória o array, é obrigatório informar o tamanho que esse array vai ter pois é necessário reservar espaços na memória para guardar os valores que podem ser preenchidos.

Após criar um array podemos inserir valores em cada posição dele e para isso temos que entender como um array é indexado. O índice de um array sempre começa em 0 então um array de 10 posições é acessível de 0 até 9, isso é muito importante pois se tentarmos acessar um posição inválida dentro de um array será lançado um erro no programa.

Então para adicionar valores em cada posição do array pode ser feito dessa maneira:

array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;
array[5] = 6;
array[6] = 7;
array[7] = 8;
array[8] = 9;
array[9] = 10;

Caso adicionemos valor em um índice que não existe:

array[10] = 10;

No momento da execução será lançado o seguinte erro:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 10

Porém existe uma outra maneira para inicializar um array e iremos ver agora:

int[] arrayInicializado = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

A diferença é basicamente que já criamos um array com os valores definidos.

Como todo array possui indices podemos acessar os seus valores através dos indices:

System.out.println(arrayInicializado[3]);

E saída será:

Seguindo a mesma lógica conseguimos alterar um valor dentro de um array pelo índice também:

arrayInicializado[0] = 10;
System.out.println(arrayInicializado[0]);

E agora o valor que inicialmente era 1 agora será 10.

Outra propriedade muito útil dos arrays é que quando nós criamos um array precisamos definir o seu tamanho, seja com new int[10] ou com os valores dentro de chaves {} e como arrays tem tamanho fixo nós temos condições de saber o seu tamanho sendo então muito usado para laços de repetição do tipo for, bastando com que seja usada a propriedade length:

for (int indice = 0; indice < arrayInicializado.length; indice++){
    System.out.println(arrayInicializado[indice]);
}

Ou podemos fazer uso do Enhanced-for também nesses casos:

for (int valor: arrayInicializado) {
    System.out.println(valor);
}

A diferença está no tamanho desse for e que não precisamos acessar o array no índice (arrayInicializado[indice]).

Vimos até o momento o modo mais comum de utilizar arrays, porém arrays podem ser multidimensionais isso significa que são arrays dentro de arrays não é algo muito comum mas dependendo do contexto pode ser utilizado porém sinceramente em minha experiência não é algo que se vê todo dia mas é bom ter esse conhecimento caso necessite resolver problemas ou caso se depare com algo assim em algum momento, então no exemplo iremos criar um array de duas dimensões:

int[][] arrayDimensional = { {1, 2, 3, 4}, {5, 6, 7} };

A primeira coisa que podemos notar é que precisamos adicionar dois colchetes [] na declaração da variável arrayDimensional e para cada array envolvemos com chaves {}, mas também poderíamos ter feito assim:

int[][] outroArrayDimensional = new int[4][3];

Para acessar, inserir ou alterar os valores dentro de um array multidimensional é necessário informar os dois valores, o primeiro para indicar qual array será utilizado e outro valor para informar qual o índice queremos acessar desse array:

System.out.println(arrayDimensional[0][2]);

Então nesse exemplo queremos acessar o primeiro array, lembrando que os índices sempre começam em 0, e dentro do primeiro array queremos o terceiro elemento, nesse caso o valor 3.

Se fosse necessário fazer um for em array multidimensional é possível e ficaria desse jeito:

for (int i = 0; i < arrayDimensional.length; i++) {
    for(int j = 0; j < arrayDimensional[i].length; j++) {
        System.out.println(arrayDimensional[i][j]);
    }
}

Nesse caso não é possível fazer uso do Enhanced-for pois é necessário trabalhar com os índices para acessar os dois arrays.

Podemos ver que é possível então trabalhar com arrays tridimensionais ou até com mais dimensões porém como podemos ver no código acima a legibilidade começa a ficar comprometida e para cada dimensão a mais no array precisaríamos aninhar outro laço for o que pode comprometer também a performance do programa dependendo da quantidade de elementos que cada array contenha.

Conclusão

Nesse artigo foi apresentado as estruturas de controle como if/else e switch vimos como criá-los e como usá-los, também vimos as estruturas de repetição com os laços while, do/while e for como podemos trabalhar com eles e em quais momentos usar cada um. Entendemos também as cláusulas break e continue como elas podem ser úteis quando precisamos interromper um processamento ou então ignorar um processamento mas sem parar o fluxo e por fim foi apresentado a estrutura de dados array e como podemos criá-los, acessar seus valores e percorrer seus dados com o laço for.

O link para o projeto que está no GitHub

Primeiros passos com Java

guilhermegarcia86 — Wed, 08 Sep 2021 15:17:17 +0000

História

Com sua primeira versão lançada em 1995 por James Gosling pela Sun Microsystems a linguagem Java se popularizou muito pois usava uma síntaxe que tentava se assemelhar com C/C++ porém sem algumas das dificuldades que uma linguagem de nível mais baixo trás consigo. Ela trouxe uma abordagem diferente das linguagens que eram convencionadas à época com o lançamento da JVM (Java Virtual Machine), um ambiente virtual onde o código é executado e a possíbilidade de executar o código em múltiplas plataformas não mais havendo a necessidade de compilar versões específicas, não que seja algo exclusivo do Java o próprio Erlang já fazia isso em 1986 com a sua virtual Machine, JAM e posteriormente com a BEAM, com isso o Java adotou o slogan "Write once, run anywhere" (Escreva uma vez, rode em qualquer lugar). Outro ponto muito importante foi a adoção de um paradigma orientado a objetos (POO), pois era muito mais comum e utilizado o paradigma procedural apesar do C++ já possuir a possibilidade de utilizar o paradigma orientado a objetos, isso trouxe mais flexibilidade e dinâmismo ao código e por fim o terceiro ponto que considero que foi uma grande vantagem foi a utilização de um Garbage Collector, que consiste em um mecânismo que faz o controle de memória do código, era um problema muito comum na linguagem C onde o desenvolvedor precisa lidar com alocação e liberação de memória no código, o que nem sempre é fácil ou trivial de se fazer e que acabava causando "vazamentos" de memória em aplicações. Tudo isso fez com que o Java se tornasse muito popular para desenvolvimento de aplicações que rodassem embarcadas em outras aplicações, os applets, desenvolvimento desktop, mobile e web.

Em 2005 a Oracle adquiriu a Sun por US$7.4 bilhões e prometeu continuar desenvolvendo e melhorando a linguagem, algo que era uma cobrança recorrente da comunidade pois lançamentos de melhorias demoravam muito. Até o momento desse artigo o Java está na versão 11LTS com previsão da versão 17LTS em 14 de setembro de 2021.

Instalação

Para instalar basta seguir essas orientações de acordo com o seu sistema operacional:

Windows

Linux

Mac

Iniciando um projeto

Nesses exemplos eu irei usar a IDE IntelliJ para criar o projeto e rodar os exemplos, a escolha é pela facilidade que essa IDE oferece de configuração e o suporte para o Java.

Poderíamos também criar os arquivos .java e compilá-los diretamente por linha de comando com o javac porém o intuito é fazer da forma mais parecida com o que é feito no dia a dia de um desenvolvedor.

Primeiramente é necessário instalar o IntelliJ, após abrí-lo clique em New Project como na imagem abaixo:

Após isso irá aparecer várias opções mas por enquanto basta deixar selecionado a opção Java e clicar em Next.

Na próxima tela selecione a opção Create project from template e a opção Command Line App ficará disponível para clicar, isso já criará um programa Java executável.

E por fim é necessário nomear o projeto, definir a pasta onde será salvo e o nome do pacote base. Os dois primeiros são simples de entender mas o terceiro é necessário pois todo programa Java é organizado em pacotes onde o código fica e este nome deve ser único por aplicação então foi convencionado de que o nome do pacote deveria ser o a URL da empresa ao contrário nesse caso ficou assim: br.com.company.

E após isso basta clicar em Finish o projeto será criado.

Entendendo o primeiro projeto

Quando um projeto novo é criado automaticamente é criado a classe Main.java com o seguinte código:

package br.com.company;

public class Main {

    public static void main(String[] args) {
    }
}

Essa é a sintaxe básica de um programa Java pois todo programa executável em Java necessita ter um método de entrada chamado main que seja public static void, entenderemos melhor o que isso significa adiante, e que receba um array de String, também entenderemos mais adiante o que isso significa, mas saiba que sem isso o programa não consegue ser executado pois no momento da execução de um programa o Java tenta localizar um método que siga esse modelo para iniciar.

Note também que na primeira linha do código aparece o nome do pacote.

Variáveis

Variáveis são posições de memória que são capazes de reter e representar expressões, elas existem em tempo de execução de um programa e tem nomes que são escolhidos pelo desenvolvedor para as identificar.

Esclarecendo melhor a explicação acima, uma variável nada mais é do que algo onde podemos colocar um valor e depois podemos trocar por outro, no exemplo abaixo fica um pouco mais claro:

int numero = 1;
numero = 2;

No trecho acima foi criado uma variável com nome "numero", por debaixo dos panos o Java irá reservar um espaço em memória para guardar o valor que foi definido, primeiramente com o número 1 e em seguida foi adicionado outro valor para a variável "numero" com o valor 2. Nesse momento outro espaço de memória é criado e nele é guardado o valor 2. Isso só é possível pois estamos usando uma variável e como o seu nome dá a entender o seu valor pode ser mudado.

Perceba também que antes da a variável "numero" tem a palavra int, isso acontece pois o Java é uma linguagem fortemente tipada, isso significa que tudo deve possuir um identificador de qual tipo é, nesse caso int representa os números inteiros, existem outros tipos e os veremos mais adiante.

Para criar uma variável é necessário informar o seu tipo, um nome e um valor:

tipo  nome     valor
int   numero = 2;

Porém a partir do Java 11 foi adicionado inferência de tipo, que significa que não precisamos dizer qual é o tipo de uma variável que a própria linguagem irá saber o seu tipo:

var numero = 2;

Basta adicionar a palavra reservada var que ele implicitamente irá entender que estamos trabalhando com um tipo numérico.

Porém o Java continua sendo fortemente tipado o que significa que uma variável não pode ser definida de um tipo e depois receber outro:

//Exemplo de código que não funciona
int numero = 1;
numero = "a";

Esse código não será compilado pela linguagem e receberemos uma mensagem de erro.

var numero = 1;
numero = "a";

Esse código também não será compilado e também receberemos uma mensagem de erro pois mesmo sem dizer qual o tipo da variável "numero" quando atribuímos o valor "1" para ela o próprio compilador já sabe que implicitamente essa variável é de um tipo numérico e sendo assim não poderia receber outro valor que não fosse um tipo numérico.

Constantes

Nem sempre teremos valores que são mutáveis e as vezes a intenção é que não seja possível que esse valor se altere. Por exemplo imaginando que exista um programa que faça contas matemáticas e utilize o número π (PI) para calcular a circunferência de um círculo:

double pi = 3.14159265359;
double circunferencia = pi * diametro = 2 * pi * raio;

Agora suponha que por algum descuido alguém mude o valor da variável pi, todos os lugares que usarem essa variável serão afetadas e o resultado estará errado o que pode causar inúmeros problemas como no exemplo abaixo:

double pi = 3.14159265359;
pi = 2;
double circunferencia = pi * diametro = 2 * pi * raio;

Para solucionar esse tipo de situação existem as constantes que são como variáveis porém o seu valor é definido uma única vez e não pode ser alterado. No Java não existe uma declaração explícita para uma constante como existem em outras linguagem, veja abaixo o exemplo de uma constante com JavaScript:

const pi = 3.14159265359;

No exemplo acima a palavra reservada const já indica que aquele valor não pode ser mudado, mas como estamos falando de Java vamos entender como ele lida com isso já que não possui uma palavra reservada para constantes.

No Java existem palavras reservadas que são usadas pela linguagem para alguns fins, entre elas existem duas que iremos destacar, a palavra reservada final e a palavra reservada static. A palavra reservada final é usada quando queremos que algo não possa ser modificado, seja uma variável, método ou classe (mais pra frente será explicado melhor) o que já parece ser um caminho pois com a palavra final uma variável declarada não poderá ser modificada. A palavra reservada static serve para indicar que algo pertence ao seu tipo e não a sua instância, eu sei que essa definição é meio confusa de entender ainda mais por que ainda não foi apresentado classes e instâncias, mas pense que isso significa que esse "algo", variável, classe ou método pode ser usado em outros pontos do programa sem que aja a necessidade de algumas burocracias que a linguagem exige. Colocando isso em prática uma constante ficaria assim:

static final double PI = 3.14159265359;
double circunferencia = PI * diametro = 2 * PI * raio;

Por convenção toda constante é escrita em letras maiúsculas e agora se por algum motivo alguém tentar alterar o valor da constante PI o compilador irá exibir uma mensagem de erro:

//Exemplo de código que não compila
static final double PI = 3.14159265359;
PI = 2;
double circunferencia = PI * diametro = 2 * PI * raio;

No exemplo acima criamos a constante PI porém no dia a dia podemos fazer uso da constante Math.PI do pacote java.lang.Math.

Tipos primitivos

Como dito anteriormente a linguagem Java é um linguagem fortemente tipada, isso significa que tudo, variáveis, constantes, métodos e classes são um tipo de dado. Existem dois tipos fundamentais no Java, os tipos primitivos e os tipos não primitivos. Aqui iremos ver o que são os dois e qual a controvérsia que existe sobre os tipos primitivos.

Um tipo primitivo é um valor diretamente guardado em memória, não é um objeto e sim o valor em si.

Parece ser contraditório já que a abordagem da linguagem é ser orientada a objetos e haver tipos primitivos, que são valores armazenados diretamente na memória, porém essa foi uma estratégia adotada pela equipe de desenvolvimento do Java, vamos entender quais são os tipos primitivos e quais valores podemos atribuir a eles:

----------------------|-----------|------------------------------|------------------------------|--------------|-----------|------------------------------------
Tipo                  | Primitivo |              Menor           |             Maior            | Valor Padrão | Tamanho   | Exemplo
----------------------|-----------|------------------------------|------------------------------|--------------|-----------|------------------------------------
                      |   byte    |              -128            |              127             |      0       |   8 bits  | byte b = (byte) 1;
Inteiro               |   short   |             -32768           |             32767            |      0       |   16 bits | short s = (short) 1;
                      |   int     |          -2.147.483.648      |          2.147.483.647       |      0       |   32 bits | int i = 1;
                      |   long    |  -9.223.372.036.854.770.000  |   9.223.372.036.854.770.000  |      0       |   64 bits | long l = 1l;
-----------------|-----------|------------------------------|------------------------------|--------------|-----------|------------------------------------
Ponto Flutuante       |   float   |           -1,4024E-37        |         3.40282347E+38       |      0       |   32 bits | float f = 1.1f;
                      |   double  |           -4,94E-307         |   1.79769313486231570E+308   |      0       |   64 bits | double d = 1.1; ou double d = 1.1d;
-----------------|-----------|------------------------------|------------------------------|--------------|-----------|------------------------------------
Caractere             |   char    |               0              |            65535             |     \0       |   16bits  | char c = 'a'; ou char c = 194;
-----------------|-----------|------------------------------|------------------------------|--------------|-----------|------------------------------------
Booleano              |   boolean |             false            |             true             |    false     |   1 bit   | boolean b = true;
-----------------|-----------|------------------------------|------------------------------|--------------|-----------|------------------------------------

Tipos não primitivos

Os tipos não primitivos são as classes e com isso é possível usar o paradigma de orientação a objetos, como herança, sobrecarga, sobrescrita e encapsulamento.
O Java possui várias classes que podemos usar e no exemplo abaixo iremos ver a classe String que representa um conjunto de caractéres e é usado para textos:

String texto = "Olá Mundo";

Como se trata de uma classe quando criamos uma variável do tipo String é criado um objeto e ganhamos ações (métodos) que podemos usar para trabalhar com textos, exemplo:

String texto = "Olá Mundo";
System.out.println(texto.toUpperCase());
System.out.println(texto.toLowerCase());

E se executarmos esse código a saída será:

OLÁ MUNDO
olá mundo

Foi usado o método println(string) da classe System que é método usado para exibir (printar) um texto no console.

Operadores aritméticos

Operadores aritméticos são usados quando é necessário executar operações matemáticas com variáveis e valores.

-----------------|-----------|------------------------------------|---------------------------------
Operação              | Operador  | Exemplo                            | Descrição                       
-----------------|-----------|------------------------------------|---------------------------------
Adição                |     +     |             x + y                  | Adição de valores               
Subtração             |     -     |             x - y                  | Subtração de valores            
Multiplicação         |     *     |             x * y                  | Multiplicação de valores        
Divisão               |     /     |             x / y                  | Divisão de valores              
Módulo                |     %     |             x % y                  | Retorna o resto de uma divisão  
Incremento            |    ++     |           x++ ou ++x               | Incrementa o valor em 1         
Decremento            |    __     |           x-- ou --x               | Decrementa o valor em 1         
-----------------|-----------|------------------------------------|---------------------------------

Operador de atribuição

Nos exemplos anteriores já foi usado o operador de atribuição e como o próprio nome já diz ele é um operador usado para atribuir algum valor, o operador mais comum de atribuição é o = (igual) onde uma variável recebe um valor mas existem outros operadores e iremos ver os mais usados;

-----|---------------------|------------------------------------------------------------------------------
Operador  | Exemplo             | Descrição          
-----|---------------------|------------------------------------------------------------------------------
=         |  x = 5              | Atribui o valor 5 para variável x
+=        |  x+= 5 ou x = x + 5 | Adiciona o valor 5 para a variável x             
-=        |  x-= 5 ou x = x - 5 | Subtrai o valor 5 para a variável x
*=        |  x*= 5 ou x = x * 5 | Multiplica o valor de x em 5 vezes              
/=        |  x/= 5 ou x = x / 5 | Divide o valor de x pelo número 5 e guarda o resultado na variável x   
%=        |  x%= 5 ou x = x % 5 | Divide o valor de x pelo número 5 e guarda o resto da divisão na variável x             
-----|---------------------|------------------------------------------------------------------------------

Um adendo aqui é que a temos o que é chamado de açúcar sintáxico em alguns operadores onde podemos escrever de forma mais resumida a expressão, onde x+= 5 tem o mesmo resultado que x = x + 5, as duas expressões fazem a mesma coisa mas a primeira é mais sucinta de escrever.

Operadores de comparação

Os operadores de comparação são utilizados para comparar valores e são muito usados em condicionais que serão mostradas mais adiante:

-----|----------------|----------|------------------------------------------------------------
Operador  | Nome           | Exemplo  | Descrição          
-----|----------------|----------|------------------------------------------------------------
==        | Igualdade      |  x == y  | Compara se o valor de x é igual ao valor de y
!=        | Não igualdade  |  x != y  | Operador usado para afirmar que dois valores não são iguais
>         | Maior que      |  x > y   | Compara se o valor de x é maior que o valor de y
<         | Menor que      |  x < y   | Compara se o valor de x é menor que o valor de y
>=        | Maior igual    |  x >= y  | Compara se o valor de x é maior ou igual que o valor de y
<=        | Menor igual    |  x <= y  | Compara se o valor de x é menor ou igual que o valor de y
-----|----------------|----------|------------------------------------------------------------

Existem outros operadores, porém foram demonstrados os mais usados no dia-a-dia.

Operadores Lógicos

Antes de entender os operadores lógicos vale a pena comentar sobre a tabela verdade, que é um dispositivo utilizado no estudo da lógica matemática. Com o uso desta tabela é possível definir o valor lógico de uma proposição, isto é, saber quando uma sentença é verdadeira ou falsa.

-----|----------------|-----------------|--------------------------------------------------------------------
Conectivo | Símbolo        | Operação lógica | Valor lógico          
-----|----------------|-----------------|--------------------------------------------------------------------
não       |       ~        |  negação        | Terá valor falso quando a proposição for verdadeira ou vice-versa
e         |       ^        |  conjunção      | Será verdadeira quando todas as proposições forem verdadeiras
ou        |       v        |  disjunção      | Será verdadeira se pelo menos uma das proposições for verdadeira
-----|----------------|-----------------|--------------------------------------------------------------------

Para ilustrar melhor vamos ao seguinte exemplo:

1 < 2 ^ 2 > 1

A seguinte expressão pode ser lida: O número 1 é menor do que 2 E o número 2 é maior do que 1 o que torna essa expressão como VERDADEIRA.

Uma forma de simplificar a tabela verdade seria desse modo:

--|---|-----|---------     ---|-----
p | q | p^q | p v q         p | ~p
--|---|-----|---------     ---|----
V | V |  V  |   V           V |  F
V | F |  F  |   V           F |  V
F | V |  F  |   V
F | F |  F  |   F
--|---|---------------

Agora trazendo isso para a linguagem Java, o que muda são os símbolos mas a lógica permanece a mesma e ao invés de termos o resultado dessas expressões como verdadeira ou falsa é usado true ou false e esse tipo de variável é do tipo boolean, um adendo que vale ressaltar é que essa lógica se chama Lógica Booleana em homenagem a George Boole que introduziu o tema em 1847.

Porém no Java não são usados os símbolos ~, ^, v para expressões booleanas, com exceção do operador ^ que é usado para outro operador lógico que não veremos aqui mas que para fins de conhecimento é o XOR ou chamado de OU Exclusivo; então para negação é usado o símbolo ! (exclamação), para conjunção é usado o símbolo & (E comercial) e para disjunção é usado o simbolo | (pipe) como no exemplo abaixo:

boolean verdadeiroConjuncao = (1 < 2) & (2 > 1);
boolean falsoConjuncao = (1 == 2) & (2 > 1);
boolean verdadeiroDisjuncao = (1 > 2) | (1 < 2);
boolean falsoDisjuncao = (1 > 2) | (2 > 3);
boolean negacao = !(1 == 1);

Conclusão

Começamos hoje uma série de artigos introdutórios ao Java, foi passado um pouco da história e conceitos básicos da linguagem no próximo artigo será apresentado o tema condicionais e laços de repetição.

Kafka Sink

guilhermegarcia86 — Mon, 21 Jun 2021 03:00:01 +0000

Introdução

No último artigo foi mostrado como é possível a partir de uma fonte de dados externa, alimentar um tópico do Kafka através do Kafka Source. Agora será visto como podemos fazer a operação inversa onde as informações de um tópico alimentarão uma fonte de dados externa através do Kafka Sink, nesse exemplo será usado o banco de dados não relacional MongoDB.

Kafka Sink

Como foi visto no artigo passado o Kafka Source é uma ferramenta open source criado pela Apache, essa ferramenta facilita a comunicação em sistemas externos ao Kafka, com isso conseguimos trazer dados de fontes externas e o oposto também pode ocorrer graças ao Kafka Sink, que realiza essa operação de sink (escoar) para sistemas externos.

Data Mountaineer

O Data Mountaineer é uma empresa com foco em BigData e streaming de dados que se juntou com a Landoop e fornece o connector que se liga ao Kafka Connect e realiza a operação de Sink que nesse caso será com o MongoDB.

Projeto

O projeto consistirá na configuração de um connector que irá receber mensagens de um tópico do Kafka e irá salvar essas informações no MongoDB, também será criado um projeto Java que estará conectado ao banco de dados e irá expor via API REST os dados para consulta.

Focando na parte que será apresentada temos um desenho do fluxo:

Onde podemos ver de forma resumida o fluxo de dados que começa com o banco de dados MySQL, onde as alterações são capturadas pelo Debezium e através do Kafka Connect são enviadas ao broker do Kafka e também via Kafka Connect os dados são consumidos de um tópico e enviados ao Data Mountaineer e serão inseridos no MongoDB.

Adicionando o Mongo ao Docker Compose

É necessário adicionar o MongoDB ao docker-compose como abaixo:

  mongo:
    image: mongo
    container_name: mongo
    depends_on: 
    - kafka-cluster    
    ports:
      - 27017:27017
    networks: 
      - kafka-network

Acessando o MongoDB

Vamos acessar o MongoDB via terminal:

docker exec -it mongo mongo

E vamos acessar a collection taxpayer:

use taxpayer

Configurando Kafka Sink

Para configurar o Kafka Sink basta acessar novamente o dashboard, através da imagem landoop/kafka-lenses-dev e clicar em Connectors no lado esquerdo e depois no botão New Connector.

Será exibida a tela com os conectores disponíveis e entre eles o conector do MongoDB basta clicar nele que será aberta a tela para inserir as configurações.

Nessa tela iremos inserir as seguintes configurações:

connector.class=com.datamountaineer.streamreactor.connect.mongodb.sink.MongoSinkConnector
connect.mongo.kcql=UPSERT INTO taxpayer SELECT after FROM irs-conn.decider.complaint_taxpayer PK after.document;UPSERT INTO taxpayer SELECT after FROM irs-conn.decider.defaulted_taxpayer PK after.document
connect.mongo.connection=mongodb://mongo:27017
tasks.max=2
topics=irs-conn.decider.complaint_taxpayer,irs-conn.decider.defaulted_taxpayer
name=mongo
connect.mongo.db=taxpayer

Vamos bater ponto a ponto essa configuração:

name: Nome da conexão.
connector.class: É a classe que é carregada para fazer a conexão com o MongoDB.
connect.mongo.connection: URI de conexão com o banco de dados.
connect.mongo.db: Nome da collection no Mongo.
tasks.max Máximo de tasks para essa conexão.
topics: Aqui deve ser informado quais são os tópicos que serão "escutados" pelo Kafka Connect para delegar ao Data Mountaineer
connect.mongo.kcql: KCQL é como diz documentação, SQL for Kafka Connect, não é algo incomum a própria Confluent possui algo similar que é o kSQL que nada mais é do que uma forma de simplificar a manipulação de dados e streams através de queries SQL. Como no nosso exemplo iremos capturar dados de dois tópicos precisamos criar duas queries para fazer UPSERT no MongoDB.

Após clicar em Create Connector a nova conexão deve ser listada como mostrado abaixo:

Monitorando o MongoDB

Agora podemos realizar alterações no MySQL e elas serão enviadas para os tópicos correspondentes e serão capturadas pelo Kafka Sink e enviadas ao MongoDB:

> db.taxpayer.find().pretty()
{
        "_id" : "890.955.180-19",
        "after" : {
                "document" : "890.955.180-19",
                "email" : "teste@teste.com",
                "name" : "Sandra Nair Sueli Ribeiro",
                "status" : "DEFAULTED"
        }
}
{
        "_id" : "869.097.474-10",
        "after" : {
                "document" : "869.097.474-10",
                "email" : "fake@fake.com.br",
                "name" : "Joao Alface",
                "status" : "COMPLAINT"
        }
}

Projeto Java

Para iniciar o projeto foi utilizado o Spring Initializr onde foi adicionado as dependências de Web, Lombok e Spring Data Mongo.

Iniciando pelo domínio dessa aplicação temos a Taxpayer:

@Data
@Builder
public class Taxpayer {

    private String document;
    private String email;
    private String name;
    private String status;

}

E nos casos de uso dessa aplicação queremos que seja possível buscar os Taxpayers pelo número de documento, email e listar todos. Para isso foi criado a classe SearchTaxpayer:

@Component
public class SearchTaxpayer {

    private final TaxpayerRepository taxpayerRepository;

    @Autowired
    public SearchTaxpayer(TaxpayerRepository taxpayerRepository){
        this.taxpayerRepository = taxpayerRepository;
    }

    public Taxpayer searchByEmail(String email){
        final Optional<Taxpayer> optionalTaxpayer = taxpayerRepository.findByEmail(email);

        if(!optionalTaxpayer.isPresent()){
            throw new TaxpayerNotFoundException("Taxpayer not found");
        }

        return optionalTaxpayer.get();
    }

    public Taxpayer searchByDocument(String document){
        final Optional<Taxpayer> optionalTaxpayer = taxpayerRepository.findByDocument(document);

        if(!optionalTaxpayer.isPresent()){
            throw new TaxpayerNotFoundException("Taxpayer not found");
        }

        return optionalTaxpayer.get();
    }

    public List<Taxpayer> findAll(){
        return taxpayerRepository.findAll().get();
    }
}

Para ela funcionar é necessário criar a classe TaxpayerRepository que nada mais é que a interface que servirá como port no conceito de ports and adapters:

public interface TaxpayerRepository {

    Optional<Taxpayer> findByEmail(String email);

    Optional<Taxpayer> findByDocument(String document);

    Optional<List<Taxpayer>> findAll();
}

E agora criamos o nosso Adapter para ele, mas primeiro faremos as configurações que o MongoDB necessita, primeiro criando a nossa entidade de banco de dados:

@Data
@Document(collection = "taxpayer")
public class TaxpayerEntity {

    @Id
    private String id;

    private After after;
}

@Data
public class After {

    private String document;
    private String email;
    private String name;
    private String status;

}

Como estamos usando Spring Data o trabalho é muito simplificado bastando criar uma interface que estenda de MongoRepository:

public interface MongoTaxpayerRepository extends MongoRepository<TaxpayerEntity, String> {

    Optional<TaxpayerEntity> findByAfter_Email(String email);

    Optional<TaxpayerEntity> findByAfter_Document(String document);
}

Agora criamos o Adapter implementando a TaxpayerRepository:

@Component
public class MongoTaxpayer implements TaxpayerRepository {

    private final MongoTaxpayerRepository mongoTaxpayerRepository;

    @Autowired
    public MongoTaxpayer(MongoTaxpayerRepository mongoTaxpayerRepository){
        this.mongoTaxpayerRepository = mongoTaxpayerRepository;
    }

    @Override
    public Optional<Taxpayer> findByEmail(String email) {

        final Optional<TaxpayerEntity> optionalTaxpayerEntity = mongoTaxpayerRepository.findByAfter_Email(email);

        if(!optionalTaxpayerEntity.isPresent()){
            return Optional.empty();
        }

        final After after = optionalTaxpayerEntity.get().getAfter();

        return Optional.of(Taxpayer.builder().name(after.getName()).document(after.getDocument()).email(after.getEmail()).status(after.getStatus()).build());
    }

    @Override
    public Optional<Taxpayer> findByDocument(String document) {

        final Optional<TaxpayerEntity> optionalTaxpayerEntity = mongoTaxpayerRepository.findByAfter_Document(document);

        if(!optionalTaxpayerEntity.isPresent()){
            return Optional.empty();
        }

        final After after = optionalTaxpayerEntity.get().getAfter();

        return Optional.of(Taxpayer.builder().name(after.getName()).document(after.getDocument()).email(after.getEmail()).status(after.getStatus()).build());
    }

    @Override
    public Optional<List<Taxpayer>> findAll() {

        final List<TaxpayerEntity> taxpayerEntityList = mongoTaxpayerRepository.findAll();

        if(null == taxpayerEntityList || taxpayerEntityList.isEmpty()){
            return Optional.empty();
        }

        final List<Taxpayer> taxpayerList = taxpayerEntityList.stream().map(taxpayerEntity -> {
            final After after = taxpayerEntity.getAfter();

            return Taxpayer.builder().name(after.getName()).document(after.getDocument()).email(after.getEmail()).status(after.getStatus()).build();
        }).collect(Collectors.toList());

        return Optional.of(taxpayerList);
    }
}

Com o adaptador criado vamos criar o controller que irá receber as requisições REST e delegar para a classe SearchTaxpayer:

@RestController
@RequestMapping("/taxpayer")
public class TaxpayerController {

    @Autowired
    private SearchTaxpayer searchTaxpayer;

    @GetMapping
    public ResponseEntity<List<Taxpayer>> getAllTaxpayers(){
        return ResponseEntity.ok(searchTaxpayer.findAll());
    }

    @GetMapping("document")
    public ResponseEntity<Taxpayer> getTaxpayerByDocument(@RequestParam("document") String document){
        return ResponseEntity.ok(searchTaxpayer.searchByDocument(document));
    }

    @GetMapping("email")
    public ResponseEntity<Taxpayer> getTaxpayerByEmail(@RequestParam("email") String email){
        return ResponseEntity.ok(searchTaxpayer.searchByEmail(email));
    }

}

Após subir a aplicação e fazendo uma requisição para url


 teremos como resultado:



```json
[
    {
        "document": "890.955.180-19",
        "email": "teste@teste.com",
        "name": "Sandra Nair Sueli Ribeiro",
        "status": "DEFAULTED"
    },
    {
        "document": "1234567890",
        "email": "fake@fake.com.br",
        "name": "Joao Alface",
        "status": "COMPLAINT"
    }
]

Conclusão

Aqui vimos a outra ponta do Kafka Connect, o Kafka Sink e foi apresentado um exemplo prático de como podemos ter bases ou até mesmo aplicações que podem receber dados através de streams com as ferramentas que o Kafka disponibiliza.

Código fonte

O código do projeto está no GitHub

Kafka Connector

guilhermegarcia86 — Mon, 21 Jun 2021 03:00:01 +0000

Introdução

Continuando a sequência de artigos sobre Kafka agora vamos entender o que é o Kafka Connect e iremos criar um listener que capturará mudanças no banco de dados e irá enviar para um tópico no Kafka.

Kafka Connect

O Kafka Connect é uma ferramenta open source criada pela Apache para poder se conectar com sistemas externos e lidar com volumes altíssimos de dados, podendo assim tanto receber quanto enviar dados para essas fontes. No artigo abaixo iremos explorar o Kafka Connect Source API que faz a parte de ingestão de dados mas também há o Kafka Connect Sink API que é o responsável por enviar dados de tópicos do Kafka para sistemas externos.

Debezium

O Debezium é um CDC, abreviação para Change Data Capture, isso significa que ele é uma peça que fica conectada ao Kafka Connect e tem a responsabilidade de capturar alterações no banco de dados. Ele possui vários conectores para bancos de dados como SQL Server, Oracle, PostgreSQL, MongoDB e etc. nesse artigo será usado o connector para MySQL.

Projeto

Para começar vamos analisar o esboço arquitetural abaixo e entender o que está sendo proposto:

Em comparação com os desenhos dos artigos anteriores o ponto que mudou foi na aplicação Decider que possui um banco de dados MySQL e nele está conectado o Debezium e este está conectado ao Kafka Connect que por sua vez está conectado ao broker do Kafka.

Primeiramente olhando para o desenho do banco de dados conseguimos ver que existe o Binlog se conectando ao Debezium, isso por que o Debezium se conecta ao Binlog e através dele consegue ficar "escutando" todas as transações que ocorrem no banco.

Mas o que é esse Binlog?

O Binlog é a abreviação para Binary Logs que é a forma como os bancos de dados tem para guardar os eventos que ocorreram neles, ele guarda muitas métricas como por exemplo quanto tempo uma query demorou para ser executada, quais dados foram criados, alterados, deletados e etc.

Após receber a informação do Binlog o Debezium delega ao Kafka Connect que é quem realmente se conecta ao broker do Kafka e cria ou insere em um tópico já existente.

Configurando o ambiente

Nos artigos anteriores estava usando a imagem landdop/fast-data-dev pois ela já fornecia todo o ambiente do Kafka pronto para o desenvolvimento porém durante os testes com o Kafka Connect ela estava apresentando problemas com os conectores do Debezium e após pesquisar soluções e alternativas encontrei uma nova imagem landoop/kafka-lenses-dev, porém para executar essa imagem é necessário criar uma licença na Lenses.

Após receber a licença basta adicionar como variável de ambiente e acessar localhost:3030 com usuário e senha admin.

Como estou usando Docker Compose o .yml fica assim:

version: '3'

services:

  mysql:
    image: mysql:8.0.17
    cap_add: 
      - SYS_NICE
    environment: 
      MYSQL_ROOT_PASSWORD: root
      MYSQL_USER: user
      MYSQL_PASSWORD: user
      MYSQL_DATABASE: register
    networks: 
      - kafka-network
    ports: 
      - "3306:3306"
    volumes: 
      - ./data/decider.sql:/docker-entrypoint-initdb.d/decider.sql

  kafka-cluster:
    image: landoop/kafka-lenses-dev
    environment:
      EULA: "https://licenses.lenses.io/download/lensesdl?id=idLicenseLenses" 
      CONNECT_HEAP: 3G
      ADV_HOST: 127.0.0.1
      SAMPLEDATA: 0
      RUNTESTS: 0
    networks: 
      - kafka-network
    ports:
      - "2181:2181"                 # Zookeeper
      - "3030:3030"                 # Landoop UI
      - "8081-8083:8081-8083"       # REST Proxy, Schema Registry, Kafka Connect ports
      - "9581-9585:9581-9585"       # JMX Ports
      - "9092:9092"                 # Kafka Broker
    depends_on: 
      - mysql

networks:
  kafka-network: 
    driver: bridge

Configurando Debezium

Vamos iniciar a configuração do Debezium no Kafka Connect.

Quando acessar o dashboard na guia lateral clique em Connectors:

Após isso clique em New Connector:

No dashboard irá aparecer todos os conectores disponíveis (existem dois CDC MySQL mas é por que um é o CDC SQL Server que está com o nome errado):

Irá aparecer o campo text area para inserir as configurações e a aqui vale passar ponto a ponto as configurações:

name=IRS-Connector
connector.class=io.debezium.connector.mysql.MySqlConnector
database.hostname=mysql
database.port=3306
database.user=user
database.password=user
database.allowPublicKeyRetrieval=true
database.server.name=irs-conn-v1
database.include.list=decider
database.exclude.list=register
database.blacklist=register
database.history.kafka.bootstrap.servers=localhost:9092
database.history.kafka.topic=schema-changes.decider
table.exclude.list=decider.flyway_schema_history,register.flyway_schema_history
table.blacklist=decider.flyway_schema_history,register.flyway_schema_history

O campo name é obrigatório e define o nome do conector.
O campo connector.class é obrigatório e é a definição de qual classe que será carregada para esse conector.
Os campos database.hostname, database.port, database.user e database.password são obrigatórios e são os dados de conexão do banco de dados.
O campo database.allowPublicKeyRetrieval é opcional e eu adicionei para permitir o client executar o request da public key.
O campo database.server.name é obrigatório, pode ser qualquer nome mas será usado como prefixo para os tópicos que serão criados no Kafka.
O campo database.include.list é opcional e serve para informar qual database deve ficar escutando as alterações, como nesse exemplo temos dois databases adicionei qual queria.
O campo database.exclude.list é opcional e é o oposto do campo acima e eu adicionei o database que eu não quero ficar observando as alterações.
O campo database.blacklist está depreciado pelo campo database.exclude.list segundo a documentação do Debezium, mas não sei se por questão de versão ou bug o campo database.exclude.list não estava funcionando; mas ele é exatamente a mesma ideia de excluir um database específico.
O campo database.history.kafka.bootstrap.servers é obrigatório e basicamente é o host/port do cluster do Kafka.
O campo database.history.kafka.topic é obrigatório e serve para nomear o tópico no Kafka onde o conector guarda o histórico de schemas do database.
O campo table.exclude.list é opcional e indica uma tabela que não deve ter as suas alterações observadas, deve estar no formato nome do database + nome da tabela, nesse caso como o projeto utiliza Flyway para gerenciamento das versões do banco de dados eu o adicionei.
O campo table.blacklist também está depreciado porém como ocorreu com o campo database.exclude.list não estava funcionando.

Após adicionar as configurações basta clicar em Create Connector:

Obs: Esse comando também pode ser feito via cURL pois ele é executado via Kafka REST e ficaria dessa foram:

cat << EOF > IRS-Connector.json
{
  "name": "IRS-Connector",
  "config": {
    "connector.class": "io.debezium.connector.mysql.MySqlConnector",
    "database.hostname": "mysql",
    "database.port": "3306",
    "database.user": "user",
    "database.password": "user",
    "database.allowPublicKeyRetrieval": "true",
    "database.server.name": "irs-conn-v1",
    "database.include.list": "decider",
    "database.exclude.list": "register",
    "database.blacklist": "register",
    "database.history.kafka.bootstrap.servers": "localhost:9092",
    "database.history.kafka.topic": "schema-changes.decider",
    "table.exclude.list": "decider.flyway_schema_history,register.flyway_schema_history",
    "table.blacklist": "decider.flyway_schema_history,register.flyway_schema_history"
  }
}
EOF
curl -X POST -H "Content-Type: application/json" -H "Accept: application/json" -d @IRS-Connector.json http://localhost:3030/api/proxy-connect/dev/connectors

Se tudo estiver certo deverá aparecer a tela de status com o conector rodando:

Se clicarmos em Explore na guia lateral iremos ver que foram criados os tópicos e também foram criados os schemas no Schema Registry:

Capturando mudanças no banco de dados

Após todas essas configurações o conector está pronto e o Debezium já está escutando as alterações, sendo assim se fizermos um INSERT no banco Decider ele irá capturar esse evento através do Binlog e irá adicionar ao tópico do Kafka como na imagem abaixo:

Aqui conseguimos ver alguns detalhes, primeiro a key passa a ser o id da tabela no banco de dados e segundo que o nosso value trás algumas informações mas o que chama mais a atenção é que ele consegue trazer o valor anterior e o valor atual que foi alterado, nesse exemplo como é um INSERT o campo before é nulo.

Agora se atualizarmos o valor dessa linha na tabela:

Isso gerará uma mensagem no tópico do Kafka onde no campo value poderá ser visto o valor do campo before com os dados antes da atualização e no campo after o valor atual daquela linha nesta tabela.

Com isso agora temos o conector em pleno funcionamento capturando qualquer alteração realizada nas tabelas que configuramos para monitorar.

Conclusão

No artigo foi apresentado como podemos usar um conector para "pegar" os dados em um banco de dados ou qualquer sistema externo e trazer para um tópico no Kafka; o oposto também pode ser feito que é capturar dados em um tópico e inserir em um sistema externo, essa é a responsabilidade do Connector Sink API e aqui deixo o link para um exemplo onde é usado o Connector Sink API para inserir dados em um banco de dados PostgreSQL.

Código fonte

Segue o código feito no GitHub