Dando voltas

Por exemplo, digamos que eu lhe peça para desenhar a seguinte figura:

Um bom começo seria desenhar as linhas horizontais assim:

Uma maneira de desenhar as linhas seria criar um bloco seqüencial de código:

  import java.awt.Graphics;
        public class FirstApplet extends java.applet.Applet
      {
            public void paint(Graphics g)
          {
              int y;
              y = 10;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
              y = y + 25;
              g.drawLine(10, y, 210, y);
          }
      }  

Para alguns programadores iniciantes, a frase "y = y + 25;" pode parecer estranha na primeira vez que a virem, mas o que ela significa é: "Pegue o valor que está na variável y, some 25 e coloque o resultado de volta na variável y." Por exemplo, se y contiver 10 antes da linha ser executada, ele terá 35 imediatamente após a linha ter sido executada.

Não é difícil perceber logo de cara que esse código contém 2 linhas iguais sendo repetidas várias vezes. O que acontece é que, neste caso, a repetição não é tão trabalhosa, mas imagine se você quisesse criar uma tabela com milhares de linhas e colunas. Ia ser muito cansativo escrever o programa usando este método de repetição. A solução para esse problema é um loop, como você pode ver abaixo:

  import java.awt.Graphics;
        public class FirstApplet extends java.applet.Applet
      {
            public void paint(Graphics g)
          {
              int y;
              y = 10;
              while (y <= 210)
              {
                  g.drawLine(10, y, 210, y);
                  y = y + 25;
              }
          }
      }  

Ao executar este programa, vai ver que ele desenha 9 linhas horizontais com 200 pixels de comprimento.

A expressão while é uma expressão de loop na linguagem Java. Ela manda o Java agir da seguinte maneira: na frase em que pode ler while, o Java observa a expressão entre parênteses e pergunta, "O y é menor ou igual a 210?":

• caso a resposta seja positiva, o Java insere o bloco de código colocado entre chaves, "{" e "}". A parte do loop acontece ao final do bloco de código. Quando o Java chega à chave final, volta à frase com o while e faz a mesma pergunta novamente. Pode ser que essa seqüência de loop ocorra várias vezes.
• mas se a resposta for negativa, ele pula o código colocado entre as chaves e segue em frente.

E podemos completar nossa grade adicionando um segundo loop ao programa, veja só:

  import java.awt.Graphics;
        public class FirstApplet extends java.applet.Applet
      {
            public void paint(Graphics g)
          {
              int x, y;
              y = 10;
              while (y <= 210)
              {
                  g.drawLine(10, y, 210, y);
                  y = y + 25;
              }
              x = 10;
              while (x <= 210)
              {
                  g.drawLine(x, 10, x, 210);
                  x = x + 25;
              }
          }
      }  

Acho que você percebeu que a frase while tem 3 partes:

• há um passo de inicialização que define y como 10;
• depois vem um passo de avaliação dentro dos parênteses da frase while;
• e por último, em algum lugar da frase, há um passo de acréscimo, que aumenta o valor de y.

Além disso, o Java também suporta uma outra maneira de fazer a mesma coisa de um jeito mais compacto do que a frase com while. Basta usar o comando for. Se você tiver um comando while, da seguinte forma:

          y = 10;
              while (y <= 210)
              {
                  g.drawLine(10, y, 210, y);
                  y = y + 25;
              }  

          for (y = 10; y <= 210; y = y + 25)
              {
                  g.drawLine(10, y, 210, y);
              }  

Dá para ver que tudo o que esse novo tipo de programa faz é condensar as linhas de inicialização, avaliação e acréscimo em uma só linha. Não passa de uma maneira de reduzir o tamanho do programa que você escreveu.

E já que estamos aqui, lá vão 2 pontos rápidos a respeito dos loops:

• em muitos casos, também seria fácil inicializar y como 210 e subtrair 25 a cada passagem pelo loop. A avaliação iria perguntar: "o y é maior ou igual a 10?" A escolha é só sua, mas o que posso dizer é que a maioria das pessoas acha mais fácil somar do que subtrair. E você, o que acha?
• o passo de acréscimo é muito importante. Um exemplo disso é o seguinte: digamos que você deixou de fora, sem querer, a parte que diz "y = y + 25;" dentro do loop. O que iria acontecer é que o valor de y nunca mudaria (ficando sempre em 10), o que não o deixaria ficar maior do que 210 e o loop continuaria para sempre (ou até que você o parasse, desligando o computador ou fechando a janela). Essa condição é chamada de loop infinito e é um bug bem comum.

Para praticar um pouco o loop, tente escrever programas que desenhem as seguintes figuras:

Para obter mais informações sobre o Java e outras linguagens de programação, confira os links na próxima página.