Descobrindo a classe de um objeto: instanceof

Nesse rápido, e útil, tutorial ensinaremos como descobrir a classe de um objeto através da keyword:
instanceof

• Java Progressivo em PDF(download da Apostila)

Polimorfismo: Classes abstratas e Métodos abstratos

Desde que iniciamos nossos tutoriais sobre classes e objetos vínhamos tratando as classes como entidades 'reais' ou 'concretas', pois podíamos instanciar objetos a partir dela.

Nesse artigo vamos introduzir um conceito importante e bastante útil na orientação a objetos: a abstração.

Pode parecer estranho, ou no mínimo confuso, classificar e utilizar algo que se diz ser abstrato, mas veremos que esse tipo de idéia é bem interessante e bem mais realista que nossa noção antiga de classe e objeto.

O laço for para Arrays: o laço For each

Em toda sua vida de programador Java, será comum você usar o laço for para percorrer todos os elementos de um Array.

Se isso é tão utilizado e importante, poderia ter um atalho ou meio mais fácil de fazer isso, não?
É, e tem.
Sem contar que, com Arrays e o laço for convencional, é bem fácil de se enrolar e cometer erros.

Aprenda uma maneira especial de usar o laço for e pare de ter problemas: é laço foreach

• Java Progressivo em PDF(download da Apostila)

Fazendo o for percorrer todo o Array/Vetor

A utilização é bem simples e direta. Vamos usar essa variante do for que percorre sempre, do começo ao fim, todos os elementos de um Array.
É bem útil, também, em termos de precaução e organização, pois alguns programadores não gostam de usar o índice 0, usam direto o índice 1 do array, ou as vezes nos confundimos e passamos (durante as iterações) do limite do array. Isso pode ser facilmente evitado usando o laço for modificado para percorrer os elementos de um array.

A sintaxe do for each é a seguinte:
for ( tipo variavel_do_tipo_do_seuArray : seuArray){
//seu código
}

Se o 'seuArray' for de inteiro, ficaria:
for (int count : seuArray){
...
}

Como podemos interpretar esse laço foreach?
Muito simples, o inteiro 'count' vai receber, a cada iteração, todos os valores de 'seuArray'.
Ou seja, ele vai percorrer todo o seu Array e receber seus valores, na ordem (do começo para o fim), um por vez. E com esses valores você vai fazer o que desejar.

Por exemplo, suponha que as notas de cada aluno de uma escola é armazenada em um Array.
Como para calcular a média você precisará sempre percorrer todo o Array/Vetor, pode, e deve-se, usar esse laço for especial. Pois ele foi feito para isso, para facilitar nossa vida.

Programadores não devem perder tempo. Devem fazer as coisas sempre da maneira mais simples e prática possível. Não tente fazer arte ou gambiarra.
Se o próprio Java lhe fornece as opções e ferramentas, use-as.

É uma arma 'especial' que não se vê por aí, em qualquer linguagem de programação.
Se você já programa ou programou em outra linguagem deve estar percebendo como Java é cheio dessas ferramentas e pormenores.
Se estudar tudo direitinho, irá se tornar um eficiente programador, pois o Java realmente foi feito para facilitar a vida de desenvolvedores, é realmente uma linguagem voltada para o trabalho.

Exemplo de uso do foreach em Java:

Crie um aplicativo em Java que peça 5 números ao usuário.
Depois, mostre o resultado da soma desses números;

Passo 1:
Vamos declarar o vetor de inteiro e o inteiro 'soma' para receber a soma dos resultados que o usuário fornecer.

Usamos um laço for, convencional, para percorrer o array.
Note que usamos 'numero.length', que é uma boa prática.

Passo 2:
Agora temos que percorrer o array inteiro, e já que temos que fazer isso, vamos fazer usando o laço for modificado que percorre um array inteiro recebendo seus valores.
Como o inteiro 'cont' vai receber os dados de todos os elementos do array 'numero', vamos somar o valor de 'cont' a cada iteração na variável 'soma'.

O código Java de nossa aplicação ficará:

import java.util.Scanner;

public class forParaArray {
    
    public static void main(String[] args){
            int[] numero = new int[5];
            int soma=0;
            Scanner entrada = new Scanner(System.in);
            
            for(int cont=0 ; cont< numero.length ; cont++){
                System.out.print("Entre com o número "+(cont+1)+": ");
                numero[cont]=entrada.nextInt();
            }
            
            //exibindo e somando
            for(int cont : numero){
                soma += cont;
            }
            
            System.out.println("A soma dos números que você digitou é "+soma);
        }
}

Os comandos break e continue: interrompendo e alterando fluxos e loopings

Nesta parte de nossa apostila online iremos ver os comandos break e continue, do Java, que servem para nos propiciar um maior controle sobre o fluxo dos aplicativos, especialmente das iterações dos loopings.

• Apostila de Java em PDF

Para que servem os comandos BREAK e CONTINUE em Java

Geralmente, em nossos programas de Java, iremos usar os laços while, for e do ... while para procurar algum ítem, número ou checar alguma condição.

Por exemplo, imagine que você foi contratado para fazer um programa, em Java, claro, para um banco.
Em um momento do aplicativo, o cliente insere o número de sua conta e o programa vai buscar esse número no banco de dados do sistema, que tem milhões de clientes cadastrados.
Ele vai fazer essa busca através de um looping.

Porém, imagine que o programa encontra os dados do cliente logo no começo, logo nas primeiras posições.
E aí, vai checar todo o resto do banco de dados?
Claro que não, isso seria perda de tempo.

É aí que entram os comandos break e continue. Esse seria um bom exemplo onde daríamos um 'break' no laço, pois já encontramos o que queríamos.

O comando break

Break significa quebrar, parar, frear, interromper. E é isso que se faz.
Quando o Java encontra esse comando pela frente, ele interrompe o laço/estrutura de controle ATUAL, como o while, for, do ... while e o switch (que veremos no próximo artigo da apostila).

Vamos mostrar um exemplo do uso do break através de um exemplo matemático.

Exemplo de uso:

Suponha que você é um cientista e quer saber se entre os números 1 e um milhão existe um número que é múltiplo de 17 e 19, ao mesmo tempo.
Ou seja, queremos saber se existe um número entre 1 e um milhão que deixa resto 0 na divisão por 17 e por 19.
Caso exista, o imprima. E só imprima o menor.

Poderíamos fazer um laço de 1 até 1 milhão, e testar isso através de um for.
Ok, é uma solução. O principal na vida profissional de um programador é saber resolver o problema.

Vamos usar um método chamado 'currentTimeMillis()', que retorna um tipo 'long' com o tempo atual do sistema em mili segundos. Vamos declarar esse tipo no início e ao fim do laço, e depois subtrair esses valores, assim teremos o tempo de execução do programa.
Após imprimir o menor número, o boolean se torna falso, assim só o primeiro número é impresso.

Veja:

public class breakTest {
    public static void main(String[] args) {
        long i = System.currentTimeMillis();
        boolean imprimir = true;
        
        for(int count=1 ; count <=1000000 ; count++){
            if((count % 17 == 0) && (count % 19 == 0))
                if(imprimir){
                    System.out.println(count);
                    imprimir=false;
                }
        }

        System.out.println("Tempo de execução, em milisegundos: "+ (System.currentTimeMillis() -i));
    }

}

Em minha máquina deu:
26 mili segundos


Mas se você quiser ser um bom profissional, não basta só saber resolver. Tem que resolver e da melhor maneira possível.
Note que que o menor número achado é 323, e o laço vai até 1 milhão! Ou seja, ele percorre de 324 até 1 milhão à toa, pois já achou o número desejado!

Ora, se ele já achou o número, 323, vamos fazer com que o laço pare, usando o comando break:

public class break {
    public static void main(String[] args) {
        long i = System.currentTimeMillis();
        
        for(int count=1 ; count <=1000000 ; count++){
            if((count % 17 == 0) && (count % 19 == 0)){
                System.out.println(count);
                break;
            }
        }

        System.out.println("Tempo de execução, em milisegundos: "+ (System.currentTimeMillis() -i));
    }

}

8 mili segundos
Menos de um terço do tempo!

Você pode pensar "Ah, de 26 mili segundos para 8 mili segundos a diferença é insignificante".
Concordo com você.
Porém, no futuro você fará aplicações maiores e que levam mais tempo, e esses pequenos detalhes farão a diferença.
Por exemplo, existem métodos que, durante um game são facilmente chamados milhões de vezes.
Multiplique essa diferença 'insignificante' de alguns mili segundos por milhões de vezes e terá um belo de um 'lag', ou lentidão. Isso se chama otimizar: fazer da maneira mais eficiente possível.

Daremos bastante enfoque para as otimizações em nosso curso de Java, como verá no exemplo a seguir.

O comando continue

Como o nome diz, ele 'continua' o laço. O comando break interrompe o laço, já o continue interrompe somente a iteração atual.

Não basta porém ser um bom profissional. Você está no curso Java Progressivo, você tem que ser um dos melhores!
Nós vamos otimizar o código passado.

Note uma coisa, queremos achar um número que seja múltiplo de 17 e 19. Ora, tal número não pode ser par, pois 17 e 19 são ímpares.
Para cada número 'count', estamos fazendo dois testes: se é múltiplo de 17 e se é múltiplo de 19.

Vamos otimizar da seguinte maneira, vamos fazer um só teste: vamos checar se é múltiplo de 2. Caso seja, nem adianta testar se é múltiplo de 17 e 19, podemos pular essa iteração.
E como pulamos uma iteração? Com o comando continue!

Veja como fica:

public class continueTest {
    public static void main(String[] args) {
        long i = System.currentTimeMillis();
        
        for(int count=1 ; count <=1000000 ; count++){
            if(count % 2 == 0){
                continue;
            }
            if((count % 17 == 0) && (count % 19 == 0)){
                System.out.println(count);
                break;
            }
            
        }

        System.out.println("Tempo de execução, em milisegundos: "+ (System.currentTimeMillis() -i));
    }

}

E temos o impressionante tempo de 1mili segundo!
De 26 mili segundos, fomos para 1 mili segundo! Impressionante esse Java, não?

Laço FOR: tendo um maior controle sobre as repetições

Veremos agora o tipo de laço mais importante e usado em Java, que será sempre visto nos código de nosso curso: o laço for

Sua fama se deve ao poder que temos por conta dos detalhes que o laço for é capaz de receber, sendo possível ter um maior controle sobre as repetições.

• Estudar offline pela apostila Java Progressivo

Diferenças entre o while e o for: para que serve o laço for em Java

Geralmente, o que é possível fazer usando o for, é possível fazer usando o o laço while em Java.
Então, naturalmente vem a pergunta: por que e para que serve, então, o laço for?

É o mesmo que perguntar 'por que usar a++' se podemos usar 'a=a+1'.
Simples: por questão de simplicidade e praticidade.

Nós, programadores Java, devemos procurar sempre a máxima eficiência. Fazer as coisas da maneira mais simples possível.
O uso do for se deve aos seguintes dois fatos, que você deve ter notado, caso tenha feito os exercícios sobre o laço while e caso tenha visto os exemplos do artigo while:
1. Geralmente existe um ponto de partida, um contador inicial para o laço while
2. Geralmente esse contador, ou outro, muda. De modo incrementativo ou decrementativo, até que a condição do while não seja mais satisfeita e o laço termine.

O que o laço for faz é automatizar isso.
Já que na grande maioria das vezes precisaremos desses dois fatores (inicial e de mudança), o laço for irá prover isso.

Como usar o laço for em Java

A sintaxe do laço for é a seguinte:

for(cond inicial; teste condicional ; apos iteraçao){
    //código
}

O laço funciona da seguinte maneira:
O laço se inicia pela condição inicial. Geralmente se inicia o contador. Esse primeiro estágio SEMPRE acontece.

O segundo estágio é o teste da condição do laço, um simples teste condicional. Caso seja verdade, o código é executado.
Ao término de execução do código, ocorre o fator de mudança, que geralmente é um incremento ou decremento, sempre após cada iteração do looping,

Depois a condição é testada novamente. Caso retorne 'true', o código é executado.
Ao término de execução do código, sempre ocorre o fator de mudança...e assim sucessivamente.

Faremos 3 exemplos que mostram bem o exemplo do uso e flexibilidade laço for.
É importante que você aprenda bem, pois eles serão muito usados em nosso curso de Java.

Exemplo 1: Contando até 10, com laço for

public class for1 {
    public static void main(String[] args) {
        for(int count=1 ; count <= 10 ; count++){
            System.out.println(count);
        }
    }

}

Nesse exemplo, fiz questão de mostrar uma importante característica do laço for: a declaração dentro do for
Note que, na condição inicial do contador, foi declarado o inteiro 'count', que foi usado no laço.

Como funciona:
A primeira coisa que acontece é a condição inicial. No nosso caso, é criado um inteiro, 'count' e inicializado com o valor 1.
Depois, a condição é testada. Como ela é verdadeira, ele imprime o valor de 'count', que é 1.

Depois 'count' é incrementada e vira 2.
Depois é testada. Como continua ser menor que 10, ela é imprimida. Depois incrementada, testada, imprimida...ela é imprimida até ser 10, pois depois disso ela será incrementada e 'count' será 11, então a condição não será mais verdadeira e o laço for terminará.

Exemplo 2: contagem regressiva, usando o laço for

public class for2{
    public static void main(String[] args) {
        for(int count=10 ; count >= 1; count--){
            System.out.println(count);
        }
    }
}

Esse exemplo serve para mostrar que podemos usar o decremento, não somente o incremento, dentro do laço for.

Como funciona:
A primeira coisa que acontece é a condição inicial. No nosso caso, é criado um inteiro, 'count' e inicializado com o valor 10.

Depois, a condição é testada. Como 'count' é maior ou igual a 1, é verdadeira e se imprime o valor de 'count', que é 10.
Após essa execução, 'count' se torna 9, e continua a ser maior ou igual a 1, e impressa...quando 'count' for 1, ela será impressa, por 1 é maior ou igual a 1.
Porém, ao ser decrementada, se tornará 0 e o laço for terminará.

Exemplo 3: contagem progressiva e regressiva no mesmo laço for

Outra característica do laço for, é que não precisamos usar só uma variável de controle ('count') ou  testar somente uma condição. O código Java para isso é:

public class for3 {
    public static void main(String[] args) {
        for(int sobe=1, desce=10 ; sobe<=10 && desce>=1; sobe++, desce--){
            System.out.printf("%d \t %d \n", sobe, desce);
        }
    }

}

Como funciona:

Declaramos duas variáveis, a 'sobe', que vai ser incrementada e impressa de 1 até 10,
e a variável 'desce' que será decrementada e impressa de 10 até 1.
Dentro do printf usamos o caractere '\t', que é o código ASCII para a tabulação, ou seja, o nosso famoso 'tab'.

Compile e rode esse simples código, verá como é maravilhoso ser programador Java e sua vida fará mais sentido.

Como colocar um menu de cores: Usando o JColorChooser

Sabe aquelas opções de cores, transparência, tom, brilho etc, que você vê em programas de imagens por aí?

Pois é, bote no seu aplicativo Java também.
Mas calma, é bem simples. Já está tudo pronto, e o nome disso é JColorChooser.

• Download da Apostila Java Progressivo