Comandos de Repetição

Comando for

Os comandos de loop são uma parte importante de todas as linguagens de

programação. Java não é uma exceção. Veremos em outro ponto deste curso que
Java oferece uma poderosa coleção de construções de loop. A mais versátil delas
é o loop for, que apresentaremos resumidamente aqui.. A forma mais simples do
loop for é a seguinte:

for ( inicialização; condição; iteração)

comando;

Geralmente a porção de inicialização ajusta a variável de controle de loop

para um valor inicial. A condição é uma expressão booleana que testa a variável
de controle de loop. Se o resultado for verdadeiro (true), o loop for continuará a ser
executado. Se for falso (false), o loop será encerrado. A expressão de iteração
determina como a variável de controle do loop é alterada cada vez que o loop é
executado. Eis um pequeno programa que ilustra o loop for.

1. import javax.swing.JOptionPane;
2. public class TesteFor
3. {
4. public static void main (String[] args)
5. {
6. JOptionPane.showMessageDialog(null,"i \t " + " i * i \t " + " i * i * i \n" );
7. for (int i=0; i< 10 ; i++)
8. JOptionPane.showMessageDialog(null, i + " \t " + i * i + " \t " + i * i * i +
" \n ");
9. }
10. }

Eis a saída deste programa:

i i* i i * i * i
0 00
1 11
2 48
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
 Neste exemplo, i é a variável de controle do loop. Ela é inicializada com o
valor zero na porção de inicialização de for. No início de cada iteração (inclusive a
primeira), o teste condicional i<10 é executado. Se o resultado do teste for
verdadeiro, o comando showMessageDialog() será executado e, depois, a porção
de iteração do loop será executada. Esse processo continua até que o teste
condicional resulte em false.

Vamos pegar este mesmo exemplo só que desta vez iremos passar o
número como parâmetro e ao invés de incrementar nós iremos decrementar,
então ficaria assim:

1. import javax.swing.JOptionPane;
2. public class TesteFor2
3. {
4. public static void main (String args [ ] )
5. {
6. int num;
7. JOptionPane.showMessageDialog(null, "i \t " + " i * i \t " + " i * i * i \n " ) ;
8. for (int i =num; i > 0 ; i--)
JOptionPane.showMessageDialog(null, i + " \t " + i * i + " \t " + i * i * i + "
\n " ) ;
9. }
10. }

Como já é sabido, a saída dependerá do parâmetro passado se, por exemplo,

nós passarmos como parâmetro o número 5, a saída será a seguinte:

I i*i i*i*i
5 25 125
4 16 64
3 9 27
2 4 8
1 1 1

Outro exemplo do uso do comando for, é visto logo, a seguir, nesse

exemplo o nosso programa calcula a fatorial de um número passado como
parâmetro, veja-o em ação:

1. import javax.swing.JOptionPane;
2. public class Fat
3. {
4. public static void main (String args [ ] )
5. {
6. int num, fatorial=1;
7. num = Integer.parseInt(JOptionPane.showInputDialog("Entre com um
valor para encontrar o fatorial"));
8. for(int i = num; i>=1 ;i--)
9. fatorial*=i;
10. JOptionPane.showMessageDialog(null,"A fatorial do número é: \t"+
fatorial);
11. }
12. }

3.1.1 Comando while

O comando while é um dos comandos de iteração de Java. Os outros são:

ƒ For
ƒ Do-while

Esses comandos criam aquilo que no jargão da programação é conhecido

como loop. Um loop executa repetidas vezes um determinado conjunto de
instruções até que ocorra uma condição previamente estabelecida para o término.
Esses três tipos de Java são capazes de atender a todas as necessidades de
programação.

Examinaremos agora o comando while. Ele repete um comando ou um

bloco de comandos enquanto a expressão de controle for verdadeira. Eis sua
forma geral:

while(condição)
{
/ / Corpo do loop.
} / / Fim do loop while

A condição pode ser qualquer expressão booleana. O corpo do loop será

executado enquanto a expressão condicional representada por condição for
satisfeita. Quando condição se tornar falsa, o controle passa para a próxima linha
de código imediatamente após o loop. As chaves { } são desnecessárias se o que
estiver sendo repetido for apenas um único comando.

Eis um exemplo de simples de loop while:

1. import javax.swing.JOptionPane;
2. public class whiledemo
3. {
4. public static void main (String args [ ] )
5. {
6. int contador=10;
7. while(contador>0)
8. {
9. JOptionPane.showMessageDialog(null,contador+" ! ");
 10. contador--;
11. }
12. JOptionPane.showMessageDialog(null,"Fogo !" );
13. }
14. }

O loop While (linhas 7 a 11) contam de 10 até 0. A cada passagem pelo loop,
um comando usando o método showMessageDialog() exibe na tela o valor da
variável contador (linha 9). A variável é então decrementada (linha 10), o que
garante que o loop chegue a um final, quando a condição contador > 0 (linha 7)
deixar de ser verdadeira. Encerrado o loop, a execução prossegue na linha
seguinte ao final do loop (linha 12), fazendo com que seja exibida na tela a string:
“Fogo !”.

Ao ser executado, este programa exibe a seguinte saída:

10 !
9!
8!
7!
6!
5!
4!
3!
2!
1!
Fogo !

Como o loop while avalia sua expressão condicional no início do loop, o

corpo do loop não será executado nenhuma vez se a condição for inicialmente
falsa. Por exemplo, no fragmento que se segue, a chamada a
showMessageDialog() nunca é executada:

int x=15, y=16;

while(x>y)
JOptionPane.showMessageDialog(null, “Mensagem não exibida”);

3.1.2 O Comando do ... while

Porém em muitas situações é desejável que o corpo do loop seja executado

pelo menos uma vez, mesmo que a condição de controle seja inicialmente falsa.
Em outras palavras, há ocasiões em que a condição de terminação deve ser
testada no final do loop e não no início.
 Para esses casos, Java oferece um loop que faz exatamente isso: do-while.
O loop do-while sempre executa seu corpo pelo menos uma vez, porque a
expressão condicional está no final do loop. Sua forma geral é:

do
{
/ / Corpo do loop.
}while(condição);

Cada iteração do loop do-while executa primeiro o corpo do loop e depois

avalia a expressão condicional representada por condição. Se a expressão for
verdadeira, o loop será repetido. Caso contrário, o loop termina> Como acontece
com todos os loops de Java, a condição deve ser uma expressão booleana. Eis
uma versão revisada do programa WhileDemo.java. Esta versão demonstra o loop
do-while. Ela gera a mesma saída que a versão anterior.

1. import javax.swing.JOptionPane;
2. public class doWhileDemo
3. {
4. public static void main(String args [ ] )
5. {
6. int contador=10;
7. do
8. {
9. JOptionPane.showMessageDialog(null,contador+" ! ");
10. contador--;
11. } while(contador > 0);
12. JOptionPane.showMessageDialog(null,"Fogo!");
13. }
14. }

Eis a saída deste programa:

10 !
9!
8!
7!
6!
5!
4!
3!
2!
1!
Fogo !
 Essa saída mostra que, neste caso, o loop do-while (linhas 7 a 11) tem
exatamente o mesmo efeito que o loop while de WhileDemo.java. Embora esteja
correto, o loop do-while de DoWhileDemo.java poderia ser reescrito de forma mais
eficiente. Eis como isso poderia ser feito:

do
{
JOptionPane.showMessageDialog(null, contador+”!”);
} while (--contador>0);

Aqui, a expressão (--contador)combina o decremento de contador e o teste

do loop em uma única expressão. Primeiro, o comando --contador é executado,
decrementando contador e retornando seu novo valor. Esse novo valor é então
comparado com zero. Se for maior que zero, o loop continuará; caso contrário, ele
será encerrado.