1. Estructura circular
Una instrucción de bucle puede ejecutar repetidamente una determinada pieza de código cuando se cumple la condición de bucle. Este código repetido se llama una declaración de cuerpo de bucle. Cuando este cuerpo de bucle se ejecuta repetidamente, la condición de juicio del bucle debe modificarse en falso en el momento apropiado para finalizar el bucle, de lo contrario, el bucle continuará ejecutándose, formando un bucle muerto.
Composición de declaraciones de bucle:
Declaración de inicialización: una o más declaraciones, estas declaraciones completan algunas operaciones de inicialización.
Declaración condicional de decisión: Esta es una expresión booleana, que puede determinar si ejecutar el cuerpo del bucle.
Declaración del cuerpo de bucle: esta parte es una declaración de bucle-cuerpo, que es lo que tenemos que hacer muchas veces.
Declaración de condición de control: Esta parte se ejecuta antes de que se ejecute la condición de juicio del siguiente ciclo después del final del cuerpo del ciclo. Al controlar las variables en la condición del bucle, el bucle termina en el momento apropiado.
EG: Cuando "Helloworld" se emite 10 veces en la consola,
Declaración de inicialización: Defina la inicialización como la primera vez.
Declaración condicional del juicio: El número de veces no puede exceder 10 veces.
Declaración del cuerpo del bucle: emite la declaración "Helloworld".
Declaración de condición de control: el número de veces cambia a la próxima vez.
2. Estructura de bucle (para la declaración de bucle)
Para formato de instrucción de bucle:
para (declaración de inicialización; declaración condicional de juicio; declaración condicional de control) {
Declaración del cuerpo de bucle;
}
Proceso de ejecución:
R: Ejecutar la declaración de inicialización
B: Ejecute la declaración condicional del juicio para ver si el resultado es verdadero o falso: si es falso, el bucle termina; Si es cierto, continúe ejecutando.
C: Declaración del cuerpo de ejecución del bucle
D: Ejecutar la declaración de condición de control
E: Vuelve a B y continúa
diagrama de flujo:
Notas:
(1) El resultado de la declaración condicional del juicio es un tipo booleano
(2) Si la instrucción de bucle es una sola declaración, se pueden omitir los frenos; Si se trata de múltiples declaraciones, los aparatos no se pueden omitir. Se recomienda no omitirlo.
(3) En términos generales: si hay un aparato ortopédico izquierdo, no hay semicolon, si hay un punto y coma, no hay abrazadera izquierda.
Código de ejemplo:
1. Encuentre la suma de números par entre 1-100:
/* Requisitos: A: Encuentre la suma de 1-100. B: Encuentre la suma de números par entre 1-100*/class Fortest1 {public static void main (string [] args) {// Encuentre la suma de 1-100. int sum1 = 0; para (int x = 1; x <= 100; x ++) {sum1+= x; } System.out.println ("1-100 es:"+sum1); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- // método 2 int sum3 = 0;2. Encuentra el factorial de 5:
/* Requisito: Encuentre el factorial de 5. ¿Qué es factorial? ¡norte! = n*(n-1)! Regla N! = N*(N-1)*(N-2)*...*3*2*1 Sum Ideology. Encontrar pensamiento factorial. */class fortest2 {public static void main (string [] args) {// Defina la variable de resultado final int jc = 1; // La x aquí puede comenzar directamente desde 2 // para (int x = 1; x <= 5; x ++) para (int x = 2; x <= 5; x ++) {jc *= x; } System.out.println ("1-5 factorial es:"+jc); }}3. Salida Todo el "número de narciso" en la consola:
/* Requisitos: emite todos los "números de narciso" en el análisis de la consola: no sabemos qué es "números de narciso", ¿qué me pides que haga? Los llamados números de narcisos se refieren a un número de tres dígitos, y la suma del cubo de sus dígitos es igual al número en sí. Por ejemplo: 153 es un narciso. 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 A: El número de tres dígitos en realidad nos dice el rango. B: a través del bucle for, podemos obtener cada número de triple dígito, pero el problema es cómo obtener los datos de este número de triple dígito, diez y cientos. ¿Cómo obtenemos los datos de un datos, diez y cientos? Supongamos que hay datos: 153 GE: 153%10 = 3 Shi: 153/10%10 = 5 Bai: 153/10/10%10 = 1 Qian: x/10/10/10%10 wan: x/10/10/10/10%10 ... c: Sea Ge*Ge*Ge+shi*shi*shi+Bai*Bai*Bai Compare con los datos y la salida de los datos de los consoladores. */class fortest3 {public static void main (string [] args) {// El triple dígito en realidad nos dice el rango. para (int x = 100; x <1000; x ++) {int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; // Deje que GE*GE*GE+shi*shi*shi+bai*bai*bai se compara con los datos if (x == (ge*ge*ge+shi*shi*shi+bai*bai)) {// si lo mismo, emite los datos en la consola. System.out.println (x); }}}}3. Estructura de bucle (mientras que la declaración de bucle)
Mientras que el formato de instrucción de bucle:
while (declaración condicional del juicio) {
Declaración del cuerpo de bucle;
}
// Declaración de inicialización de formato extendido;
while (declaración condicional del juicio) {
Declaración del cuerpo de bucle;
Declaración de condición de control;
}
diagrama de flujo:
La diferencia entre un bucle para bucle y un bucle de tiempo:
Para las declaraciones de bucle y, mientras que las declaraciones de bucle se pueden convertir de manera equivalente, pero todavía hay algunas pequeñas diferencias.
(1) Diferencias de uso:
No se puede acceder a la variable controlada por la instrucción condicional de control después de los extremos para el bucle for For, y puede continuar usándose después de que termina el bucle while. Si desea continuar usándolo, use mientras, de lo contrario se recomienda usarlo. La razón es que los extremos para el bucle para y la variable desaparecen de la memoria, lo que puede mejorar la eficiencia del uso de la memoria.
(2) Diferencia de escena:
Porque el bucle es adecuado para la operación para un juicio de rango, mientras que el bucle es adecuado para la operación para un número poco claro de juicios
Código de ejemplo:
La montaña más alta de nuestro país es Mount Everest: 8848m. Ahora tengo un papel lo suficientemente grande con un grosor de: 0.01m. ¿Puedo preguntar cuántas veces lo doble para asegurarme de que el grosor no sea más bajo que la altura del Monte Everest?
/* La montaña más alta de nuestro país es el Monte Everest: 8848m. Ahora tengo un papel lo suficientemente grande con un grosor de: 0.01m. ¿Puedo preguntar cuántas veces me doblo, puedo asegurarme de que el grosor no sea más bajo que la altura del Monte Everest? Análisis: A: Defina una variable estadística, el valor predeterminado es 0 B: el pico más alto es el Monte Everest: 8848m Este es el grosor final. Ahora tengo una hoja de papel lo suficientemente grande, con un grosor de: 0.01m Este es el grosor inicial C: ¿Cuántas veces me doblo, puedo asegurarme de que el grosor no sea más bajo que la altura del Monte Everest? ¿Qué cambios sucederán si lo doblo una vez? Es decir, el grosor es dos veces más grueso que antes. D: Mientras el grosor de cada cambio no exceda la altura del Monte Everest, se doblará, Variable estadística ++ E: Variables estadísticas de salida. */class whileTest01 {public static void main (string [] args) {// Definir una variable estadística, el valor predeterminado es 0 int count = 0; // El pico más alto es Mount Everest: 8848m Este es el grosor final // ahora tengo un papel que es lo suficientemente grande, con un grosor de: 0.01m Este es el grosor inicial // para simplicidad, entregué 0.01 a 1, y la misma forma en que 8848 se convirtió en 884800 int End = 884800; int inicio = 1; mientras que (inicio <end) {// siempre y cuando el grosor de cada cambio no exceda la altura del monte Everest, lo doble y la variable estadística ++ Count ++; // ¿Qué cambios sucederán si se dobla una vez? Es que el grosor es el doble del anterior. inicio *= 2; System.out.println ("th"+count+"El grosor es"+inicio); } // Salida Variables estadísticas. System.out.println ("para apilarse"+Count+"Time"); }}4. Estructura de bucle (hacer ... mientras que la declaración de bucle)
Formato básico:
hacer {
Declaración del cuerpo de bucle;
} while ((declaración condicional de juicio); [/código]
Formato extendido:
Declaración de inicialización;
hacer {
Declaración del cuerpo de bucle;
Declaración de condición de control;
} while ((declaración condicional de juicio); [/código]
diagrama de flujo:
5. Diferencias y precauciones para la estructura cíclica:
Las tres declaraciones de bucle pueden completar la misma función, lo que significa que pueden convertirse de manera equivalente, pero todavía hay pequeñas diferencias:
Do ... mientras que el bucle ejecutará el cuerpo del bucle al menos una vez. Para bucle y while loop solo ejecutará el cuerpo de bucle cuando la condición sea verdadera
1. Notas:
Al escribir programas, debe dar prioridad al bucle for, luego considere el bucle while y finalmente considere el do ... while loop.
El siguiente código es un bucle muerto:
while (verdadero) {}
para(;;){}
2. Uso anidado de bucles: el cuerpo de bucle de la declaración de bucle en sí es una declaración de bucle
(1) PREGUNTA 1: ENCONTRA un patrón de estrella (*) con 4 filas y 5 columnas:
Consejo: El número de filas controladas por el bucle exterior y el número de columnas controladas por el bucle interno
/*Requisitos: genere la siguiente forma*** *** **** **** ** ***** Consejo: el bucle exterior controla el número de filas, el bucle interno controla el número de columnas*/class forfortest01 {public static void main (cadena [] args) {// a través de una simple observación, vemos que esta es una fila y el número de columnas es una forma cambiante //. para (int x = 0; x <5; x ++) {for (int y = 0; y <5; y ++) {system.out.print ("*"); } System.out.println (); } System.out.println ("-----------------------------------------------------); // Hemos implementado una forma de 5 filas y 5 columnas // pero esto no es lo que queremos // lo que queremos es el cambio del número de columnas // ¿Cómo cambia el número de columnas? // la primera fila: 1 columna y = 0, y <= 0, y ++ // la fila: 2 columna ¿COLUMA? y = 0, y <= 1, y ++ // La tercera fila: 3 columna y = 0, y <= 2, y ++ // La cuarta fila: 4 columna y = 0, y <= 3, y ++ // La quinta fila: 5 columna y = 0, y <= 4, y ++ // Cuando se mira el cambio de x en el bucle externo, es x = 0,1,2,3,4 // para (int x = 0; x <5; x ++) {for (int y = 0; y <= x; y ++) {system.out.print ("*");(2) Pregunta 2: emite la tabla de nueve nueve multiplicación en la consola:
/* Requisitos: emite la tabla de nueve nueve multiplicación en la consola. First we write the nine-nine multiplication table: 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*4=16 ... 1*9=9 2*9=18 3*9=27 ... Let's first see this nine-nine multiplication table as such: * ** ********* ********* ********* ********* ********* ********* Nota: '/x' x significa cualquiera, este método se llama caracteres de transferencia. '/t' la posición de un personaje de pestaña (tecla TabTab) '/r' Enter '/N' Line Break */Class Forfortest02 {public static void main (string [] args) {for (int x = 0; x <9; x ++) {for (int y = 0; y <= x; y ++) {system.ut.print (" *"); } System.out.println (); } System.out.println ("---------------------"); // Para usar datos, comenzamos desde 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 (); }}}Efecto de ejecución:
6. Declaración de control de salto:
Como ya hemos dicho antes, Goto en Java es una palabra reservada y no se puede usar en la actualidad. Aunque no hay una declaración GOTO para mejorar la seguridad del programa, también trae muchos inconvenientes. Por ejemplo, quiero terminar cuando un cierto bucle sepa hasta cierto paso, y no puedo hacer esto ahora. Para compensar este defecto, Java proporciona ruptura, continúa y regresa a los saltos de control e interrupciones de las declaraciones.
interrupción de la interrupción
continuar
devolver
1. Declaración de control de salto (descanso):
Use escenarios para el descanso:
~ En la instrucción Switch para seleccionar la estructura
~ En la declaración de bucle (si el juicio se agrega a la instrucción de bucle)
Nota: no tiene sentido dejar el escenario de uso
La función de la ruptura:
A: salga del bucle de una sola capa
B: salga del bucle de múltiples capas
Para lograr este efecto, debes saber algo. Una declaración con etiqueta. Los nombres de las etiquetas deben cumplir con las reglas de nombres de Java
Formato:
Nombre de la etiqueta: declaración
Código de ejemplo:
/* Declaración de salto de control: Break: Interrupción Continuar: Continuar: Return: Return Break: Interrupción Significado Escenario de uso: A: Declaración de conmutación B: Declaración de bucle. (Si el juicio se agrega a la instrucción del bucle) Nota: no tiene sentido dejar las dos escenas anteriores. ¿Cómo usarlo? R: Salga de un bucle de una sola capa B: salga de un bucle de múltiples capas para lograr este efecto, debe saber algo. Una declaración con etiqueta. Formato: nombre de etiqueta: instrucción */class breakDemo {public static void main (string [] args) {// compensación de interruptor exterior o bucle // break; // compensar un bucle de una sola capa para (int x = 0; x <10; x ++) {if (x == 3) {break; } System.out.println ("HelloWorld"); } System.out.println ("Over"); System.out.println ("---------------"); // Compensación de un bucle de múltiples capas wc: for (int x = 0; x <3; x ++) {nc: for (int y = 0; y <4; y ++) {if (y == 2) {// rompe nc; romper wc; } System.out.print ("*"); } System.out.println (); }}}En la línea 38, agregamos una etiqueta al bucle exterior llamado WC, y luego saltamos de esta etiqueta en la línea 42.
Efecto de ejecución:
Nota: En el desarrollo real, la función de saltar el bucle de múltiples capas es casi imposible de usar.
2. Declaración de control de salto (continuar):
Use escenarios para continuar:
No tiene sentido dejar el escenario de uso en una declaración de bucle
La diferencia entre continuar y romper:
Batir, salga del bucle de una sola capa, continúe saliendo de un bucle y ingresa a la próxima ejecución.
Los efectos son los siguientes:
Preguntas de la entrevista:
for (int x = 1; x <= 10; x ++) {if (x%3 == 0) {// complete el código aquí} system.out.println ("Java Learning"); }Complete la línea 4 del código anterior para satisfacer las siguientes condiciones:
Quiero emitir 2 veces en la consola: "Java Learn" Break;
Quiero emitir 7 veces en la consola: "Aprendizaje Java" continúa;
Quiero emitir 13 veces en la consola: "Java Learning" System.out.println ("Java Learning");
3. Declaración de control de salto (retorno)
La palabra clave de retorno no es saltar del cuerpo del bucle. La función más utilizada es finalizar un método, es decir, salir de un método y saltar al método llamado en la capa superior.
Para decirlo sin rodeos: la función de retorno no es finalizar el bucle, sino para finalizar el método.
Los efectos son los siguientes:
Ejercicios de declaraciones de bucle combinadas con la ruptura:
Pregunta de la entrevista: La madre de Xiaofang le da 2.5 yuanes al día, y ella lo salvará. Sin embargo, cada vez que este día sea el quinto día de ahorro o un múltiplo de 5, ella gastará 6 yuanes. ¿Cuántos días puede Xiaofang ahorrarlo a 100 yuanes?
Implementación del código:
/* Requisitos: la madre de Xiaofang le da 2.5 yuanes al día, y lo guardará. Sin embargo, cada vez que este día sea el quinto día de ahorro o un múltiplo de 5, ella gastará 6 yuanes. ¿Cuántos días puede Xiaofang ahorrarlo a 100 yuanes? Análisis: A: La madre de Xiaofang le da 2.5 yuanes al día, Double DayMoney = 2.5; B: ella ahorrará doble daysum = 0; C: almacenar int daycount = 1 desde el primer día; D: ¿Cuántos días salvará Xiaofang 100 yuanes? resultado doble = 100; E: Si este día es el quinto día de ahorro o múltiplo de 5, gastará 6 yuanes, lo que indica que necesita juzgar el valor de DayCount. Si el 5 se divide, se restarán 6 yuanes. Daysum -= 6; Esto también implica un problema, es decir, si no es un múltiplo de 5 días, el dinero debe acumularse Daysum += DayMoney; F: Debido a que no sé cuántos días son, uso un bucle muerto. Una vez que supera los 100 yuanes, saldré del bucle. */class Whiledemo {public static void main (string [] args) {// El dinero que se almacenará todos los días es 2.5 yuan doble daymoney = 2.5; // El valor de inicialización del ahorro es 0 doble daysum = 0; // Storage int Daycount = 1 desde el primer día; // El almacenamiento final no es menos de 100 y el resultado int = 100; // porque no sé cuántos días son, uso un bucle muerto, mientras (verdadero) {// acumula dinero daysum += dayMoney; // Una vez que excede los 100 yuanes, salgo del bucle. if (daysum> = resultado) {System.out.println ("Gastar un total de 100 yuanes en almacenamiento en total"); romper; } if (dayCount%5 == 0) {// gasta 6 yuan daysum -= 6; System.out.println ("Things"+Daycount+"Gastar un 6 yuan en total"); } // El número de días cambia DayCount ++; }}}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.