Estrutura de repetição do/while

Transcrição

1 Es truturas de Controle Estrutura de repetição do/while A estrutura de repetição do/while é semelhante à estrutura while. Na estrutura while, o programa testa a condição de continuação do laço no começo do laço, antes de executar seu corpo. A estrutura do/while testa a condição do laço depois de executar o corpo do laço portanto, o corpo do laço sempre é executado pelo menos uma vez. Quando uma estrutura do/while termina, a execução continua com a instrução depois da cláusula while. Não é necessário utilizar chaves na estrutura do/while se houver apenas uma instrução no corpo. A maioria dos programadores inclui as chaves, para evitar confusão entre as estruturas while e do/while. A diferença entre uma declaração while e do/while é que, no laço while, a avaliação da expressão lógica é feita antes de se executarem as instruções nele contidas enquanto que, no laço do/while, primeiro se executam as instruções e depois realiza-se a avaliação da expressão lógica, ou seja, as instruções dentro de um laço do/while são executadas pelo menos uma vez. A declaração do/while possui a seguinte forma: instrução 1; instrução 2;... while (expressão lógica); O fluxograma do/while deixa claro que o programa não avalia a condição de continuação do laço enquanto a ação não for executada pelo menos uma vez. instrução(ões) condição verdadeiro falso Abaixo temos alguns exemplos que usam a declaração do/while: Exemplo 1: int x = 0; System.out.println ( x ); x++; while (x < 10); Exemplo 2: //laço infinito System.out.println( Olá ); while (true); Exemplo 3: //um laço executado uma vez Do System.out.println( Olá ); 1

2 Linguagem de Programação - Java while (false); Exemplo 4: Um applet que utiliza uma estrutura do/while para desenhar 10 círculos aninhados com o método drawoval da classe Graphics. //pacote do núcleo de Java import java.awt.graphics; //pacote de extensão de Java import javax.swing.japplet; //declaração da classe public class TesteDoWhile extends JApplet { //declaração do método paint, que desenha linhas no fundo do applet public void paint (Graphics g) { //chama a versão herdade do método paint super.paint(g); //declara a variável que servirá como contador, iniciando em 1 int cont = 1; //executa a primeira vez //envia a mensagem drawoval para o objeto Graphics g.drawoval(100 - cont * 10, cont * 10, cont * 20, cont * 20); //incremente o contador ++cont; //verifica a condição, se for verdadeira continua executando, caso contrário sai da estrutura do/while while (cont <= 10); No método paint é declarado a variável de controle cont e a inicializa com 1. A estrutura do/while envia a mensagem drawoval para o objeto Graphics ao qual g faz referência. Os quatro argumentos que representam a coordenada x superior esquerda, a coordenada y superior esquerda, a largura e a altura da caixa delimitadora da elipse (um retângulo imaginário na qual a elipse toca o centro de todos os quatro lados do retângulo) são colocados com base no valor da variável de controle cont. O programa desenha primeiro a elipse mais interna. O canto superior esquerdo da caixa delimitadora para cada elipse subsequente move-se para mais perto do canto superior esquerdo do applet. Ao mesmo tempo, a largura e a altura da caixa delimitadora são aumentados, para assegurar que cada nova elipse contenha todas as primeiras elipses. A variável cont é incrementada. O programa avalia o teste de continuação do laço na parte inferior do laço. Declarações de Interrupção Além das instruções de seleção e repetição, o Java fornece instruções para alterar o fluxo de controle. São elas: break, continue e return. Instrução break A instrução break, quando executada em um while, for, do...while ou switch, ocasiona sua saída imediata dessa instrução. A execução continua com a primeira instrução depois da instrução de controle. Utilizações comuns da instrução break são escapar no começo de um loop ou pular o restante de uma instrução switch. 2

3 Es truturas de Controle A declaração break possui duas formas: unlabeled (não identificada) e labeled (identificada). A forma unlabeled encerra a execução de um switch e o fluxo de controle é transferido imediatamente para o final deste. Podemos também utilizar a forma para terminar declarações for, while ou do-while. A forma labeled de uma declaração break encerra o processamento de um laço que é identificado por um label especificado na declaração break. Um label, em linguagem Java, é definido colocando-se um nome seguido de doispontos. Exemplo: demonstração da instrução break em uma estrutura de repetição for. //pacotes de extensao de Java //declaracao da classe public class TesteBreak { //método main inicia a execução do aplicativo em Java //declaração de duas variávies String saida = ""; int contador; //repete 10 vezes for (contador = 1; contador <= 10; contador++){ //se a contagem for igual a 5, termina o laço if (contador == 5) break; //interrompe o laço somente se contador ==5 saida += contador + " "; //fim da estrutura for saida += "\nsai do laço quando contador = " + contador; JOptionPane.showMessageDialog(null, saida); System.exit(0); //termina o aplicativo Quando a estrutura if da estrutura for detecta que o contador é 5, a instrução break é executada. Essa instrução termina a estrutura for e o programa prossegue logo depois do for. No nosso exemplo o corpo do laço é executado completamente apenas quatro vezes. Exemplo: o mesmo programa feito em outra versão. public class TesteBreak2 { public void main (String args[]){ int contador; //variável de controle também utilizada depois que o loop termina contagem: for (contador = 1; contador <= 10; contador++){ //faz o loop 10 vezes if (contador == 5) //se a contagem for 5 break contagem; //termina o loop System.out.printf("%d",contador); //final do for System.out.printf("Sai do loop quando contador = %d\n", contador); //fim do método main //fim da classe TesteBreak2 Instrução continue A instrução continue, quando executada em uma estrutura while, for ou do-while, pula as instruções restantes no corpo do laço e prossegue com a próxima iteração do laço. Nas estruturas while e do-while, o programa avalia o teste de continuação do laço imediatamente depois da instrução continue ser executada. Em estruturas for, a expressão de incremento é executada e depois o programa avalia o teste de continuação do laço. 3

4 Linguagem de Programação - Java A declaração continue tem duas formas: unlabeled e labeled. A forma unlabeled salta as instruções restantes de um laço e avalia novamente a expressão lógica que o controla. A forma labeled interrompe a repetição atual de um laço e salta para a repetição exterior marcada com o label indicado. Exemplo: utilizando a instrução continue em uma estrutura for. //pacotes de extensão de Java //início da classe TesteContinue public class TesteContinue { //inicia a execução do aplicativo em Java /*declaração da variável que exibirá o valor de saída, * exibido na caixa de diálogo*/ String saida = ""; /*declaração for, que repete 10 vezes * a variável i é declarada e inicializada dentro do for * a variável i serve de contador */ for (int i = 1; i <= 10; i++){ //se a contagem for 5, continua com a próxima iteração do laço if (i == 5) continue;/*pula o código restante no laço somente se i for igual a 5 */ saida += i + " "; //fim da estrutura for saida += "\nusou continue para saltar a impressão 5"; JOptionPane.showMessageDialog(null, saida); System.exit(0); //termina o aplicativo //fim do método main //fim da classe TesteContinue O exemplo utiliza a instrução continue em uma estrutura for para pular a instrução de concatenação de strings quando a estrutura if determina que o valor de i é 5. Quando a instrução continue é executada, o controle do programa continua com o incremento da variável de controle na estrutura for. Exemplos de instruções rotuladas break e continue. 1. O programa abaixo demonstra uma instrução rotulada break em uma estrutura aninhada for. O bloco inicia com um rótulo para: O bloco inclui a estrutura aninhada for e a instrução de concatenação de strings. Quando a estrutura if detecta que linha é igual a 5, a instrução break é executada. Essa instrução termina tanto a estrutura for interna quanto a estrutura for externa. O programa prossegue imediatamente para a primeira instrução depois do bloco rotulado. O corpo da estrutura for mais interna é executado completamente apenas quatro vezes. //pacotes de extensão de Java //início da classe TesteBreakrotulado public class TesteBreakRotula //o métdo main inicia a execução do aplicativo Java String saida = ""; //declaração de strings para: { //bloco rotulado //conta 10 linhas for (int linha = 1; linha <= 10; linha++){ //conta 5 colunas for(int coluna = 1; coluna <= 5; coluna++){ //se a linha for igual a 5, pula para o fim do bloco "para" if (linha == 5) 4

5 Es truturas de Controle break para; //pula para o fim do bloco "para" saida += "* "; //fim da estrutura interna for saida +="\n"; //fim da estrutura externa for //a linha seguinte é pulada saida += "\niteração terminada normalmente"; //fim do bloco rotulado JOptionPane.showMessageDialog(null, saida, "Testando break com um rótulo", JOptionPane.INFORMATION_MESSAGE); System.exit(0); //termina o aplicativo //fim do metodo main //fim da classe TesteBreakRotulado 2. O programa abaixo utiliza a instrução rotulada continue em uma estrutura for aninhada para permitir que a execução continue com a próxima iteração da estrutura externa for. A estrutura rotulada for inicia o rótulo proximalinha. Quando a estrutura if da estrutura interna for detecta que coluna é maior que linha, a instrução continue é executada e o controle do programa continua com o incremento da variável de controle do laço externo for. Embora a estrutura for interna conte de 1 a 10, o número de caracteres * enviados para saida em uma linha nunca excede o valor de linha. public class TesteContinueRotula String saida = " "; proximalinha: //rotulo-alvo da instrução continue //conta 5 linhas for (int linha = 1; linha <= 5; linha++){ saida += "\n"; for (int coluna = 1; coluna <= 10; coluna++){ //se a coluna for maior que a linha, inicia proxima linha if (coluna > linha) continue proximalinha; //proxima iteração do laço rotulado saida += "* "; //fim da estrutura interna for //fim da estrutura externa for JOptionPane.showMessageDialog( null,saida,"testando CONTINUE com um rótulo", JOptionPane.INFORMATION_MESSAGE); System.exit(0); //fim do método main //fim da classe TesteContinueRotulado Exercícios 1. Complete: a) JTextArea é um componente GUI que é capaz de exibir muitas de texto. b) O método settext substitui o texto em uma. c) O método adiciona texto ao fim em uma JTextArea. d) A classe oferece constantes que podem ser usadas para personalizar programas para representar valor em dinheiro para outros países. e) A estrutura de repetição testa a condição de continuação do laço no final do laço, de modo que o corpo do laço será executado pelo menos. 5

6 Linguagem de Programação - Java f) A estrutura trata uma série de condições nas quais uma variável ou expressão particular é comparada com valores que ela pode assumir e diferentes ações são tomadas. g) A instrução, quando executada em uma das estruturas de repetição, ou, causa a saída imediata da estrutura. h) A instrução, quando executada em uma das estruturas de repetição, ou, pula qualquer instrução restante no corpo da estrutura e prossegue com o teste para a próxima iteração do laço. i) Para sair de um conjunto aninhado de estruturas, use a instrução rotulada. j) A instrução rotulada, quando executada em uma estrutura de repetição ou, pula as instruções restantes no corpo daquela estrutura e em qualquer quantidade de estruturas de repetição que a incluam e prossegue para a próxima da estrutura de repetição rotulada que a envolve. 2. Responda: a) Descreva os quatro elementos básicos de repetição controlada por contador. b) Compare e contraste as instruções de repetição while e for. c) Explique uma situação em que seria mais adequado utilizar uma instrução do-while do que uma instrução while. d) Compare e contraste as instrução break e continue. 3. Escreva os aplicativos para as situações abaixo: a) O programa deve localizar o menor de vários inteiros. Assuma que o primeiro valor lido especifica o número de valores a serem inseridos pelo usuário. b) Calcule o produto dos inteiros ímpares de 1 a 15 e depois exiba os resultados em uma caixa de diálogo de mensagem. c) Exiba os seguintes padrões separadamente, um embaixo do outro. Utilize loops para gerar os padrões. Todos os asteriscos (*) devem ser impressos por uma única instrução na forma System.out.print( * ); o que faz com que os asteriscos sejam impressos lado a lado. Uma instrução na forma System.out.println(); pode ser utilizada para mover-se para próxima linha. Não devem haver outras instruções de saída no programa. (a) * ** *** **** ***** ****** ******* ******** ********* ********** (b) ********** ********* ******** ******* ****** ***** **** *** ** * d) Escreva um programa que leia cinco número entre 1 e 30. Para cada número que é lido, seu programa deve exibir o mesmo número de asteriscos adjacentes. Por exemplo, se seu programa lê o número 7, ele deve exibir *******. 6