Programação e loop iterações java

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 = Random (). nextInt (10) + 1-out.println (" ************ ") -out.println ("Bem-vindo ao jogo de adivinhação") -out.println (" ************ ") -out.println () - out.print ("Insira um int de 1 a 10: ") -int entraNumero = keyboard.nextInt () - numGuesses ++ -while (entraNumero! = randomNumber) {out.println () - out.println ("Tente novamente...") -out.print ("Insira um int de 1 a 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 suposições que ele ou ela fez. O computador está repetindo várias declarações repetidas vezes, verificando cada vez através de para 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 que registro.

O que é estranho sobre esse programa? Bem, algumas declarações aparecem mais de 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 a partir do utilizador antes de o loop e (novamente) no interior do laço.

Video: Me Salva! ALP09 - Algoritmos com Iteração - comando "while"

out.print ("Insira um int de 1 a 10: ") -int entraNumero = keyboard.nextInt () -numGuesses ++ -while (entraNumero = randomNumber!) {out.println () - out.println ("Tente novamente...") -out.print ("Insira um int de 1 a 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 a condição de ter a ver com a entrada do usuário. Assim, o computador não entrar no ciclo até que o usuário dá alguma entrada. Então, quando o computador está dentro do loop, o computador pede mais 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.

Listagem 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 = Random (). nextInt (10) + 1-out.println (" ************ ") -out.println ("Bem-vindo ao jogo de adivinhação") -out.println (" ************ ") -out.println () -while (true) {out.print ("Insira um int de 1 a 10: "-inputNumber) = keyboard.nextInt () - numGuesses ++ -if (entraNumero == randomNumber) {pausa-}out.println () - out.println ("Tente novamente...") -}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, para que o computador deve entrar no ciclo sem testar qualquer entrada.

Video: 43 - Certificação Java (Usando loop do tipo for)

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 se (entraNumero == randomNumber) obstáculo). 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).

Video: Programação em Python - 08 - Laços e Iterações

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 loop externa) o computador não saltar fora do loop externo.

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

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 controle passa para o Eu eclodiu declaração. que Eu eclodiu declaração é lado de fora do para j laço, mas é dentro a para i ciclo.

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 depois (se a suposição não é correta) o computador diz: “Tente de novo.” Essa é a seqüência de eventos conforme descrito na Listagem 2. Mas na Listagem 1, o código dentro do circuito parece descrever os acontecimentos em ordem inversa: o laço diz “Tente novamente”, 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 preocupar para preparar 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 declaração para declaração torna tonto e os lembra de algo da década de 1960 chamado código espaguete. (usos código espaguete vamos para declarações de saltar de uma declaração para outro. Dentro Pascal por Exemplo, autor B. Burd diz “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.”) De uma forma ou de outra, pausa declarações em loops são a exceção, não a regra. Usá-los 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 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 = Random (). nextInt (20) + 1-int randNum2 = Random (). nextInt (20) + 1-int randNum3 = 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 ("Insira um int: ") -inputNumber = keyboard.nextInt () -if (entraNumero! = randNum1 && entraNumero! = randNum2 &&entraNumero! = randNum3) { continuar- }out.println ("Bom palpite!") -out.println () -} out.print ("Os números são ") -out.print (+ randNum1 " ") -out.print (+ randNum2 " ") -out.print (+ randNum3 " ") -keyboard.close () -}}

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. Ou seja, em vez de executar as instruções restantes no interior do loop, o computador se move para o início da próxima iteração do loop. 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 utilizador para outro valor de entrada. (É claro que, se o contador de loop 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, em sua aplicação, o restante do loop é uma complicada seqüência 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 loop, e você quer enfatizar isso raridade, não abrangendo o restante do circuito em uma E se declaração. Em ambos os casos, uma continuar declaração pode ser exatamente a escolha certa.