aprendizaje de control de procesos de Java
Objeto escáner
El concepto
1. Realice la interacción entre el programa y las personas a través de la clase Scanner, y obtenga la entrada del usuario a través de ella. java.util.Scanner es una característica de java5.
Podemos obtener la entrada del usuario a través de la clase Scanner .
2. Gramática básica
Scanner s = new Scanner(System.in);
3. Use los métodos next () y nextLine () de la clase Scanner para obtener la cadena de entrada. Antes de leer, generalmente necesita usar hasNext () y hasNextLine () para determinar si hay datos de entrada.
Visualización de código
Una vez completada la entrada del teclado, haga clic en Entrar para completar la entrada.
Obtenga el valor de entrada mediante el siguiente método.
1. El siguiente acceso () a los datos de entrada encuentra un espacio, luego termina y no se puede obtener el valor después del espacio.
Use el método hasNext () para determinar si el usuario ingresa un valor.
String str = scanner.next (); después de ejecutar el programa, seguirá ejecutándose. Este código espera a que el usuario ingrese el valor, y la siguiente oración se ejecutará después de hacer clic en la tecla Enter.
// 创建一个扫描器对象，用户接收键盘数据
// System.in表示输入，键盘输入数据传给Scanner类，使用scanner变量引用
Scanner scanner = new Scanner(System.in);
// 判断用户是否输入字符串
if(scanner.hasNext()) {
// 程序执行后，会保持运行状态，这一句等待用户输入值，点击Enter结束后才会执行下一句
String str = scanner.next();
// 若输入12 45，结果为12，遇到空格后结束
System.out.println("使用next结果为：" + str);
}
// 凡是属于IO（输入输出）流的类如果不关闭会一直占用资源，要养成关闭的习惯
scanner.close();
2. El método nextLine () obtiene todos los datos antes de hacer clic en Enter.
Scanner scanner = new Scanner(System.in);
// 判断用户是否输入字符串
if(scanner.hasNextLine()) {
String str = scanner.nextLine();
// 若输入ab cd，结果为ab cd
System.out.println("使用nextLine结果为：" + str);
}
scanner.close();
Características de dos métodos:
siguiente()
1. Asegúrese de leer los caracteres válidos antes de finalizar la entrada.
2. Cuando se encuentra un espacio, termina, y solo se puede obtener la cadena antes del espacio
3. next () no puede ingresar una cadena con espacios
línea siguiente()
1. Con Enter como el carácter final, puede obtener todos los caracteres que ingresó antes de hacer clic en Enter.
2. Puede obtener espacios y caracteres después de espacios.
Scaner Advanced
Especifique el tipo de entrada. Por ejemplo, el tipo de número de entrada especificado es válido.
Scanner scanner = new Scanner(System.in);
double sum = 0;
int n = 0;
System.out.println("请输入数字类型，输入其他类型值加Enter未结束：");
// 只有输入不是数字类型后才能结束while循环，
// nextDouble只能获取到数字类型的值
while(scanner.hasNextDouble()) {
double a = scanner.nextDouble();
sum = sum + a;
n++;
}
System.out.println("输入的数值的个数为：" + n);
System.out.println("输入值的平均值为：" + sum/n);
// 凡是属于IO（输入输出）流的类如果不关闭会一直占用资源，要养成关闭的习惯
scanner.close();
Estructura secuencial
La estructura básica de Java es una estructura secuencial, a menos que se especifique lo contrario, se ejecutará frase por frase en secuencia .
La estructura secuencial es una estructura de algoritmo básica indispensable para cualquier algoritmo.
Estructura de juicio
Juzgue si algo es factible antes de ejecutarlo. El programa usa una declaración if para indicar la estructura del juicio.
Gramática
// 布尔表达式：指结果为true或者false的表达式
if(布尔表达式) {
// 布尔表达式为true时执行的括号里的语句
}
Estructura de doble elección
Hay dos resultados después del juicio. Sintaxis:
if(布尔表达式) {
// 布尔表达式为true时执行语句
} else {
// 布尔表达式为false时执行语句
}
Estructura de elección múltiple
Existen múltiples juicios de condición, siempre que se cumpla una condición, el juicio posterior no se ejecutará.
Sintaxis:
if (布尔表达1) {
// 符合布尔表达式1为true就执行这里
} else if (布尔表达2) {
// 符合布尔表达2为true就执行这里
} else if (布尔表达3) {
// 符合布尔表达式3为true就执行这里
} else {
// 都不符合布尔表达的1、2、3就执行这里
}
if (grade >= 90 && grade <=100) {
System.out.println("成绩优秀！");
} else if (grade >= 80 && grade < 90) {
System.out.println("成绩良好！");
} else if (grade >= 60 && grade <80) {
System.out.println("成绩合格！");
} else if (grade >= 0 && grade < 60) {
System.out.println("成绩不合格！");
} else {
System.out.println("输入的成绩错误！");
}
Anidado si estructura
La sentencia de juicio if puede usarse en la sentencia de juicio if.
Gramática
if (布尔表达式1) {
// 布尔表达式1位true后执行
if (布尔表达式2) {
// 布尔表达式2位true后执行
}
}
Cambiar
El interruptor es una estructura de opción múltiple.
El tipo de variable en la declaración de cambio puede ser:
byte, short, int o char,
A partir de Java SE 7, el conmutador admite el tipo de cadena String.
Al mismo tiempo, la etiqueta del caso debe ser una constante de cadena.
Gramática
// 表达式等于value值才会执行相应的语句
switch (表达式) {
case value1 :
// 表达式等于value1时执行这里的语句
// break:执行后结束直接跳出，不会再执行后面的代码。
break;
case value2 :
// 表达式等于value1时执行这里的语句
break;
default :
// 表达式都不等于前面的value值时，执行这里
}
char grade = 'B';
switch (grade) {
case 'A':
System.out.println("成绩优秀！");
break;
case 'B':
System.out.println("成绩良好！");
break;
case 'C':
System.out.println("成绩及格！");
break;
default :
System.out.println("不在成绩值的范围！");
}
La esencia de juzgar si es equivalente en el cambio todavía se juzga por el valor. Las cadenas son los números correspondientes en la tabla Unicode. Cada objeto tiene un valor hascode (compuesto de números), que se utiliza para comparar con el valor hascode del valor.
java compilation java ---> class (bytecode file) ---> decompilation (IDEA)
Verifique el archivo de clase generado después de Java, descompílelo a través de IDEA y compárelo con el archivo original de Java.
1. Haga clic derecho y seleccione Project Structre
2. Encuentre la ruta al archivo de clase
3. Busque el archivo de clase (escribí el código en Demo03, así que elegí copiar Demo03.class) para copiar
Encuentra el directorio del archivo actual en IDEA
1. Haga clic derecho en el archivo seleccionado
2. Seleccione Mostrar en el Explorador para abrir el directorio del archivo java
3. Copie y pegue el archivo de clase
La esencia del personaje sigue siendo el valor, y el juicio final todavía se basa en el valor.
Estructura cíclica
Mientras
1. Si bien es el ciclo más básico, su sintaxis es:
while(布尔表达式) {
// 布尔表达式为true执行循环内容
}
2. Mientras la expresión booleana sea verdadera, el ciclo continuará ejecutándose.
3. En la mayoría de los casos , detendremos el ciclo y necesitamos una forma de hacer que la expresión sea falsa para finalizar el ciclo.
Calcule 1 ~ 100 con while
int sum = 0;
int i = 1;
// 只要i小于等于100就会一直执行while里面的语句
while(i <= 100) {
sum = sum + i;
i++;
}
// 当while中i大于100就会结束while循环，执行下一句代码。
System.out.println("结构和为：" + sum);
hacer ~ mientras
1. El bucle do ... while es similar al bucle while, excepto que el bucle do ... while se ejecutará al menos una vez.
do {
// 执行代码
} while(布尔表达式);
La diferencia entre while y do ... while
1. Mientras se juzga antes de la ejecución, mientras que se ... mientras se juzga después de la ejecución.
2. do ... while asegura que el bucle se ejecute al menos una vez.
para bucle
1. La instrucción for loop es una estructura general que admite la iteración y es la estructura de bucle más efectiva y flexible. La sintaxis es la siguiente:
for(初始化;布尔表达式;更新) {
// 代码语句
}
Caso: genera la suma entera de 1 ~ 100
int sum = 0;
for (int i = 1;i <= 100;i++) {
sum = sum + i;
}
Ejercicio 1: genera sumas pares e impares entre 1 y 100
int odd = 0; // 奇数
int even = 0; // 偶数
for (int i = 1;i <= 100;i++) {
if (i%2 == 0) {
even = even +i;
} else {
odd = odd +i;
}
}
System.out.println("奇数和为：" + odd);
System.out.println("偶数和为：" + even);
Ejercicio 2: genera un valor que es divisible por 5 entre 100 y genera 3 valores por línea
for (int i=1;i <= 100;i++) {
if(i%5 == 0) {
System.out.print(i + " ");
}
if(i%(5*3) == 0) {
System.out.println();
}
}
Ejercicio 3: imprime la tabla de multiplicar noventa y nueve
// 练习：打印九成九乘法表
// 第一行打印1*1=1，结束后分行。
// 第二行打印1*2=2,2*2=3，结束后分行。
// 第三行...,
for (int i = 1;i <= 9;i++) {
for (int j = 1;j <= i; j++) {
System.out.print(j + "*" + i + "=" + (j*i) + "\t");
}
System.out.println();
}
Ejercicio 4: imprimir triángulos
// 打印三角形
for (int i = 1;i <= 5;i++) {
for (int j = 5;j >= i;j--) {
System.out.print(" ");
}
for (int n = 1;n <= i;n++) {
System.out.print("*");
}
for (int m = 1;m < i;m++) {
System.out.print("*");
}
System.out.println();
}
Mejorado para loop
1. java5 presenta un bucle for mejorado que se utiliza principalmente para matrices o colecciones. La sintaxis es la siguiente
for (声明语句 ： 表达式) {
// 执行代码
}
2. Declaración de declaración: declare una nueva variable local cuyo tipo debe coincidir con el tipo del elemento de matriz. El alcance (es decir, el rango que se puede usar) está limitado al bloque de bucle (es decir, el código en {}), y su valor es igual al valor del elemento de matriz en este momento.
3. Expresión: el nombre de la matriz a la que se debe acceder o el método para devolver el valor como una matriz.
int[] num = {10,20,30,40,50,60};
// 数组num的值会一个一个的传个a，全部传完后结束循环
for (int a : num) {
System.out.println(a);
}
System.out.println("=====================");
// 相当于
int a;
for (int i = 0;i < num.length;i++) {
a = num[i];
System.out.println(a);
}
descanso 和 continuar
1. break En la parte del sujeto de cualquier declaración de loop, break se usa para forzar que quit finalice el loop. (Utilizado principalmente en el interruptor)
2. La declaración continua se usa en el cuerpo de la declaración del ciclo para terminar la ronda actual del ciclo, pero el ciclo no ha terminado y se ejecutará la siguiente ronda del ciclo.
int i = 0;
while (i < 5) {
i++;
if (i == 3) {
// 结束while循环，跳出执行下一句
break;
}
System.out.print(i + " ");
}
// 结果为1 2
int j = 0;
while (j < 5) {
j++;
if (j == 3) {
// 直接结束本次循环，会在执行下一个循环
continue;
}
System.out.print(j + " ");
}
// 结果为1 2 4 5
Aprender a ver el video es: Crazy God dijo que Java es un aprendizaje basado en cero