Tratamento das ESTRUTURAS de CONTROLE ATUALIZADO

Prévia do material em texto

______________________________________________________________________________
2.10. Tratamento das Estruturas de Controle 
2.10.1. Exemplo de Aplicação: Usando a Instrução
 if-else no Programa - Applet06
2.10.2. Exemplo de Aplicação: Usando a Instrução
 switch-case no Programa - Applet07
2.10.3. Exemplo de Aplicação: Usando a Instrução
 while no Programa - Applet08
2.10.4. Exemplo de Aplicação: Usando a Instrução
 do-while no Programa - Applet09
2.10.5. Exemplo de Aplicação: Usando a Instrução
 for no Programa - Applet10
2.10.6. Exemplo de Aplicação: O Loop for com
 Incrementos Distintos - Applet11
2.10.7. Exemplo de Aplicação: Controla Loops for 
 Através de Variáveis - Applet12
2.10. Tratamento das Estruturas de Controle 
As instruções para controle da execução de um programa desenvolvido na linguagem Java estão relacionados abaixo: 
if-else
?:
switch-case
whife
do-while
for
break
continue
return
Em lições anteriores, você aprendeu bastante sobre a maneira como Java funciona. Você sabe como digitar e compilar programas, como efetuar entrada e saída de dados simples, como executar operações matemáticas e como efetuar comparações usando ex​pressões lógicas. Mas estas técnicas são meramente os blocos constituintes de um progra​ma. Para utilizar estes blocos de urna maneira útil, temos de compreender como o computador toma decisões.
Nesta lição, você aprenderá sobre corno seus programas podem analisar dados de modo a decidir quais trechos do programa devem ser executados. Até o momento, suas applets executaram as instruções numa ordem estritarnente sequencial, começando com a primeira linha de um método e trabalhando, linha a linha, até o final do método. É chegado o momento de aprender a controlar o fluxo de programa, a ordem na qual as instruções são executadas, de modo que possamos executar ações distintas baseadas nos dados que o programa recebe. As instruções para controle de fluxo de execução de um programa na linguagem de programação orientado a objetos Java, são:
Controlando o Fluxo do Programa
Fluxo do programa é a ordem na qual um programa executa suas instruções. A maior parte dos fluxos de programa é sequencial, o que significa que as instruções são executadas uma a uma na ordem em que aparecem no programa. Entretanto, há coman​dos em Java que fazem com que um programa salte para a frente ou para trás, pulando código de programa naquele momento não necessário. Estes comandos controlam o fluxo do programa. 
Se a idéia dos computadores tomando decisões baseados em dados parece um pou​co estranha, pense na maneira como você toma decisões. Suponha, por exemplo, que voce esteja aguardando uma carta importante. Você vai até sua caixinha de correspondência e olha lá dentro. Baseado naquilo que viu, você toma uma das seguintes decisões: 
Se houver correspondência na caixa postal, você a pega e leva para dentro de casa. 
Se não houver correspondência na caixa, você reclama sobre o sistema postal.
Em ambos os casos, você tomou uma decisão baseado na existência ou não de correspondência. Isto é chamado desvio condicional. Os computadores usam o mesmo método para tomar decisões (exceto pelo fato de nunca reclamarem e não xingarem pelo atraso de sua correspondência). Você verá a palavra if usada freqüentemente em programas de computador. Da mesma maneira que você pode dizer a si mesmo “Se houver correspondência na caixinha, eu a trarei para dentro de casa”, um computador pode usar uma instrução if para decidir qual ação tomar.
2.10.1. Exemplo de Aplicação: Usando Instrução if-else
 no Programa - Applet06
O par de instruções if-else possibilita a execução condicional de enuncia​dos, fazendo com que os enunciados após a instrução if sejam executa​dos desde que a condição testada seja verdadeira. A seguir, exemplo onde a soma das variáveis ocorrerá apenas se o valor da variável x for maior do que o valor da variável y.
 if (x>y)
 x=x+y; /* É executado se teste for verdadeiro. A seguir, executa a primeira declaração 
 ou enunciado após o conjunto de declarações da a instrução if. */
A instrução else é opcional. Os enunciados após a instrução e/se são executados desde que a condição testada seja falsa. A seguir, exemplo onde as variáveis serão somadas se o teste for verdadeiro e serão subtraídas se o teste for falso. 
if (x>y)
 x=x+y; /* É executado se teste for verdadeiro. A seguir executa a primeira declaração 
 após o conjunto de declarações da instrução else. */ 
 else 
 x=x-y; /* É executado se teste for falso. A seguir executa a primeira declaração após 
 o conjunto de declarações da instrução if. */ 
Para executar mais de um enunciado, eles devem ser agrupados por meio de chaves {}. No exemplo abaixo os dois enunciados serão executados se o teste for verdadeiro (ou seja, x for igual a y).
 if (x==y {
 x=a+b;
 x=c-d;
 }
Testes mais complexos podem ser realizados usando-se várias instruções if​-else, conforme o exemplo.
 if (x>y)
 x=x+y; // Transfere o controle para x=x+y+z+w
 else 
 if (x>z)
 x=x+z; // Transfere o controle para x=x+y+z+w
 else
 if (x>w)
 x=x+w; // Transfere o controle para x=x+y+z+w
 x=x+y+z+w;
Descrição do Problema
Desenvolva um programa na linguagem Java que disponibilizada uma caixa de texto, digite uma opção de um menu, a partir de uma mensagem solicitando essa escolha, de acordo com o que segue: Se a opção for 1, modifique a cor de exibição da mensagem “Esta é a cor que você escolheu.” Para vermelho; Se a opção for 2, modifique para azul; Se a opção for 3, modifique para verde; Se a alternativa escolhida estiver fora do domínio (1-3), informe a mensagem “Seleção de menu inválida. Considere a área de exibição da Applet06 a seguir, e para operar o serviço, primeiramente, dê um clique no componente para lhe dar o foco, depois digite a opcão e tecle <Enter>:
Fluxo de Solução do Programa: Algorítmo 
Para facilitar a aprendizagem e o entendimento do funcionamento do programa, desenvolveremos a seguir a fluxo da solução do Programa:
Informe a Java que o programa usa classes do pacote awt
Informe a lava que o programa usa classes do pacote applet
Defina a classe Applet06 como classe herdeira da classe Applet de Java {
 Declare um objeto TextField chamado textFieldl 
 // Para criar objetos, dimensionar, dispor e inicializar a área de exibição 
 Sobregrave o método init() da classe Applet {
 Crie o objeto TextField
 Adicione o objeto textField à area de exibição da applet06
 Inicialize o conteúdo texto do objeto textField com “1 “
 } 
 // Para acessar, modificar, selecionar e exibir dados na applet06
 Sobregrave paint() { 
 Exiba instruções para o usuário na área de exibição da applet06
 Exiba o menu de cores em três linhas
 Obtenha o texto do objeto TextField1
 Converta o texto num inteiro de nome opção
 Selecione uma cor baseada no valor introduzido pelo usuário
 Exiba uma das mensagens na cor apropriada
 } 
 Sobregrave action() {
 Informe a Java para repintar a área de exibição da applet06
 Informe a Java que o método action() finalizou com sucesso
 }
 }
Criando o Programa no Ambiente Jbuilder
import java.awt.*;
import java.applet.*;public class Applet06 extends Applet { 
 TextField OpçãoMENU; 
 public void init() { 
 // Rótulo e componente
 add(new Label("OpçãoMENU"));
 add(OpçãoMENU = new TextField(5)); 
 }
 public void paint(Graphics g) {
 g.drawString("Digite a opção de menu na Caixa de Texto acima.", 20, 50);
 g.drawString("1. Red", 40, 75);
 g.drawString("2. Blue", 40, 95);
 g.drawString("3. Green", 40, 115);
 int opção = Integer.parseInt(OpçãoMENU.getText());
 if (opção == 1)
 g.setColor(Color.red);
 else if (opção == 2)
 g.setColor(Color.blue);
 else if (opção == 3)
 g.setColor(Color.green);
 else g.setColor(Color.black);
 if ((opção >= 1) && (opção <= 3))
 g.drawString("Esta é a cor que você escolheu.", 20, 140);
 else g.drawString("Seleção de menu inválida.", 20, 140);
 }
 public boolean action(Event event, Object arg) {
 repaint();
 return true;
 }
}
Resultado da Execução do seu Applet06
Entendendo o Funcionamento do Programa
Se você acompanhou com atenção o desenvolvimento da Applet05 e fez o exercício de fixação correspondente (MathApplet), já deve saber como a maior parte da Applet6 funciona. Porém, há alguma coisa nova no método paint() que merece atenção especial. Primeiramente, após converter a seleção do menu digitada pelo usuário da forma de texto para inteiro, o programa usa o inteiro numa instrução if para combinar cada seleção de menu com a cor adequada. 
O método setColor() é parte do objeto Graphics; você o chama para estabelecer a cor dos elementos gráficos (texto, por exemplo) que o programa desenha ou exibe na área de trabalho da applet06. O único argumento do método setColor() é a cor a ser configurada. Corno pode ser visto, Java possui um objeto Color que pode ser usado para selecionar cores. Você aprenderá mais a respeito do objeto Color quando estudar “As Bibliotecas de Classes de Java”. Observe que, se a seleção do usuário não for igual a urna seleção do menu, a cor e configura como preta.
Após o programa configurar a cor, uma segunda instrução if determina qual texto deve ser exibido baseado no fato de o usuário ter introduzido uma seleção válida ou não. Se a seleção do usuário for válida, o programa 
exibe a mensagem “Esta é a cor que você escolheu.” na cor selecionada. Caso contrário, o programa exibe a mensagem “Seleção de menu inválida” em preto.
Instrução ?:
O operador condicional ?: substitui as instruções if-else em situações em que se deseja, em função de uma condição, selecionar o valor resultante de uma dentre duas expressões. O operador é colocado à direita de uma expressão condicional e à esquerda de duas expressões separadas por dois pontos (:).
 nome=(espressão_condicional)?espressão_1: espressão_2;
Se a condição testada for verdadeira, será armazenado o valor resultante da expressão_1 na variável à esquerda do operador de atribuição. Se for falsa, será armazenado o valor resultante da expressao_2 na variável à esquerda do operador de atribuição. O exemplo da página a seguir mostra o código equivalente usando-se as instruções if-else.
 if (expressão_condicional)
 nome=espressão_1;
 else
 nome=espressão_2; 
No exemplo seguinte, se o valor da variável x for menor que o valor da variável y, será atribuído a z o valor resultante da soma. Caso contrário, será atribuído a z o valor resultante da subtração.
z=(x<y) ? x+y : x-y;
 2.10.2. Exemplo de Aplicação: Usando Instrução switch
 no Programa - Applet07
As instruções switch-case simplificam o código quando são neces​sários muitos testes. Em vez de serem utilizadas diversas instruções if-else, é usada uma única instrução switch com várias instruções case. 
Estas instruções possibilitam que, de acordo com o valor resultante de uma expressão, seja executado um determinado conjunto de enunciados.
 switch (expressão) {
 case constante_1 : enunciado;
 break;
 case constante_n : enunciado;
 break;
 defauld : enunciado;
 break;
 }
A cada instrução case há uma constante associada, que será compa​rada ao valor resultante da expressão na instrução swttch. O exemplo seguinte testa se o valor resultante da expressão é 10, 20 ou 30. 
Caso o valor da expressão não corresponda aos valores testados, a execu​ção do programa continuará no enunciado seguinte ao bloco associa​do ao switch.
 switch (temperatura+média) {
 Case 10: controlador.AumentarTemp( );
 break; 
 Case 20: controlador.reduzirTemp( );
 break; 
 Case 30: controlador.reduzirTemp( );
 break; 
 }
OBSERVAÇÃO: A instrução break faz com que o switch seja abandonado após a execu​ção dos enunciados associados ao case cuja constante é igual ao valor da expressão testada. A palavra-chave default é opcional e tem por objetivo especificar quais os enunciados que serão executados caso o valor da expressão não corresponda a nenhum dos valores associados às instruções case.
 switch (temperatura+média) {
 Case 10: aumentar.Temp( );
 Break;
 Case 50: reduzir.Temp( ); 
 Break;
 Default: armazenarrRegistro( ); 	 
 }
Descrição do Problema
		Desenvolva um programa na linguagem Java chamado de Applet07 que disponibilizada uma caixa de texto, digita uma opção de um menu, a partir de uma mensagem solicitando essa escolha, de acordo com o que segue: Se a opção for 1, modifique a cor de exibição da mensagem “Esta é a cor que você escolheu.” para vermelho; Se a opção for 2, modifique para azul; Se a opção for 3, modifique para verde; Se a alternativa escolhida estiver fora do domínio (1-3), informe a mensagem “Seleção de menu inválida. Considere a área de exibição do Applet07 a seguir, e para operar o serviço, primeiramente, dê um clique no componente para lhe dar o foco, depois digite a opção e tecle <Enter>:
Você deve ter visto que a instrução switch é semelhante em muitos aspectos à instrução if. De fato, as instruções if e switch podem ser facilmente convertidas entre si. Agora, você vai desenvolver um programa que incorpora o exemplo de menu, mas usando a instrução switch no lugar da instrução if.
Fluxo de Solução do Programa
Como a Applet07 é semelhante a Applet06, vamos suprimir o item Fluxo de Solução do Programa. Apenas alertando para que você substitua o trecho referente à instrução if por outro trecho referente à instrução switch. 
Criando o Programa no Ambiente JBuilder
import java.awt.*;
import java.applet.*;
public class Applet07 extends Applet {
 TextField OpçãoMENU;
 public void init() { 
 // Rótulo e componente
 add(new Label("OpçãoMENU"));
 add(OpçãoMENU = new TextField(5)); 
 }
 public void paint(Graphics g) {
 g.drawString("Digite a opção de menu na Caixa de Texto acima.", 20, 50);
 g.drawString("1. Red", 40,75); 
 g.drawString("2. Blue", 40, 95);
 g.drawString("3. Green", 40, 115); 
 int opção = Integer.parseInt(OpçãoMENU.getText());
 switch(opção) {
 case 1:
 g.setColor(Color.red);
 break;
 case 2:
 g.setColor(Color.blue);
 break;
 case 3:
 g.setColor(Color.green);
 break;
 default:
 g.setColor(Color.black);
 } 
 if ((opção >= 1) && (opção <= 3))
 g.drawString("Esta é a cor que você escolheu.", 20, 140);
 else g.drawString("Seleção de menu inválida.", 20, 140);
 }
 public boolean action(Event event, Object arg) {
 repaint(); 
 return true;
 }
}
Entendendo o Funcionamento do Programa
Ao rodar este programa, você verá a mesma tela que aquela vista na Applet06. Na realidade, do ponto de vista do usuário, o programa funciona exatamente da mesma maneira que na versão anterior. As diferenças são totalmente internas.
Controles de Repetição 
Pode-se executar enunciados repetidamente em um programa desenvolvido na linguagem java, sob o controle das instruções: while, do-while e for. Um computador executa operações repetitivas especialmente bem. Ele nunca fica aborrecido e pode executar urna mesma tarefa pela milionésima vez tão bem como fez a primeira. Considere, por exemplo, um arquivo em disco contendo 10.000 nomes e ende​reços. Se você tentasse digitar etiquetas para toda essa gente, estaria vendo estrelinhas em pouco tempo. Por outro lado, urna impressora (com a ajuda de um computador) pode imprimir sem cansar as 10.000 etiquetas, sem nenhum problema.
Qualquer linguagem de prograrnação precisa ter alguma forma de comando loop para instruir o computador a executar tarefas repetitivas. Java possui três tipos de Loops: while, do-while e for. Nesta lição, você aprenderá dois primeiros tipos tipos de Loop. Na próxima, falaremos do loop for.
 Em programas de computador, looping é o processo de executar 
 repetidamente um bloco de instruções. Começando-se pelo topo do 
 bloco, as instruções são executadas até o programa atingir o final do 
 bloco, em cujo ponto o programa retoma p/o topo e começa tudo de
 novo. As instruções no bloco podem ser repetidas quantas vezes
 quisermos, desde nenhuma até um número infinito. Se um loop 
 prosseguir indefinidamente, ele é chamado de loop infinito.
No decorrer desta lição, você vai aprender sobre os loops, que formam urna importante parte da linguagem lava. Java também suporta outro tipo de Loop, chamado for, que permite a especificação exata do número de vezes que o Loop deve ser executado. Nesta lição você também aprenderá a escrever loops for e a incorporá-los em seus programas Java.
2.10.3. Exemplo de Aplicação: A Instrução while
 no Programa – Applet08
A instrução while possibilita a execução repetida de um conjunto de enunciados enquanto uma condição for verdadeira. A sintaxe é a seguinte:
 while (condição) {
 enunciado_1;
 ...
 enunciado_n;
 } 
Antes da execução dos enunciados, a condição é avaliada. Se for verdadeira, os enunciados são executados; senão, o fluxo é desviado para a instrução seguinte ao bloco associado ao while. Ao final de cada execução do bloco, a condição é novamente avaliada. Este processo continua até que a condição seja falsa. A seguir, exemplo onde os enunciados são executados enquanto x for maior do y.
 while (x>y) {
 x=x+w;
 z=b+f;
 }
Eis um novo exemplo simples de loop while:
num = 1;
while (num < 10) {
 instrução 1;
 instrução 2
 instrução n
}
Observe como neste exemplo, o programa primeiramente configurou a variável de controle (num) para 1. Inicializar a variável de controle antes de entrar no loop é extremamente importante. Se não inicializarmos a variável, não saberemos o que ela pode conter e, consequentemente, o resultado de um loop é imprevisível. No exemplo acima, se por acaso num fosse maior do que 10, o loop nem chagaria a ser executado. Em vez disso, a expressão de controle do loop seria imediatamente avaliada como false e o programa desviaria para a instrução após as chaves. Erros como este você deve evitar.
 O núcleo de um loop compreende as linhas de programa que são
 executadas quando a expressão de controle do loop for verdadeira.
 Usualmente, o núcleo de um loop é envolto entre chaves, criando
 um bloco de programa.
 
Sempre inicialize (estabeleça o valor inicial de) qualquer variável usada numa expressão de controle de um loop while. Não obedecer a esta regra pode fazer com que seu programa pule o loop inteiramente. lnicializar uma variável significa configurá-la para seu valor inicial. Caso você precise de que uma variável comece num valor específico, terá de faze-lo por conta própria. Certifique-se também de incrementar ou decrementar a variável de controle conforme a necessidade no núcleo de um loop. Não obedecer a esta regra poderia resultar num loop infinito, que é o caso quando o loop condicional nunca chega a um resultado verdadeiro, fazendo com que o loop execute indefinidamente.
Descrição do Problema
Como acontece com a maioria das coisas na vida, a melhor forma de aprender é praticar. Assim, desenvolva um programa na lingaugem Java que a partir do recebimento dos valores inicial e final do índice de controle de um loop while, cria sua tela informando esses mesmos índices fornecidos, de acordo com a área de exibição da Applet08 a seguir:
Fluxo de Solução do Programa
Para facilitar a aprendizagem e o entendimento do funcionamento do programa, desenvolveremos a seguir o Fluxo de Solução do Programa: 
Informe a Java que o programa usa classes do pacote awt
Informe a Java que o programa usa class
..es do pacote applet
Defina a classe Applet08 como classe herdeira da classe Applet de Java {
 Declare objetos TextField chamados textField1 e textField2.
 Sobregrave o método init() da classe Applet p/dispor e inicializar a área de exibição {
 Crie os dois objetos TextField chamados textField1 e textField2
 Acrescente os dois objetos TextFleld à Applet08
 Inicialize os objetos TextField para “1” e 10’ 
 }
Sobregrave o método paint() da classe Applet p/acess/modif/selec. e exibir dados { 
 Imprima uma mensagem ou prompt para o usuário
 Obtenha o número do primeiro objeto TextField
 Converta o número de texto para inteiro em start
 Obtenha o texto do Segundo objeto TextField
 Converta o número de texto para inteiro em end
 Inicialize o contador de linhas row
 Inicialize a variável de controle do loop, count com o valor inicial startLoop ou repita desde o valor inicial até o valor final {
 Inicialize a string s com “Count = “
 Adicione o contador do loop à string de texto
 Desenhe a string de texto na superfície da Applet08
 Incremente o contador de linhas row
 }
 Sobregrave o método action() da classe Applet {
 Instrua Java a repintar a área de exibição da Applet08
 Informe a Java que o método action() finalizou com sucesso
 }
}
Criando o Programa no Ambiente JBuilder
import java.awt.*;
import java.applet.*;
public class Applet08 extends Applet {
 TextField limiteInicial;
 TextField limiteFinal;
 public void init() {
 this.setSize(400, 300); //(largura, altura) 
 // Rótulos, componentes e inicialização 
 add(new Label("Limite INICIAL"));
 add(limiteInicial = new TextField(5)); 
 limiteInicial.setText("1");
 add(new Label("Limite FINAL"));
 add(limiteFinal = new TextField(5)); 
 limiteFinal.setText("10"); 
 }
 public void paint(Graphics g) {
 g.drawString("Entre c/os valores inicial e final do controle.", 50, 45);
 String l = limiteInicial.getText();
 int start = Integer.parseInt(l);
 l = limiteFinal.getText();
 int end = Integer.parseInt(l);
 int row = 0;
 int count = start;
 while (count <= end) {
 l = "Count = ";
 l += String.valueOf(count++); // s=s+count (operador composto) e count=count+1 
 // acontece a soma após a execução
 // (operador pós-fixado)
 g.drawString(l, 80, row*15+60);
 row++; // row=row +1
 }
 }
 public boolean action(Event event, Object arg) {
 repaint();
 return true;
 }
}
Resultado da Execução do programa Applet08
Entendendo o Funcionamento do Programa
Ao rodar a Applet08, digite o valor inicial para o loop na primeira caixa e o valor final na segunda caixa. Não pressione <Enter> antes de ter introduzido ambos os valores. Assim que os tiver introduzido, o loop while do programa roda para os valores selecionados, imprimindo a variável de controle de loop cada vez que passar pelo loop. Por exemplo, na definição do problema, o loop while faz a contagem de 1 a 10 (os valores padrão para os componentes TextField). Entretanto, é possível digitar qualquer número desejado. Caso você tenha digitado 15 na primeira caixa e 30 na última, o loop while fará a contagem de 15 a 30, como mostrado na figura da execução do programa. Se você introduzir um par de números dentro de uma faixa muito ampla, a saída ultrapassará os limites da applet08. Isto não causará nenhum tipo de problema, porém não será possível ver a saída inteira. Além disso, se você usar um valor inicial maior do que o valor final, não será gerada nenhuma saída na área de exibição da applet. Isto porque a expressão condicional do loop while nunca será avaliada como verdadeira.
2.10.4. Exemplo de Aplicação: A Instrução do-while
 no Programa – Applet09
As instruções do-while possibilitam que os enunciados sejam executados enquanto a condição for verdadeira. A diferença entre as instruções while e a do-while resume-se ao fato de que, enquanto a instrução while testa a condição antes da execução dos enunciados, o do-while só testa a condição depois da execução. O do-while é menos genérico do que o while, sendo interessante quando os enunciados precisam ser executados pelo menos uma vez. A sintaxe é descrita a seguir:
 do {
 enunciado_1;
 ...
 enunciado_n;
 } while (condição);
Descrição do Problema
É chegado o momento de colocar seu conhecimento de loops do-while em prática. Se você ainda não pegou o jeito da coisa, talvez se surpreenda em descobrir que a Applet09 se parece e age como a applet08. Na realidade, no que diz respeito ao usuário, elas são quase exatamente o mesmo progra​ma. Entretanto, os inteligentes já devem ter adivinhado que Applet09 usa um loop do-​while em substituição a um loop while. Isto significa que, independentemente dos valores introduzidos pelo usuário nos componentes TextField da applet09, ela exibirá pelo menos uma linha de texto. Assim, desenvolva o programa na linguagem Java, Applet09 que usa um loop do-while para criar sua tela, imprimindo os índices inicial e final do controle como acontece na Applet08. Entretanto, se o valor inicial do índice for maior do que o valor final, neste caso, o programa Applet09 imprime apenas o primeiro índice de controle, de acordo a área de exibição mostrada a seguir: 
Fluxo de Solução do Programa
Para facilitar a aprendizagem e o entendimento do programa, vamos desenvolver apenas o trecho do-while (correspondente ao método paint()) do fluxo de solução do programa, considerando que a Applet09 é muito semelhante a Applet08. 
Sobregrave o método paint() da classe Applet p/acess/modif/selec. e exibir dados { 
 Imprima uma mensagem ou prompt para o usuário
 Obtenha o número do primeiro objeto TextField
 Converta o número de texto para inteiro em start
 Obtenha o texto do Segundo objeto TextField
 Converta o número de texto para inteiro em end
 Inicialize o contador de linhas row
 Inicialize a variável de controle do loop, count com o valor inicial start
 Faça a execução das instruções {
 Inicialize a string s com “Count = “
 Adicione o contador do loop à string de texto
 Desenhe a string de texto na superfície da Applet08
 Incremente o contador de linhas row
 }
 Repita para valor inicial <= valor final
 }
Criando o Programa no Ambiente JBuilder
import java.awt.*;
import java.applet.*;
public class Applet09 extends Applet {
 TextField textField1;
 TextField textField2;
 public void init() {
 this.setSize(400, 300); // (largura, altura)
 textField1 = new TextField(5);
 textField2 = new TextField(5);
 add(textField1);
 add(textField2);
 textField1.setText("1");
 textField2.setText("10");
 }
 public void paint(Graphics g) {
 g.drawString("Entre c/os valores inicial e final do controle.", 50, 45);
 String s = textField1.getText();
 int start = Integer.parseInt(s);
 s = textField2.getText();
 int end = Integer.parseInt(s);
 int row = 0;
 int count = start;
 do {
 s = "Count = ";
 s += String.valueOf(count++); // count=cout+1
 g.drawString(s, 80, row * 15 + 70);row++; // row = row + 1;
 }
 while (count <= end);
 }
 public boolean action(Event event, Object arg) {
 repaint();
 return true;
 } 
}
Resultado da Execução do programa Applet09
Entendendo o Funcionamento do Programa
Enquanto o usuário introduzir um valor menor na primeira caixa e um maior na segunda, a applet Applet09 se comportará exatamente do mesmo modo que a Àpple08. Entretanto, a diferença surge quando o valor inicial for maior do que o valor final. 
A Applet08 não produz na realidade nenhuma saída de texto sob estas condições, pois o loop while avalia a condição antes de executar o núcleo do loop. Como é exemplificado na segunda figura da página anterior (para a execução do programa), a Applet09 sempre exibe pelo menos uma linha de saída de texto, pois o loop é avaliado após o núcleo ser executado e não antes. Na figura, o usuário havia introduzido um valor inicial maior do que o valor final.
Através da utilização de loops, é possível programar applets facilmente para executar operações repetitivas. Embora os loops possam parecer um tanto estranhos neste momen​to, você descobrirá usos e mais usos para eles à medida que for escrevendo suas próprias applets. Lembre-se apenas de que um loop while pode ser executado ou não dependen​do do funcionamento das expressões condicionais. 
Por outro lado, um loop do-while sempre executa ao menos uma vez, pois sua condição é avaliada no final do loop e não no início. Na próximo lição, você aprenderá um último tipo de loop chamado for. Como será visto, um loop for é usado quando se sabe exatamente quantas vezes um loop deve ser executado.
2.10.5. Exemplo de Aplicação: A Instrução for
 no Programa – Applet10
Outra forma de controlar a execução repetidas de enunciados é usando a instrução for. Esta instrução é usada quando se deseja que os enunciados sejam executados uma quantidade específica de vezes. A instrução contém três expressões separadas por ponto-e-vírgula. A primeira inicializa uma variável usada para controle de repetição; a segunda é um teste que determina se a repetição continuará; a última é usada para alterar o valor da variável usada para controle da repetição. A seguir, a sintaxe da instrução for: 
 for (expressão_1; expressão_2; expressão_3) {
 enunciado_1;
 ...
 enunciado_n;
 } 
O valor da variável que controla a repetição varia dentro de uma faixa de valores. A vantagem da instrução for em relação a instrução while é que a instrução for mantém centralizado o controle da repetição, resultando em um código mais claro. A seguir, código equivalente a instrução for, usando while:
 espressão_1;
 while (expressão_2) {
 enunciado-1;
 ...
 enunciado_n;
 expressão_3;
 } 
No exemplo a seguir, os enunciados serão executados enquanto o valor da variável n for menor do que 5. A variável é inicializada com o valor 0 e cada repetição é incrementada. 
 for (n=0; n<5; n++) {
 x=y+z;
 b=c-d;
 } 
As expressões presentes na instrução for podem ser sempre omitidas, desde que sejam mantidos os caracteres ponto-e-vírgula (;). Por exemplo, se o bloco de enunciados deve ser sempre executado, usa-se o seguinte código. 
for (;;) {
 enunciado_1;
 ...
 enunciado_n;
}
O código demonstrado anteriormente é útil, por exemplo, em programas servidores, onde várias atividades são realizadas pelos enunciados pelo for, tais como:
Aguardar solicitação de serviço;
Executar serviço;
Enviar resposta para quem solicitou serviço;
Voltar a aguardar uma nova solicitação de serviço.
Provavelmente, o loop mais freqüentemente usado em programação seja o loop for, que instrui um programa a executar um bloco de código um número especificado de vezes. Há muitas aplicações para um loop for, incluindo-se operações como fazer a leitura dos itens de uma lista ou inicializar urna array (matriz). (Você aprendeu sobre arrays no Item 4.6. Tratamento de Arrays). Você poderia, por exemplo, usar um loop for para instruir seu computador a imprimir 10.000 etiquetas de endereço lendo um novo endereço de um arquivo cada vez que passar pelo loop e enviando este endereço à impressora. Entretanto, pelo fato de você não ter atualmente um arquivo de endereços, digamos que você queira imprimir dez vezes um nome na tela. No exemplo a seguir mostramos uma maneira de fazer isto.
Descrição do Problema
A melhor maneira de aprender qualquer construção programática é usá-la num programa. Portanto, desenvolva o programa Applet10 na linguagem Java, que usa um loop for para exibir 10 vezes, um dado nome digitado pelo usuário, de acordo com as especificações da área de exibição a seguir:
Fluxo de Solução do Programa
Para facilitar a aprendizagem e o entendimento do funcionamento do programa, desenvolveremos o fluxo de solução do programa, a seguir:
Informe a Java que o programa usa classes do pacote awt
Informe a Java que o programa usa classes do pacote applet
Defina a classe Applet10 como classe herdeira da classe Applet de Java {
 Declare objetos TextField chamado textField1 
 Sobregrave o método init() da classe Applet p/dispor e inicializar a área de exibição {
 Crie o objeto TextField chamado textField1
 Adicione o objeto TextFleld à Applet10
 Inicialize o objeto TextField para “XXX-----------------------XXX” 
 }
 Sobregrave o método paint() da classe Applet p/acess/modif/selec. e exibir dados { 
 Imprima uma mensagem ou prompt para o usuário
 Obtenha o nome do objeto TextField
 Loop ou repita por dez vezes
 Desenhe a string de texto na superfície da Applet10
 }
 Sobregrave o método action() da classe Applet {
 Instrua Java a repintar a área de exibição da Applet10
 Informe a Java que o método action() finalizou com sucesso
 }
}
Criando o Programa no Ambiente Jbuilder
import java.awt.*;
import java.applet.*;
public class Applet10 extends Applet {
 TextField nome;
 public void init() {
 this.setSize(300, 250); // (largura, altura)
 add(new Label("Nome:")); 
 add(nome = new TextField(20));
 }
 public void paint(Graphics g) {
 g.drawString("Entre com um nome ACIMA.", 70, 45);
 String n ="Índice FOR = ";
 for (int x=0; x<10; x++) // x++ equivale (x=x+1)
 g.drawString(n+nome.getText(), 80, x*15 + 70);
 }
 public boolean action(Event event, Object arg) {
 repaint();
 return true;
 }
}
Resultado da Execução do programa Applet10
Entendendo o Funcionamento do Programa
Na Applet10 observe que o contador x do loop funciona neste programa. Embora o loop for execute 10 vezes, o maior valor armazenado em x será 9. Este é o motivo para o contador do loop iniciar em 0 e contar 0, 1, 2, 3, 4, 3, 6, 7, 8 e 9. 
Talvez inicialmente você esperasse que x acabasse terminando com o valor 10. Atenção para este tipo de coisa nos seus programas Java, especialmente se voce usa o valor para o contador do loop dentro do núcleo loop ou em algum outro lugar do programa. 
A Applet10 usa o contador do loop para determinar a linha na qual o próximo nome será impresso. Tenha em mente que, pelo fato de x ser declarado como parte do bloco de programa do loop for, ele não pode ser acessado de fora deste bloco.
import java.awt.*;
import java.applet.*;public class Applet10A extends Applet {
 TextField nome;
 public void init() {
 this.setSize(400, 300); // (largura, altura)
 nome = new TextField(20);
 add(nome);
 //nome.setText("Orlando Pinho");
 }
 public void paint(Graphics g) {
 g.drawString("Entre com um nome ACIMA.", 117, 45);
 for (int x=0; x<8; x++) {// x++ equivale(x=x+1), após execução/Loop 
 g.drawString(nome.getText(), 117, x*15+60);
 g.drawString(String.valueOf(x), 260, x*15+60);
 } 
 }
 public boolean action(Event event, Object arg) {
 repaint();
 return true;
 }
}
2.10.6. Exemplo de Aplicação: O loop for com Incrementos
 Distintos - Applet11
No exemplo anterior de um loop for incrementa o contador do loop de uma unidade. Mas suponha que você queira um loop que conte de 5 até 50, de cinco em cinco. Isto poderia ser útil se você precisasse usar o contador do loop para exibir um valor que precisasse ser incrementado por um número diferente. 
Você pode fazer isto modificando as seções do loop for, como segue: for (x=5; x<=50; x+=5). Este loop não começa a contagem em 1. Em vez disso, a variável do loop começa com um valor de 5. Depois, graças a instrução x+=5, a variável do loop é incrementada de 5 unidades cada vez que passa por ela. 
Consequentemente, x muda de 5 para 10, de 10 para 1 5 e assim por diante até atingir 50, resultando em dez loops. Você também pode usar um loop for para fazer urna contagem regressiva, corno a seguinte: for (x=50; x>=5; x-=5). Observe que na parte de inicialização da instrução for é usado o maior valor. 
Note tambérn que a cláusula de incremento usa um operador de decremento que faz com que a contarem do loop seja decrementada (diminuída) e não incrementada.
Descrição do Problema
Se você estiver um pouco contuso, dê uma olhada no desenvolvimento do programa a seguir chamado de Applet11. Onde o método paint() desta applet contém dois loops for, um que conta em ordem crescente de cinco em cinco e outro com contagem regressiva também de cinco em cinco. 
Faça seu programa para uma variação de 5 a 40. Veja área de exibição Applet11 para uma variação de incremento de 5 para 20 e decremento de 20 para 5:
Fluxo de Solução do Programa
Para facilitar a aprendizagem e o entendimento do funcionamento do programa, desenvolveremos a seguir o fluxo de solução do programa.
Informe a Java que o programa usa classes do pacote awt
Informe a Java que o programa usa classes do pacote applet
Defina a classe Applet11 como classe herdeira da classe Applet de Java {
 Sobregrave o método paint() da classe Applet p/acess/modif/selec. e exibir dados { 
 Imprima uma mensagem ou prompt para o usuário
 Inicialize o contador de linhas row com 2
 Obtenha o nome do objeto TextField
 Inicie o primeiro loop for {
 Crie a string de exibição básica
 Adicione o valor do contador de loops à string de display
 Exiba a string na área de exibição da Applet11
 Incremente o contador de linhas row
 }
 Inicie o segundo loop for {
 Crie a string de exibição básica
 Adicione o valor do contador de loops à string de display
 Exiba a string na área de exibição da Applet11
 Incremente o contador de linhas row
 }
 }
 }
Criando o Programa no Ambiente JBuilder
import java.awt.*;
import java.applet.*;
public class Applet11 extends Applet {
 public void paint(Graphics g) {
 g.drawString("Valores da variável de Controle dos Loops:", 80, 20);
 int row = 3;
 for (int x=5; x<=20; x+=5) { //na instrução x+=5, a variável do loop é incrementada de 5 (x=x+5) qdo. executada.
 String s = "Contador do Loop = ";
 s += String.valueOf(x); // s = s + alguma coisa (concatenação)
 g.drawString(s, 80, row*15+ 5);
 row++; //row=row+1
 }
 for (int x=20; x>=5; x-=5) { 
 String s = "Contador do Loop = "; 
 g.drawString(s += String.valueOf(x), 80, row*15+15);
 row++;
 }
 }
}
Resultado da Execução do Programa Applet11
Entendo o Funcionamento do Programa
Um aspecto mais importante do programa Applet11 é a utilização do método paint() que apresenta dois loops da instrução for, o primeiro conta em ordem crescente de cinco em cinco até 40 e o segundo faz uma contagem regressiva de cinco em cinco, de 40 até 5. Cada vez que o programa passa pelo loop, ele imprime o valor da variável de controle do loop, de modo que você possa ver exatamente o que está acontecendo internamente nos loops de finitos para o programa. 
2.10.7. Exemplo de Aplicação: Controla loops for Através
 de Variáveis - Applet12 
Da mesma forma que você pode substituir variáveis para a maioria dos valores numéricos num programa, também é possível substituir variáveis por literais num loop for. Na realidade, provavelmente você usará variáveis nos limites do loop com tanta frequência, como usa literais, se não mais. Eis um exemplo de como usar variáveis para controlar seus loops for: for (x=início; x<=fim; x+=inc). Neste loop for parcial, a variável de controle do loop x começa com o valor contido na variável início. Cada vez que passar pelo loop, Java incrementa x pelo valor armaze​nado na variável inc. Finalrnente, quando x for maior do que o valor armazenado em fim, o loop termina. Como pode ser visto, usar variáveis com loops for (ou qualquer outro tipo de loop, com este propósito) permite que se escrevam loops que funcionem de maneira distinta conforme será visto no estado do programa a seguir. Portanto, desenvolva o programa Applet12
Descrição do Problema
Para o último applet desta lição, você aplicará tudo sobre loops for. Portanto, desenvolva o Applet12 para testar diferentes valores iniciais, finais e incrementais para o loop for contido no método paint() do applet, de acordo com as especificações da área de exibição com valores de inicial (1), final (6) e incremento de (1):
Criando o Programa no Ambiente NetBeans
import java.awt.*;
import java.applet.*;
public class Applet12 extends Applet {
 TextField textField1; 
 TextField textField2; 
 TextField textField3;
 public void init() {
 this.setSize(400,300);
 textField1 = new TextField(5);
 add(textField1);
 textField1.setText("1");
 textField2 = new TextField(5);
 add(textField2);
 textField2.setText("4"); 
 textField3 = new TextField(5);
 add(textField3); 
 textField3.setText("1");
 } 
 public void paint(Graphics g) {
 g.drawString("Dê partida ao loop, informando ACIMA",50,45);
 g.drawString("valores inicial, final e incremento.",50,60);
 String s = textField1.getText(); 
 int start = Integer.parseInt(s);
 s = textField2.getText();int end = Integer.parseInt(s);
 s = textField3.getText(); 
 int inc = Integer.parseInt(s);
 int x;
 int row = 0;
 for (x=start; x<=end; x+=inc) {
 String s2 = "Contador do Loop = ";
 s2 += String.valueOf(x);
 g.drawString(s2, 50, row*15+85);
 ++row;
 }
 for (x=end; x>=start; x-=inc) {
 String s2 = "Contador do Loop = ";
 s2 += String.valueOf(x);
 g.drawString(s2, 50, row*15+85);
 ++row;
 } 
 } 
 public boolean action(Event event, Object arg) {
 repaint();
 return true;
 }
}	
Resultado da Execução do Programa Applet12
Entendo o Funcionamento do Programa
Introduza o valor inicial para o loop na primeira caixa, a seguir o valor final na Segunda e o de incremento na terceira caixa. Não pressione <Enter> até que tenha preenchido todas as três caixas com os valores desejados. Ao pressionar <Enter>, o método action() entra em ação, instruindo Java a repintar a área de exibição da applet12 usando os novos valores. 
O	loop for é uma versátil estrutura de programação que permite criar loops que rodam a partir de um valor inicial até um valor final. A operação do loop também depende do valor do incremento, que permite usar a variável de controle do loop para fazer contagem progressiva ou regressiva em quantidades especificadas. Como você poderá constatar, os loops for são bastante usados nos programas Java. (Na realidade, eles são uma parte padrão de praticamente todas as linguagens de programação). 
Controles de Desvio
A linguagem Java não contém a instrução goto mas permite desviar o fluxo da execução do programa através das instruções break, continue e return.
Instrução break
A instrução break possibilita que se salte para fora de um bloco controlado pelas instruções switch-case, while, do-while ou for. No exemplo seguinte, quando a condição testada pelo if for verdadeira, o fluxo será desviado para o primeiro enunciado após o bloco controlado pelo while.
while (a>b) {
 a=b+c;
 if (a>100) 
 break;
}
Se existirem vários blocos aninhados, o fluxo de execução será transferido para o bloco mais externo (ou seja, o fluxo de execução é desviado para o primeiro enunciado seguinte ao bloco encerrado pelo break. No exemplo seguinte, quando a condição testada pelo if for verdadeira, o fluxo será desviado para o primeiro enunciado seguinte ao bloco controlado pelo while. Observe que este enunciado está dentro do bloco controlado pelo do-while.
do {
 b=c+d;
 while (e<f) {
 e=g+h;
 if (e>10)
 break;
 }
 k=1-m;
} while (b<100); 
O break também possibilita que se salte para fora de um bloco externo ao bloco no qual se encontra a instrução. Para que isto ocorra, o bloco externo deve ser identificado por um label posicionado na linha anterior ao início do bloco. 
No exemplo anterior, caso se deseje que o salto seja para o primeiro enuncia​do após o bloco controlado pelo do-while, e não para o primeiro enunciado após o bloco controlado pelo while, basta identificar o bloco controlado pelo do-while com um label e informar o nome do label no break.
 bloco_ externo;
 do {
 b=c+d;
 while (e<f) {
 e=g+h;
 if (e>10)
 break bloco_externo;
 }
 k=1-m;
 } while (b<100); 
Instrução continue
A instrução continue também permite que se interrompa a execução de um bloco controlado pelas instruções switch-case, while, do-while ou for. A diferença entre o continue e o break é que o continue desvia o fluxo de execução para o teste que controla o bloco, enquanto o break desvia o fluxo de execução para fora do bloco. Quando a condição testada pelo if for verdadeira, o fluxo de execução se deslocará para a condição testada pelo while.
 while (a>b) {
 a=b+c;
 if (a>100) continue;
 b=b+1;
 }
No caso em que vários blocos estejam aninhados, o fluxo de execução é transferido para o teste que controla o bloco onde se encontra o continue. A instrução continue também permite que se salte para o teste realizado em um bloco externo, desde que este seja identificado por um label. No exemplo seguinte, quando a instrução continue for executada, o fluxo da execução é desviado para o teste no do-while.
 bloco_ externo;
 do {
 b=c+d;
 while (e<f) {
 e=g+h;
 if (e>10)
 continue bloco_externo;
 }
 k=1-m;
 } while (b<100); 
Instrução return
Esta instrução return é usada quando se deseja retornar um valor de um método. Se, após a execução do método, for necessário retornar um valor, deverá ser informado, na declaração do método, o tipo do valor a ser retornado. Quando não for necessário retornar um valor, a instrução return é opcional. No exemplo seguinte, o método utilizado calcularMedia() retorna um valor do tipo float.
 float calcularmedia(float x, float y) {
 return (x+y)/2;
 } 
�PAGE �
�PAGE �86�
Prof. Orlando Pinho de Assis