1. Estrutura circular
Uma instrução LOOP pode executar repetidamente uma certa parte do código quando a condição do loop é atendida. Este código repetido é chamado de declaração de corpo em loop. Quando esse corpo de loop é executado repetidamente, a condição de julgamento de loop precisa ser modificada para falsa no momento apropriado para encerrar o loop; caso contrário, o loop continuará a executar, formando um loop morto.
Composição das declarações de loop:
Declaração de inicialização: uma ou mais declarações, essas declarações concluem algumas operações de inicialização.
Declaração Decisão Condicional: Esta é uma expressão booleana, que pode determinar se deve executar o corpo do loop.
Declaração do corpo de loop: Esta parte é uma declaração de corpo de loop, que é o que temos que fazer muitas vezes.
Declaração da condição de controle: Esta parte é executada antes que a próxima condição de julgamento do ciclo seja executada após o final do corpo do ciclo. Ao controlar as variáveis na condição do loop, o loop termina no momento apropriado.
por exemplo: quando "helloworld" é produzido 10 vezes no console,
Declaração de inicialização: Defina a inicialização como a primeira vez.
Declaração condicional do julgamento: O número de vezes não pode exceder 10 vezes.
Declaração do corpo do loop: emitir a declaração "helloworld".
Declaração de condição de controle: o número de vezes muda para a próxima vez.
2. Estrutura do loop (para declaração de loop)
Para formato de instrução em loop:
para (declaração de inicialização; declaração condicional de julgamento; declaração condicional de controle) {
Declaração corporal de loop;
}
Processo de execução:
R: Execute a declaração de inicialização
B: Execute a declaração condicional do julgamento para verificar se o resultado é verdadeiro ou falso: se for falso, o loop termina; Se for verdade, continue executando.
C: Executar a declaração do corpo do loop
D: Declaração de condição de controle de execução
E: Volte para B e continue
Fluxo:
Notas:
(1) O resultado da declaração condicional de julgamento é do tipo booleano
(2) se a instrução Loop for uma única declaração, os aparelhos poderão ser omitidos; Se forem várias declarações, os aparelhos não podem ser omitidos. Recomenda -se não omiti -lo.
(3) De um modo geral: se houver uma cinta esquerda, não há semicolon, se houver um semicolon, não há cinta esquerda.
Exemplo Código:
1. Encontre a soma de números pares entre 1-100:
/* Requisitos: A: Encontre a soma de 1-100. B: Encontre a soma dos números pares entre 1-100*/classe fortest1 {public static void main (string [] args) {// Encontre a soma de 1-100. int sum1 = 0; for (int x = 1; x <= 100; x ++) {sum1+= x; } System.out.println ("1-100 é:"+sum1); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Método 2 int sum3 = 0;2. Encontre o fatorial de 5:
/* Requisito: Encontre o fatorial de 5. O que é fatorial? n! = n*(n-1)! Regra n! = n*(n-1)*(n-2)*...*3*2*1 ideologia da soma. Encontre pensamento fatorial. */classe fortest2 {public static void main (string [] args) {// define a variável de resultado final int jc = 1; // O X aqui pode realmente começar diretamente de 2 // para (int x = 1; x <= 5; x ++) para (int x = 2; x <= 5; x ++) {jc *= x; } System.out.println ("1-5 Fatorial é:"+JC); }}3. Sair todo o "número de narcissus" no console:
/* Requisitos: produzindo todos os "números de narcissus" na análise do console: não sabemos o que é "números de narcissus", o que você me pede para fazer? Os chamados números de Narcissus se referem a um número de três dígitos, e a soma do cubo de seus dígitos é igual ao próprio número. Por exemplo: 153 é um narcispo. 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 A: O número de três dígitos realmente nos diz o intervalo. B: Através do loop for, podemos obter cada número de dígitos triplos, mas o problema é como obter os dados desse número de três dígitos, dez e centenas. Como obtemos os dados de dados, dez e centenas? Suponha que existam dados: 153 GE: 153%10 = 3 xi: 153/10%10 = 5 Bai: 153/10/10%10 = 1 qian: x/10/10/10%10 WAN: x/10/10/10/10/10%10 ... c: ge*ge*ge+shi*shi*shi+bai*bai*bai*bai*bai*bai*10 ... */classe fortest3 {public static void main (string [] args) {// O dígito triplo realmente nos diz o intervalo. for (int x = 100; x <1000; x ++) {int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; // Deixe ge*ge*ge+shi*shi*shi+bai*bai*bai compare com os dados se (x == (ge*ge*ge+shi*shi*shi+bai*bai)) {// se for o mesmo, produza os dados no console. System.out.println (x); }}}}3. Estrutura do loop (enquanto declaração de loop)
Enquanto formato de instrução em loop:
enquanto (declaração condicional de julgamento) {
Declaração corporal de loop;
}
// Declaração de inicialização do formato estendido;
enquanto (declaração condicional de julgamento) {
Declaração corporal de loop;
Declaração de condição de controle;
}
Fluxo:
A diferença entre um loop e um loop de tempo:
Para declarações de loop e, embora as declarações de loop possam ser convertidas de forma equivalente, mas ainda existem algumas pequenas diferenças.
(1) Diferenças no uso:
A variável controlada pela instrução condicional de controle não pode ser acessada após as extremidades do loop for e pode continuar sendo usada após a extremidade do loop enquanto termina. Se você deseja continuar a usá -lo, use enquanto, caso contrário, é recomendável usar. O motivo é que o loop for termina e a variável desaparece da memória, o que pode melhorar a eficiência do uso da memória.
(2) diferença de cena:
Para o loop, é adequado para operação para um julgamento de alcance, enquanto o loop é adequado para operação para número pouco claro de julgamentos
Exemplo Código:
A montanha mais alta do nosso país é o Monte Everest: 8848m. Agora tenho um papel grande o suficiente com uma espessura de: 0,01m. Posso perguntar: quantas vezes o dobro para garantir que a espessura não seja menor que a altura do Monte Everest?
/* A montanha mais alta do nosso país é o Monte Everest: 8848m. Agora tenho um papel grande o suficiente com uma espessura de: 0,01m. Posso perguntar: quantas vezes desistir, posso garantir que a espessura não seja menor que a altura do Monte Everest? Análise: R: Defina uma variável estatística, o valor padrão é 0 B: O pico mais alto é o Monte Everest: 8848m Essa é a espessura final. Agora tenho um pedaço de papel grande o suficiente, com uma espessura de: 0,01m Essa é a espessura inicial C: Quantas vezes eu dobro, posso garantir que a espessura não seja menor que a altura do Monte Everest? Que mudanças acontecerão se eu dobrá -lo uma vez? Ou seja, a espessura é duas vezes mais espessa do que antes. D: Enquanto a espessura de cada alteração não exceder a altura do Monte Everest, ela será dobrada, variável estatística ++ E: Variáveis estatísticas de saída. */classe whileTest01 {public static void main (string [] args) {// define uma variável estatística, o valor padrão é 0 int conting = 0; // O pico mais alto é o Monte Everest: 8848m Esta é a espessura final // agora tenho um papel que é grande o suficiente, com uma espessura de: 0,01m Esta é a espessura inicial // para simplicidade, transformei 0,01 em 1 e, da mesma maneira, 8848 se tornou 884800 int = 884800; int start = 1; enquanto (inicie <end) {//, desde que a espessura de cada alteração não exceda a altura do Monte Everest, dobre -a e da variável estatística ++ contagem ++; // Que mudanças acontecerão se for dobrado uma vez? É que a espessura é o dobro da anterior. start *= 2; System.out.println ("th"+count+"espessura é"+start); } // Variáveis estatísticas de saída. System.out.println ("a ser empilhado"+contagem+"tempo"); }}4. Estrutura do loop (faça… enquanto declaração de loop)
Formato básico:
fazer {
Declaração corporal de loop;
} while ((declaração condicional de julgamento); [/code]
Formato estendido:
Declaração de inicialização;
fazer {
Declaração corporal de loop;
Declaração de condição de controle;
} while ((declaração condicional de julgamento); [/code]
Fluxo:
5. Diferenças e precauções para a estrutura cíclica:
As três declarações de loop podem realmente concluir a mesma função, o que significa que elas podem se converter equivalentemente, mas ainda existem pequenas diferenças:
O faça ... enquanto o loop executa o corpo do loop pelo menos uma vez. Para loop e enquanto o loop apenas executará o corpo do loop quando a condição for verdadeira
1. Notas:
Ao escrever programas, você deve dar prioridade ao loop for, então considere o loop while e, finalmente, considere o fazer ... enquanto o loop.
O código a seguir é um loop morto:
while (true) {}
para(;;){}
2. Uso aninhado de loops: o corpo do loop da declaração em loop é uma declaração de loop
(1) Pergunta 1: Por favor, produz um padrão de estrela (*) com 4 linhas e 5 colunas:
Dica: o número de linhas controladas pelo loop externo e o número de colunas controladas pelo loop interno
/*Requisitos: Por favor, produza a seguinte forma*** *** **** **** ** ***** DICA: O loop externo controla o número de linhas, o loop interno controla o número de colunas*/classe fortest01 {public static void main (string [] args) »// a mais de uma observação simples, vemos que é uma linha é 5. e 5 colunas para (int x = 0; x <5; x ++) {for (int y = 0; y <5; y ++) {System.out.print ("*"); } System.out.println (); } System.out.println ("---------------------------------------------------------------); // Implementamos uma forma de 5 linhas e 5 colunas //, mas não é isso que queremos // o que queremos é a alteração de um número de colunas, y <wer the Number of Columns muda? y = 0, y <= 1, y ++ // A terceira linha: 3 coluna y = 0, y <= 2, y ++ // a quarta linha: 4 coluna y = 0, y <= 3, y ++ // a quinta linha: 5 coluna y = 0, y <= 4, y+ // Quando parecem a alteração de x, na parte superior, a parte de 4 como segue (int x = 0; x <5; x ++) {for (int y = 0; y <= x; y ++) {System.out.print ("*");(2) Pergunta 2: Saia a tabela de multiplicação de nove e nove no console:
/* Requisitos: Saia da tabela de multiplicação de nove e nove no console. Primeiro, escrevemos a tabela de multiplicação de nove e nove: 1*1 = 1 1*2 = 2 2*2 = 4 1*3 = 3 2*3 = 6 3*3 = 9 1*4 = 4 2*4 = 8 3*4 = 12 4 ****el *** *** *** *** *** *** *** *** *** *** *** *** **el Multiplication Table, enquanto: ********* ********* ********* NOTA: '/X' X significa qualquer um, esse método é chamado de personagens de transferência. '/t' a posição de um caractere de guia (tecla tabtab) '/r' enter '/n' quebra de linha */classe forForTest02 {public static void main (string [] args) {for (int x = 0; x <9; x ++) {para (int y = 0; y <= x; y ++) {system.ad.print (" *; } System.out.println (); } System.out.println ("---------------------"); // Para usar os dados, começamos de 1 para (int x = 1; x <= 9; x ++) {for (int y = 1; y <= x; y ++) {System.out.print (y+"*"+x+"="+y*x+"/t"); } System.out.println (); }}}Efeito de corrida:
6. Declaração de controle de salto:
Como já dissemos antes, o Goto em Java é uma palavra reservada e não pode ser usada no momento. Embora não haja declaração Goto para aprimorar a segurança do programa, ela também traz muito inconveniente. Por exemplo, quero terminar quando um certo loop souber de uma certa etapa, e não posso fazer isso agora. Para compensar esse defeito, o Java fornece interrupção, continue e retorne aos saltos e interrupções de declarações.
interromper quebrar
continuar
retornar
1. Declaração de controle de salto (quebra):
Use cenários para interrupção:
~ Na instrução Switch para selecionar estrutura
~ Na declaração de loop (se o julgamento for adicionado à declaração de loop)
Nota: Não faz sentido deixar o cenário de uso
A função do intervalo:
A: Rompe do loop de camada única
B: Rompe do loop de várias camadas
Para alcançar esse efeito, você deve saber algo. Uma declaração com rótulo. Os nomes de tags devem cumprir as regras de nomeação de Java
Formatar:
Nome da tag: instrução
Exemplo Código:
/* Declaração de salto de controle: interrupção: interrupção Continue: Continue: Retorno: Retorno Break: Interrupção Significado Cenário de uso: A: Declaração B: declaração de loop. (Se o julgamento for adicionado à declaração de loop) Nota: Não faz sentido deixar as duas cenas acima. Como usá -lo? R: Rompe de um loop de camada única B: Partem de um loop de várias camadas para alcançar esse efeito, você deve saber alguma coisa. Uma declaração com rótulo. Formato: Nome da tag: instrução */classe breakdemo {public static void main (string [] args) {// deslocamento externo ou loop // break; // compensar um loop de camada única para (int x = 0; x <10; x ++) {if (x == 3) {break; } System.out.println ("helloworld"); } System.out.println ("Over"); System.out.println ("-------------"); // deslocamento um loop de várias camadas wc: for (int x = 0; x <3; x ++) {nc: for (int y = 0; y <4; y ++) {if (y == 2) {// quebre nc; quebrar WC; } System.out.print ("*"); } System.out.println (); }}}Na linha 38, adicionamos uma tag ao loop externo chamado WC e depois pulamos desta tag na linha 42.
Efeito de corrida:
NOTA: No desenvolvimento real, é quase impossível usar a função de saltar looping de várias camadas.
2. Declaração de controle de salto (continue):
Use cenários para continuar:
Não faz sentido deixar o cenário de uso em uma declaração de loop
A diferença entre continuar e interromper:
Break Break Out of uma camada única Continue a partir de um loop e entra na próxima execução.
Os efeitos são os seguintes:
Perguntas sobre entrevistas:
para (int x = 1; x <= 10; x ++) {if (x%3 == 0) {// preencha o código aqui} System.out.println ("Java Learning"); }Preencha na linha 4 do código acima para satisfazer as seguintes condições:
Quero produzir 2 vezes no console: "Java Learn" Break;
Quero produzir 7 vezes no console: "Java Learning" continua;
Quero produzir 13 vezes no console: "Java Learning" System.out.println ("Java Learning");
3. Declaração de controle de salto (devolução)
A palavra -chave de retorno é não pular do corpo do loop. A função mais usada é encerrar um método, ou seja, sair de um método e saltar para o método chamado na camada superior.
Para ser franco: a função do retorno não é encerrar o loop, mas encerrar o método.
Os efeitos são os seguintes:
Exercícios de declarações de loop combinadas com quebra:
Pergunta da entrevista: A mãe de Xiaofang lhe dá 2,5 yuan um dia, e ela o salvará. No entanto, sempre que este dia é o quinto dia de economia ou um múltiplo de 5, ela passará 6 yuan. Quantos dias Xiaofang pode salvá -lo em 100 yuan.
Implementação de código:
/* Requisitos: A mãe de Xiaofang dá a ela 2,5 yuan um dia, e ela o salvará. No entanto, sempre que este dia é o quinto dia de economia ou um múltiplo de 5, ela passará 6 yuan. Quantos dias Xiaofang pode salvá -lo em 100 yuan. Análise: R: A mãe de Xiaofang dá a ela 2,5 yuan por dia, Double DayMoney = 2,5; B: Ela salvará Double Daysum = 0; C: Armazene Int DayCount = 1 desde o primeiro dia; D: Quantos dias Xiaofang salvará 100 yuan. resultado duplo = 100; E: Se este dia for o quinto dia de economia ou múltiplas de 5, ela gastará 6 yuan, indicando que precisa julgar o valor do dia do dia. Se o 5 for dividido, 6 yuan serão subtraídos. Daysum -= 6; Isso também implica um problema, ou seja, se não for um múltiplo de 5 dias, o dinheiro deve ser acumulado Daysum += DayMoney; F: Como não sei quantos dias é, uso um loop morto. Depois de exceder 100 yuan, sairei do loop. */class Whiledemo {public static void main (string [] args) {// O dinheiro a ser armazenado todos os dias é 2,5 yuan duplo DayMoney = 2.5; // O valor de inicialização da economia é 0 dias duplos = 0; // Armazenamento Int DayCount = 1 desde o primeiro dia; // O armazenamento final é nada inferior a 100 e o resultado int = 100; // Como não sei quantos dias é, eu uso um loop morto, enquanto (verdadeiro) {// acumulam dinheiro deysum += DayMoney; // Depois de exceder 100 yuan, saio do loop. if (Daysum> = resultado) {System.out.println ("Gastando um total de 100 yuan em armazenamento no total"); quebrar; } if (DayCount%5 == 0) {// Gaste 6 yuan diasum -= 6; System.out.println ("Things"+DayCount+"gastando um 6 yuan no total"); } // o número de dias alterações do dia do dia ++; }}}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.