En general, hay tres tipos de estructura de programa: estructura de secuencia, estructura de selección y estructura de bucle. Estas tres estructuras diferentes tienen una característica común. Tienen una sola entrada y una sola salida. La entrada y salida única hace que el programa sea fácil de leer, fácil de mantener y fácil de depurar.
- Estructura de la secuencia: El programa se ejecuta uno por uno de arriba a abajo. Después de que se ejecuta una instrucción, la siguiente instrucción continúa ejecutándose hasta el final del programa, como se muestra en la figura:
- Estructura de selección: La estructura de selección es para decidir qué declaraciones ejecutar según las condiciones sean verdaderas o no. Una estructura: como se muestra en la figura:
- Estructura del bucle: La estructura del bucle determina el número de ejecuciones de la sección del programa según se establezca o no la condición de juicio. Esta sección del programa se denomina cuerpo del bucle, como se muestra en la figura:
Elige una estructura
La estructura de selección incluye instrucciones if, if ... else y switch. Después de agregar el programa con la estructura de selección, es como agregar una "encrucijada". Según las diferentes opciones, el programa se ejecutará con resultados diferentes.
Sentencia
if Sintaxis de sentencia if:
if (condición de juicio) { sentencia 1; ... } Si solo hay una sentencia a procesar en el cuerpo de la sentencia if, se pueden omitir las llaves izquierda y derecha. Cuando se satisface el valor de la condición de juicio (verdadero), las declaraciones entre llaves se ejecutarán una por una. El diagrama de control de flujo de if : Los pasos de ejecución de la declaración if: (1) Juzgue el resultado de la expresión (2) Si el resultado de la expresión es verdadero, ejecute la declaración (3) Si el resultado de la expresión es falso, omita el declaración Ejemplo 1:
package com.qwy;
public class Demo01 {
public static void main(String[] args) {
int x=3;
int y=4;
System.out.println("*********开始比较**********");
if(x>y){
System.out.println("x比y大");
}
if(x<y){
System.out.println("x比y小");
}
System.out.println("*********结束比较**********");
}
}
Resultado de la ejecución:
iniciar la comparación *
x es menor que y
finalizar la comparación *
if… else… instrucción
Estructura de la sintaxis:
if (condición de juicio) { cuerpo de instrucción 1; } else { cuerpo de instrucción 2; }
Cuando hay una sentencia de sentencia de rama en el programa, puede usar la sentencia if ... else para procesar. Cuando se establece la condición de sentencia, se ejecuta el cuerpo principal de la sentencia if. Cuando no se establece la condición de sentencia, la cuerpo de la declaración después de que se ejecuta el else, y el diagrama de control de flujo de if ... else Mostrar: 
Ejemplo 2:
package com.qwy;
public class Demo02 {
public static void main(String[] args) {
int num = 3;
if (num % 2 == 1) {
System.out.println("nums是奇数");
} else {
System.out.println("num是偶数");
}
}
}
Resultado de la operación:
nums es un
operador ternario impar (operador ternario).
Existe un operador que puede ser equivalente a una instrucción que usa if ... else para asignar una variable, es decir, el operador ternario: su formato: variable = juicio ¿condición? Expresión 1: Expresión 2.
Ejemplo 3:
package com.qwy;
public class Demo03 {
public static void main(String[] args) {
int max = 0;
int x = 2;
int y = 4;
max = x > y ? x : y;
System.out.println(max);
}
}
Resultados en ejecución:
4
A partir de los resultados en ejecución, el uso del operador ternario es más conciso: puede reemplazar una cadena larga de if ... else con una declaración.
if ... else if ... sentencia else
Si necesita juzgar múltiples condiciones en if ... else, use if ... else if ... else sentencia, su sintaxis:
if (juicio condicional 1) { cuerpo de la sentencia 1; } else if (juicio condicional 2) { Cuerpo de la declaración 2; } … // Varias declaraciones else if () else {cuerpo de la declaración 3} if… else if diagrama de control de flujo: Ejemplo 4:
package com.qwy;
public class Demo04 {
public static void main(String[] args) {
int x = 5;
if (x == 1) {
System.out.println("x的值是1");
} else if (x == 2) {
System.out.println("x的值是2");
} else if (x == 5) {
System.out.println("x的值是5");
} else {
System.out.println("x的值不在1,2,5中");
}
}
}
Resultado de la operación:
el valor de x es 5. Cuando la
sentencia switch
encuentra y ejecuta una de las sentencias que cumple la condición de juicio entre muchas condiciones, además de usar if ... else juicio continuo, también puede usar una forma más conveniente , es decir, múltiples opciones: declaración de cambio. Su formato gramatical:
switch (expresión) { valor de selección de caso 1: cuerpo de declaración 1; ruptura; valor de selección de caso 2: cuerpo de instrucción 2; ruptura; …… valor de selección de caso n: cuerpo de instrucción n; ruptura; predeterminado: cuerpo de instrucción; } Diagrama de control de flujo de conmutación: los pasos de ejecución del control de flujo de conmutación: (1) La declaración de conmutación primero calcula la expresión entre paréntesis y el resultado son números, caracteres, enumeraciones (después de JDK1.5) y cadenas (después de JDK1.7) ) (Dos) De acuerdo con el valor de la expresión, verifique si coincide con el valor seleccionado detrás del caso. Si el valor seleccionado del caso no coincide, se ejecuta la declaración contenida en el valor predeterminado y la declaración de cambio se deja después ejecución. (3) Si el valor seleccionado de un caso coincide con el resultado de la expresión, se ejecutará la declaración contenida en el caso y la declaración de cambio no se dejará hasta después de la declaración de interrupción. (4) Si la instrucción break no se agrega después de la instrucción case, la instrucción switch se ejecutará hasta el final de la instrucción switch. (5) Si no se define la instrucción de ejecución predeterminada, no se ejecuta nada y se sale directamente de la instrucción de cambio. Ejemplo 5:
package com.qwy;
public class Demo05 {
public static void main(String[] args) {
int x = 3;
int y = 4;
char oper = '-';
switch (oper) {
case '+': {
System.out.println("x+y=" + (x + y));
break;
}
case '-': {
System.out.println("x-y=" + (x - y));
break;
}
case '*': {
System.out.println("x*y=" + (x * y));
break;
}
case '/': {
System.out.println("x+y=" + (x / y));
break;
}
default: {
System.out.println("未知的操作");
break;
}
}
}
}
Resultado de la operación:
xy = -1
Ejemplo 6: Verificar el rol de romper
package com.qwy;
public class Demo06 {
public static void main(String[] args) {
int x=3;
int y=4;
char oper='-';
switch (oper) {
case '+':{
System.out.println("x+y="+(x+y));
//break;
}
case '-':{
System.out.println("x-y="+(x-y));
//break;
}
case '*':{
System.out.println("x*y="+(x*y));
//break;
}
case '/':{
System.out.println("x+y="+(x/y));
//break;
}
default:{
System.out.println("未知的操作");
//break;
}
}
}
}
Resultado de la operación:
xy = -1
x * y = 12
x + y = 0
operación desconocida
Se puede ver en los resultados de ejecución que después de que se cumple la primera condición del programa, debido a que no hay un conjunto de instrucciones de interrupción correspondiente, el programa se ejecuta desde la posición donde se cumple la primera condición y el interruptor no saldrá hasta que se ejecuta la última condición.