Testes Condicionais e Laços - Tutorial de Java

Agora que você já estudou e exercitou seus conhecimentos básicos em Java sobre tipos, variáveis, classe Scanner, print, operadores e outros conceitos essenciais para o aprendizado desta linguagem de programação, vamos seguir adiante em nossos estudos.

Nesta seção iremos aprender sobre os testes condicionais (if else e switch case) bem como os loopings ou laços (for, while e do while), que fazem parte de toda linguagem de programação.

Até o momento, nossos programas em Java simplesmente rodavam do começo ao fim, automaticamente e sempre da mesma maneira.

Ao final destes tutoriais de nossa Apostila de Java, você irá aprender a criar programas que terão um fluxo diferente, baseado nas opções e escolhas feitas por um usuário.
Ou seja, se o usuário fornecer um determinado valor, acontece algo. Se ele fornecer outro valor diferente, uma outra coisa poderá ser acionada.

Por exemplo, ao executar uma calculadora, você pode optar por fazer soma, e ela fará.
Caso opte por fazer uma multiplicação, o aplicativo irá fornecer outros resultados.
E caso queira uma divisão, seu programa vai rodar de uma maneira diferente, de modo a operar divisões, tudo de acordo com o que o usuário escolher.

Através dos laços de repetição, ou loopings, iremos ver como executar qualquer tarefa quantas vezes quisermos, de maneira automática e totalmente controlada por você programador, ou pelo usuário.

Com os conceitos destes tutoriais, nossos programas ficarão bem mais funcionais, robustos e interessantes, não só de programar, mas como também de usar.

Tutorial de Java - Testes e Laços

01. if else : Testando e Escolhendo o que vai ser Executado

     1.1 Programa: Diz se você passou direto, ficou de recuperação ou foi reprovado
     1.2 Programa: determina as raízes de uma equação do segundo grau, até as complexas
02. Questões sobre if else

03. Operadores de Incremento (++) e Decremento (--)
04. Operadores de Atribuição: +=, -=, *=, /= e %=
05. Operadores de atribuição e de incremento e decremento - diferenças entre a=++b e a=b++
06. O laço while: o que é, como usar e calculando PA e PG com while
      6.1 Questões usando o laço while
07. Loop infinito, controlando laços e loopings com o while
08. Laço for: tendo um maior controle sobre as repetições
      8.1 Questões usando o laço for
09. O laço do ... while: O laço que sempre acontece...pelo menos uma vez
10. Os comandos break e continue: interrompendo e alterando fluxos e loopings
11. O comando switch: fazendo escolhas em Java
12. Exercícios envolvendo laços
Apostila Caelum resolvida: Capítulo 3, Variáveis, Tipos Primitivos e Controle de Fluxo

O laço do ... while: O laço que sempre acontece...pelo menos uma vez

Veremos nesse artigo mais um importante laço em Java, o laço do...while, que sempre executa o código do laço pelo menos uma vez, independente da condição do while ser true ou false.

Um dos maiores problemas do laço while é que ele só é executado se a condição contida nele for true.
Porém, muitas vezes, em nossos aplicativos Java, não podemos garantir que essa condição será sempre verdadeira ou queremos que o laço seja executado PELO MENOS UMA VEZ, e caso o usuário decida, o laço vai continuar ou não.

Então, o diferencial do laço do while é que ele sempre executa, sempre inicia o laço.

• Apostila de Java em PDF

Como usar o laço DO WHILE em Java

A sintaxe do laço do .. while em Java, é a seguinte

do
{
 //esse código será executado pelo menos uma vez    
} while( condição );

Seu uso é bem simples e intuitivo, visto que o laço while nós já conhecemos.
O 'do' do inglês quer dizer 'faça'.
Ou seja, esse laço nos diz 'faça isso enquanto 'condição' for verdadeira'

Exemplos de uso

Um dos exemplos de uso é para exibir o menu. Ora, o menu tem que ser exibido pelo menos uma vez.
Se depois, você quiser sair, é opção sua.
Mas que ele tem que ser exibido ao menos uma vez, ele tem. E uma boa saída para fazer isso, em Java, é usar o laço do ... while.

No exemplo a seguir, o menu é mostrado.
Para parar de exibir o menu, basta digitar 0, que o boolean irá se tornar 'false' e o laço não mais se repetirá, pois a condição dentro do while será falsa.

Caso a entrada do usuário seja qualquer outro número que não 0, a variável boolean continua 'true', como foi declarada e o laço continuará a rodar (ou seja, o menu continua a ser exibido).

O trecho: System.out.printf("\n\n\n\n\n\n");
É simplesmente para limpar a tela.

Teste para ver:

import java.util.Scanner;

public class DoWhile {
    public static void main(String[] args) {
        boolean continuar=true;
        int opcao;
        Scanner entrada = new Scanner(System.in);
        do
        {
            System.out.println("\t\tMenu de opções do curso Java Progressivo:");
            System.out.println("\t1. Ver o menu");
            System.out.println("\t2. Ler o menu");
            System.out.println("\t3. Repetir o menu");
            System.out.println("\t4. Tudo de novo");
            System.out.println("\t5. Não li, pode repetir?");
            System.out.println("\t0. Sair");
            
            System.out.print("\nInsira sua opção: ");
            opcao = entrada.nextInt();
            
            if(opcao == 0){
                continuar = false;
                System.out.println("Programa finalizado.");
            }
            else{
                System.out.printf("\n\n\n\n\n\n");
            }
            
        } while( continuar );
    }
}

Embora este seja um exemplo simples, ele será a base para vários menus que iremos fazer em nosso Curso de Java.
Por exemplo, como um sistema de cadastro de alunos e um esquema de caixa eletrônico.

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.

Questões usando o laço while

Exercícios sobre o laço WHILE em Java

Usando o laço while, faça as seguintes questões em Java:

0. Programa em Java dos patinhos da Xuxa
Xuxa, a rainha dos baixinhos, criou uma música que tem o segunte formato:

n patinhos foram passear
Além das montanhas
Para brincar
A mamãe gritou: Quá, quá, quá, quáMas só n-1 patinhos voltaram de lá.

Que se repete até nenhum patinho voltar de lá.

Ao final, todos os patinhos voltam:

A mamãe patinha foi procurar
Além das montanhas
Na beira do mar
A mamãe gritou: Quá, quá, quá, quá
E os n patinhos voltaram de lá.

Crie um programa em Java que recebe um inteiro positivo do usuário e exibe a música inteira na tela, onde o inteiro recebido representa o número inicial n de patinhos que foram passear.

1. Programa em Java que mostra os números ímpares
Escreva um aplicativo em Java mostra todos os números ímpares de 1 até 100.

2. Programa em Java que mostra os números pares
Escreva um aplicativo em Java mostra todos os números pares de 1 até 100.

3. Programa em Java que mostra os números pares e ímpares 
Escreva um aplicativo em Java que recebe inteiro e mostra os números pares e ímpares (separados), de 1 até esse inteiro.

4. Programa em Java que calcula a média das notas de uma turma
Escreva um programa que pergunte ao usuário quantos alunos tem na sala dele.
Em seguida, através de um laço while, pede ao usuário para que entre com as notas de todos os alunos da sala, um por vez.

Por fim, o programa mostra a média, aritmética, da turma.

5. Achando o maior número
Achar o maior, menor, média e organizar números ou sequências são os algoritmos mais importantes e estudados em Computação. Em Java não poderia ser diferente.
Em nosso curso, obviamente, também não será diferente.

Escreva um programa em Java que solicita 10 números ao usuário, através de um laço while, e ao final
mostre qual destes números é o maior.

Essa questão está resolvida e comentada em nosso artigo sobre O uso do laço WHILE para descobrir o maior número de uma lista.
6. Achando os dois maiores números

Escreva um programa em Java que solicita 10 números ao usuário, através de um laço while, e ao final
mostre os dois maiores números digitados pelo usuário.

7. Quadrado de asteriscos

Escreva um programa que lê o tamanho do lado de um quadrado e imprime um quadrado daquele tamanho com asteriscos. Seu programa deve funcionar para quadrados com lados de todos os tamanhos entre 1 e 20.
Para lado igual a 5:
*****
*****
*****
*****
*****

8. Quadrado de asteriscos e espaços em branco

Escreva um programa que lê o tamanho do lado de um quadrado e imprime um quadrado daquele tamanho com asteriscos e espaços em branco. Seu programa deve funcionar para quadrados com lados de todos os tamanhos entre 1 e 20.
Para lado igual a 5:
*****
*    *
*    *
*    *
*****

O laço while: o que é, como usar e calculando PA e PG com while

Nos últimos artigos aprendemos vários operadores e atalhos utilizados pelos programadores Java, como ++, +=, *= dentre outros.

Está na hora de colocá-los em ação e aprender um dos comandos mais importantes em qualquer linguagem de programação: os laços

Nesse artigo, explicaremos o que é e como usar o laço while.

• Apostila completa Java Progressivo

Como usar o laço while em Java

While, do inglês 'enquanto' é um laço de repetição.
Cada ciclo de repetição é chamado de iteração.

Sua sintaxe é a seguinte:

while ( condição ){
    códigos
}

Ou seja, enquanto (while) a condição for verdadeira, os códigos entre chaves serão repetidos.
Mas qual a vantagem de ter um código repetido? Isso não parece absurdo?

Bom, quando pensamos em repetido, pensamos em algo estático, mas não isso o que acontece.
É aí que entra os operadores de incremento, decremento, atribuição e outros.

Nas linhas de código, geralmente as coisas vão 'mudando' a condição e à cada iteração a condição é testada.
Se a condição retornar um valor lógico verdadeiro, o código entre chaves é executado.
Caso o valor retornado seja falso, o laço while é então terminado e o programa Java segue normalmente.

Vamos ver um exemplo simples, que mostra os números de 1 até 10.

Contando até 10 em Java, com o laço while

O programa é simples.
Definimos uma variável inteira, 'count'.
Enquanto essa variável for menor que 10, seu valor será imprimido e será incrementado.
Ou seja será, será impresso 1, 2, 3, ..., 9, 10...opa!
Quando chegar em 11, a condição dentro do laço não será mais verdadeira, e o laço terminará!

Teste:

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

}

Fazendo um PA (progressão aritmética) com o laço while, em Java

O programa a seguir mostra os termos 'an' de uma PA, de termo inicial 'inicial' e razão 'razao', até um valor máximo 'valor_max'.
A diferença deste programa para o anterior é que os termos de uma PA crescem através da adição da razão ao termo anterior.

Em programação, poderíamos representar isso assim: an = an + razao
Porém, como vimos alguns operadores em Java, faremos isso: an += razao

Veja o resultado:

public class pa {
    public static void main(String[] args) {
        int inicial=1,
            razao=3,
            an=inicial,
                valor_max=20;
        
        System.out.printf("Elementos da PA, de valor inicial %d e razão %d, menores que %d\n", inicial, razao, valor_max );
        while(an<=valor_max){
            System.out.println(an);
            an += razao;
        }
    }

}

Fazendo um PG (progressão geométrica) com o laço while, em Java

O programa a seguir mostra os termos 'gn' de uma PG, de termo inicial 'inicial' e quociente 'quociente', até um valor máximo 'valor_max'.
Os produtos de uma PG, progressão geométrica, crescem através do produto do termo anterior com o quociente.
Em programação, poderíamos representar isso assim: gn = gn * razao
Porém, como vimos alguns operadores em Java, faremos isso: gn *= razao
Veja o resultado:

public class pg {
    public static void main(String[] args) {
        int inicial=1,
            quociente=2,
            gn=inicial,
            valor_max=32;
        
        System.out.printf("Elementos da PG, de valor inicial %d e razão %d, menores que %d\n", inicial, quociente, valor_max );
        while(gn<=valor_max){
            System.out.println(gn);
            gn *= quociente;
        }
    }

}

Operadores de atribuição e de incremento e decremento: diferenças entre a=++b e a=b++

Já vimos o uso dos operadores de decremento e incremento, em Java.
E também como usar os operadores de atribuição: +=, -=, *=, /= e %=

Porém, devemos tomar alguns cuidados no uso deles, como, por exemplo, na diferença entre a=++b e a=b++

• Java Progressivo em PDF(download da Apostila)

Diferença de a=++b e a=b++ em Java

Você ja estudou e testou que usar isoladamente:
a++ e ++a não surte efeito.

Porém, surte na hora da atribuição.

Vamos lá, ao nosso 'teste hacker':
Seja b=2;
Só olhando e raciocinando, você seria capaz de descobrir quanto seria 'a' em cada caso:
a = b++;
a = ++b;

Explicações
1. a = b++

Mais uma vez, é um atalho em Java, uma forma mais simples de escrever as seguintes linhas:
a = b;
b++;

2. a = ++b

Analogamente, é o atalho que os programadores Java usam para representar as seguintes linhas de código:
++b;
a = b;

'Tenho que decorar todos esses atalhos em Java, então? Maldito Java!'

Não. Você é programador, você não decora, você pensa.
Não foi à toa que coloquei o 'teste hacker', foi pra aguçar seu raciocínio.

Em ambos os casos, 'b' é incrementado. A diferença é que 'a' recebe o valor de 'b' antes do incremento em um e depois do incremento em outro.
Como eu disse, em Java, você pode descobrir apenas olhando e pensando um pouco.
Veja:

No primeiro exemplo: a = b++
Qual a ordem, 'b' ou incremento? Primeiro o 'b'. Depois o de incremento ocorre, '++'.
Ou seja, 'a' vai receber o valor de 'b' primeiro, então a=2
Só depois que 'b' vai ser incrementado e vai se tornar b=3.

No segundo exemplo: a = ++b
Qual a ordem: 'b' ou incremento?
Primeiro o incremento, '++', depois que aparece o 'b', então só depois acontece a atribuição..
Assim, primeiro ocorre o incremente, então b=3.
Só depois é que esse valor é atribuído para a.

Como diz a bíblia do programador Java: compilais e verás a verdade.
Eis o código:

public class Increment {
    public static void main(String[] args) {
        int a,
            b=1;
        
        System.out.println("b = " + b);
        System.out.println("a = b++ ");
        a = b++;
        System.out.println("Então: a = " + a);
        System.out.println();
        
        System.out.println("b = " + b);
        System.out.println("a = ++b ");
        a = ++b;
        System.out.println("Então: a = " + a);
    }
}