Programação Java e Loop Iterations

Para fazer laços do seu programa Java mais fácil de escrever e fácil de entender, você precisa saber como Java de pausa

e continuar declarações afetam iterações do loop.

instrução break do Java

Dê uma olhada no programa abaixo. O programa gera aleatoriamente um número de 1 a 10, e repetidamente pede ao utilizador para adivinhar o número.

listagem 1

importação java.lang.System.out-import java.util.Scanner-import classe java.util.Random-public static GuessAgain {static void main (args String []) públicas {Scanner Teclado = new Scanner (System.in) - int numGuesses = 0-int randomNumber = new Random (). nextInt (10) + 1-out.println ( "************") -out.println ( "Bem-vindo ao jogo de adivinhação ") -out.println (" ************ ") -out.println () - out.print (" Enter um int 1-10: ") -int entraNumero = teclado. nextInt () - ++ - numGuesseswhile (entraNumero! = randomNumber) {out.println () - out.println ( "Tente outra vez ...") - out.print ( "Enter um int 1-10:") -inputNumber = keyboard.nextInt () - numGuesses ++ -}out.print ( "Você ganha depois") -out.println (numGuesses + "suposições".) - keyboard.close () -}}

A figura abaixo mostra uma execução do código. O usuário faz cinco palpites. Cada vez, o computador verifica para ver se a suposição é correta. Uma estimativa incorreta gera uma solicitação para tentar novamente. Para um palpite correto, o usuário recebe uma empolgante Você ganha, juntamente com uma contagem do número de tentativas feitas ele ou ela. O computador está repetindo várias declarações repetidas vezes, verificando de cada vez até ver se palpite do usuário é o mesmo que o número gerado aleatoriamente. Cada vez que o usuário faz uma suposição, o computador adiciona 1 à sua contagem de suposições. Quando o usuário faz o palpite correto, o computador exibe a correspondência.

O que é estranho sobre esse programa? Bem, algumas declarações aparecer mais do que uma vez no programa. Normalmente, uma declaração de que é copiado de uma parte de um programa para outro não é motivo para preocupação. Mas, a estratégia global parece suspeito. O programa recebe um número do usuário antes que o loop e (novamente) no interior do loop.

out.print ( "Enter um int 1-10:") -int entraNumero = keyboard.nextInt () -numGuesses ++ -while (entraNumero = randomNumber!) {out.println () - out.println ( "Tente outra vez ...") -out.print ( "Enter um int 1-10:") -entraNumero = keyboard.nextInt () -numGuesses ++ -}

Esse código usa um truque padrão para fazer loops trabalho. É chamado escorvamento uma volta. O padrão é

obter entradaenquanto a entrada que você tem não é a última entrada{ Obter mais entrada}

No início do enquanto loop, o computador verifica uma condição que tem a ver com a entrada do usuário. Assim, o computador não entrar no ciclo até que o usuário dá alguma entrada. Em seguida, quando o computador está dentro do loop, o computador pede mais de entrada para alimentar próxima iteração do loop. O truque parece estranho, mas funciona.

Os desenvolvedores usam essa técnica, priming um loop, o tempo todo, por isso não pode ser tão ruim. Mas há uma outra maneira.

A Lista 2

importação java.lang.System.out-import java.util.Scanner-import classe java.util.Random-public static GuessAgain {static void main (args String []) públicas {Scanner Teclado = new Scanner (System.in) - int entraNumero, numGuesses = 0-int randomNumber = new Random (). nextInt (10) + 1-out.println ( "************") -out.println ( "Welcome to the Jogo de adivinhação ") - out.println (" ************ ") -out.println () -while (true) {out.print ( "Enter um int 1-10:") -inputNumber = keyboard.nextInt () - numGuesses ++ -Se (entraNumero == randomNumber) {pausa-}out.println () - out.println ( "Tente outra vez ...") -}out.print ( "Você ganha depois") -out.println (numGuesses + "suposições".) - keyboard.close () -}}

Do ponto de vista do usuário, o código na Listagem 2 faz exatamente a mesma coisa que o código na Listagem 1. (Para ver a saída de qualquer programa, consulte a figura acima). A diferença é Listagem 2 tem apenas uma chamada para keyboard.nextint. Essa chamada é dentro do loop, por isso, o computador deve entrar no ciclo sem testar qualquer entrada.

Se você olhar para a condição do loop, você pode ver como isso funciona. A condição do laço é sempre verdadeiro. Não importa o que está acontecendo, a condição do circuito sempre passa seu teste. Assim, a condição do laço é uma grande fraude. Você nunca saltar fora do circuito por falhar no teste na condição do loop. Em vez disso, você saltar para fora quando você bate a pausa declaração de que está dentro do loop (e você bater esse pausa indicação quando você passar o if (entraNumero == randomNumber) bloqueio). A coisa toda funciona muito bem.

Quando o computador executa um pausa declaração de que está em um loop, o computador salta para fora do loop (para a primeira instrução que vem após o loop).

Com um pausa declaração, o computador salta para fora de apenas um loop. Se esse ciclo passa a ser dentro de outro loop (um circuito externo) o computador não saltar fora do circuito externo.

BreakOutOfLoop classe pública {public static void main (String [] args) {for (int i = 0- i lt; 3- i ++) {para (int j = 0- J lt; 100- j ++) {System.out.print (j + "") -se (j> 9) {} break-}System.out.println ( "estourou!") -}}}

Para ilustrar, a figura que se segue contém a saída do código anterior:

Quando o computador atinge o pausa declaração, o controlo salta para o Eu eclodiu declaração. que Eu eclodiu declaração é lado de fora do para j laço, mas é dentro a para i loop.

Do ponto de vista de um programador, o código na Listagem 2 é mais natural do que o código na Listagem 1. Afinal, como é que o jogo prossiga? As suposições de usuário, em seguida, o computador verifica a adivinhar, e então (se o palpite não é correto) o computador diz: "Tente de novo." Essa é a sequência de eventos, conforme descrito na Listagem 2. Mas na Listagem 1, o código dentro do loop parece descrever os acontecimentos em ordem inversa: O laço diz: "Tente outra vez", e em seguida, o usuário insere um número.

Listagem 2 oferece uma boa alternativa para a técnica de priming circuito na Listagem 1. Então, por que os programadores se preocupam em privilegiada seus laços? Faz pausa declarações têm quaisquer inconvenientes ocultos? Bem, a resposta depende do seu ponto de vista. Alguns programadores pensam que pausa declarações em loops são confusas. Todos os saltos de instrução para declaração torna tonto e recorda-lhes algo da década de 1960 chamado código espaguete. (usos código espaguete vamos para declarações para saltar de uma declaração para outro. Dentro Pascal pelo Exemplo, autor B. Burd diz # 147 Programação com Goto é como viajar em torno de Paris nadando através do seu sistema de esgoto. Há uma abundância de cortes curtos, mas nenhum deles valem a pena tomar. # 148-) De uma forma ou de outra, pausa declarações em loops são a exceção, não a regra. Use-os se quiser, mas não espere encontrar muitos deles em código Java de outras pessoas.

instrução continue do Java

Listagem 3 oferece mais molho secreto para loops do seu programa. Imagine um jogo que gera aleatoriamente três números de 1 a 20. O usuário tem cinco voltas adivinhar os números. Quando o usuário insere um palpite correto, o programa felicita o usuário. ( "Good palpite", diz o programa.) Quando o usuário insere uma estimativa incorreta, o programa não fornece nenhum feedback.

Listagem 3 contém algum código para fazer tudo isso acontecer.

listagem 3

importação java.lang.System.out-import java.util.Scanner-import classe java.util.Random-public static GuessAgainAndAgain {static void main (args String []) públicas {Scanner Teclado = new Scanner (System.in) - int entraNumero-int randNum1 = new Random (). nextInt (20) + 1-int randNum2 = new Random (). nextInt (20) + 1-int randNum3 = new Random (). nextInt (20) + 1-out. println ( "************") -out.println ( "Bem-vindo ao jogo de adivinhação") - out.println ( "************") -out.println () - para (int i = 0- i lt; 5- i ++) {out.print ( "Enter um int:") -inputNumber = keyboard.nextInt () -Se (entraNumero! = randNum1 entraNumero! = randNum2 entraNumero! = randNum3) { continuar- }out.println ( "Good palpite!") - out.println () - "-out.print (randNum2 +} out.print (" Os números são ") -out.print (randNum1 +") "") Check-out -keyboard.close .print (randNum3 + "") () -}}

Esta figura mostra a execução de um programa desse tipo.

Java de continuar declaração informa ao computador para saltar passado as instruções restantes no interior do loop. Isto é, em vez de executar as instruções restantes dentro do circuito, o computador passa para o início da próxima iteração do ciclo. Assim, na Listagem 3, quando o entraNumero Não é qualquer um dos números gerados aleatoriamente do programa, o computador salta passado o código "bom palpite", incrementa o contador de loop (a variável Eu), E pede ao usuário para um outro valor de entrada. (É claro que, se o contador de ciclo atinge o seu limite, o computador não executar outra iteração. Em vez disso, o computador salta fora do circuito, e executa o que quer que declarações vir após o loop.)

Você pode facilmente reescrever Listagem 3 para que o código não tem continuar declaração. Você teria que colocar o código "Good palpite" dentro de um E se declaração, mas que estaria bem. o continuar declaração não faz muito para melhorar a aparência do programa Listagem 3. Mas quando você quer evitar o código de nidificação dentro E se declarações, o continuar declaração vem a calhar.

Talvez, na sua aplicação, o restante do ciclo é uma seqüência complicada de declarações. Você não quer fazer esta seqüência parece mais complicado, encerrando-o dentro de um E se declaração. Ou talvez, em seu aplicativo, você só raramente ignorar o restante do circuito, e você quer enfatizar esta raridade, não abrangendo o restante do loop em um E se declaração. Em ambos os casos, uma continuar declaração pode ser exatamente a escolha certa.