El
catálogo de etapas básicas del control de procesos de Java :
interacción del usuario
Estructura de secuencia del escáner estructura de
selección estructura de
bucle ejercicios de
ruptura y continuación 1. Objeto del escáner La gramática básica que aprendimos antes no se dio cuenta de la interacción entre programas y personas, pero Java nos proporciona tal Herramientas, podemos obtener información del usuario. Java.util.Scanner es una nueva característica de Java5, podemos obtener la entrada del usuario a través de la clase Scanner.
Sintaxis básica:
Escáner s = nuevo escáner (System.in);
Obtenga la cadena de entrada a través de los métodos next () y nextLine () de la clase Scanner. Antes de leer, generalmente necesitamos usar hasNext () y hasNextLine () para determinar si todavía hay datos de entrada.
siguiente():
Debe leer los caracteres válidos antes de poder finalizar la entrada. // Se debe ingresar, de lo contrario el programa no se detendrá
Para los espacios en blanco encontrados antes de ingresar caracteres válidos, el método next () los eliminará automáticamente. // Hello World solo genera Hello debido a los espacios
Solo cuando se ingresa un carácter válido, el espacio en blanco ingresado después se utilizará como separador o terminador. / '/ Finalizar solo si hay un espacio en el programa'
next () no puede obtener una cadena con espacios.
Ejemplos de uso de next ():
paquete com.company.base;
import java.util.Scanner;
demostración de clase pública1 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接受键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if (scanner.hasNext()){
//使用next方式接收
String str = scanner.next();
System.out.println("输出的内容为:"+str);
}
scanner.close(); //IO流的用完记得关掉 占用内存 IO流就是输入输出流 和电脑交换信息的
}}
NextLine ()
toma Enter como terminador, lo que significa que el método nextLine () devuelve todos los caracteres antes del retorno de carro.
Puede obtener espacios en blanco.
paquete com.company.base;
import java.util.Scanner;
demo2 de clase pública {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据");
if(scanner.hasNextLine()){
String abc = scanner.nextLine();
System.out.println("输出："+abc);
}
scanner.close();
}}
Paquete de escáner com.company.base para juzgar números enteros y decimales ;
import java.util.Scanner;
public class demo4 {
public static void main (String [] args) {
Scanner scanner = new Scanner (System.in);
//从键盘接收数据
int i = 0;
float f = 0.0f;
System.out.println("请输入整数：");
//如果。。。那么。。。
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整数数据："+ i);
}else {
System.out.println("输入的不是整数数据");
}
System.out.println("请输入小数");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("小数数据："+ f);
}else {
System.out.println("输入的不是小数数据!");
}scanner.close ();
}}
Haz una calculadora simple
paquete com.company.base;
import java.util.Scanner;
demo5 de clase pública {
public static void main(String[] args) {
//我们可以输入多个数字，并求其总和与平均数，每一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
m = m+1;//m++
sum = sum + x;
System.out.println("你输入了第"+m+"个数据，然后点钱结果sum"+sum);
}
System.out.println(m +"个数的和为"+ sum);
System.out.println(m+ "个数的平均值是"+(sum / m));
scanner.close();
}}
2. Estructura de la secuencia
La estructura básica de Java es la estructura de la secuencia, a menos que se especifique lo contrario, la responsabilidad se ejecutará de acuerdo con el orden.
La estructura de secuencia es la estructura de algoritmo más simple.
Entre oraciones y oraciones, los recuadros y recuadros se llevan a cabo en orden de arriba a abajo, consta de varios pasos de procesamiento ejecutados en secuencia, es un algoritmo básico que no se puede separar de ningún algoritmo. estructura.
Si aún no lo ha descubierto, simplemente realice el RUN a continuación y lo sabrá
paquete com.company.base;
public class demo6 {
public static void main (String [] args) {
System.out.println ("1");
System.out.println ("2");
System.out.println ("3");
System.out.println ("4");
System.out.println ("5");
System.out.println ("6");
System.out.println ("7");
System.out.println ("8");
}
}
3. Estructura de selección (muy importante)
si estructura de selección simple si estructura de selección
doble si estructura de selección
múltiple
anidada si
cambia estructura estructura de selección múltiple si estructura de selección
única
A menudo necesitamos juzgar si algo es factible, y luego ejecutamos , Tal proceso está representado por una instrucción if en el programa
gramática:
if (expresión booleana) {
// La declaración que se ejecutará si la expresión booleana es verdadera; de lo contrario, omita
}
Cuando la estructura de opción doble if
requiere dos juicios, se necesita una estructura de opción doble, por lo que hay una estructura if-else.
Sintaxis:
if (expresión booleana) {
// Si el valor de la expresión booleana es verdadero
} else {
// Si el valor de la expresión booleana es falso
}
package com.company.ifdemo;
import java.util.Scanner;
public class if2 {
public static void main(String[] args) {
//考试分数大于60就是及格，小于60分就是不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score>60){
System.out.println("及格");
}else {
System.out.println("不及格");
}
}}
Si se
trata de una estructura de selección múltiple, encontramos que el código en este momento no se ajusta a la situación real. En la situación real, puede haber ABCD y hay juicios de varios niveles de intervalo. Por ejemplo, 90-100 es A, 80-90 es B, y así sucesivamente. En muchos casos en la vida, nuestras opciones son más que estos dos, por lo que necesitamos una estructura de opciones múltiples para lidiar con estos problemas.
if (expresión booleana 1) {
// Ejecutar código
si el valor de la expresión booleana 1 es verdadero } else if (expresión booleana 2) {
// Ejecutar código
si el valor de la expresión booleana 2 es verdadero } else if (expresión booleana Ecuación 3) {
// Ejecutar código si el valor de la expresión booleana 3 es verdadero
} else {
// Ejecutar código si ninguna de las expresiones booleanas anteriores es verdadera
}
package com.company.ifdemo;
import java.util.Scanner;
public class if3 {
public static void main(String[] args) {
//考试分数大于60就是及格，小于60分就是不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();/ La
sentencia if tiene como máximo una sentencia else, y la sentencia else sigue a todas las demás sentencias if.
La instrucción if puede tener varias instrucciones else if, y deben preceder a la instrucción else.
Una vez que una de las declaraciones else if se detecta como verdadera, las otras declaraciones else if y else se omitirán. Ejecución
/
if (puntuación == 100) {
System.out.println ("Felicitaciones, obtuvo la máxima puntuación");
} else if (puntuación <100 && puntuación> = 90) {
System.out.println ("Nivel A");
} else if (puntuación <90 && puntuación> = 80) {
System.out.println ("Nivel B");
} else if (puntuación <80 && puntuación> = 70) {
System.out.println ("nivel C");
} else if (puntuación <70 && puntuación> = 60) {
System.out.println ("nivel D") ;
} else if (score <60 && score> = 0) {
System.out.println ("No se pudo aprobar y estudiar mucho");
}
}
}
-
Estructura if anidada
-
Es legal usar declaraciones anidadas if ... else. En otras palabras, puede usar una instrucción if o else if en otra instrucción if o else if. Puede anidar declaraciones else if ... else like if.
- Sintaxis
if (expresión booleana 1) {
// Ejecutar código
si el valor de la expresión booleana 1 es verdadero if (expresión booleana 2) {
// Ejecutar código si el valor de la expresión booleana 2 es verdadero
}
}
-
4. Cambiar la
estructura de opciones múltiples Hay otra forma de darse cuenta de la estructura de opciones múltiples es la declaración de caso de cambio.
La declaración de caso de cambio puede determinar si una variable es igual a un cierto valor en una serie de valores, y cada valor se denomina rama.
El tipo de variable en la declaración del conmutador puede ser:
byte, short, int o char.
A partir de Java SE 7, el
conmutador admite el tipo de cadena String
y la etiqueta del caso debe ser una constante de cadena o un literal.
Switch (expresión) {
valor de caso:
//
salto de declaración ; //
valor de caso opcional :
//
salto de declaración ; // opcional
// puede tener cualquier número de declaraciones de caso
predeterminado:
// declaración // opcional
}
El primer ejemplo:
package com.company.jiaohuan;
public class JH {
public static void main (String [] args) {
//
char grade = 'A';
switch (grade){
case 'A':
System.out.println("优秀");
break;//可选
case 'B':
System.out.println("良好");
break;//可选
case 'C':
System.out.println("及格");
break;//可选
case 'D':
System.out.println("再接再厉");
break;//可选
case 'E':
System.out.println("拉了兄弟");
break;//可选
default:
System.out.println("未知等级");
}
}}
El segundo ejemplo:
package com.company.jiaohuan;
public class JH2 {
public static void main (String [] args) {
String name = "chb";
// Nueva característica de JDK 7, ¡el resultado de la expresión puede ser una cadena! ! !
// ¡La naturaleza de los personajes sigue siendo números! ! !
//反编译 java----class(字节码文件)---反编译（IDEA）cambiar (nombre) {
caso "RAP":
System.out.println ("RAP");
rotura;
caso "整 活":
System.out.println ("整 活");
predeterminado:
System.out.println ("妹 有 啊");
}
}
}
5. Estructura de
bucle while bucle
while (expresión booleana) {
// contenido del bucle
}
- Siempre que la expresión booleana sea verdadera, el bucle continuará ejecutándose.
- En la mayoría de los casos, detendremos el bucle. Necesitamos una forma de invalidar la expresión para finalizar el bucle.
- Es necesario ejecutar una pequeña cantidad de casos en un bucle, como el monitoreo de respuesta a la solicitud del servidor.
- Si la condición de bucle es siempre verdadera, provocará un bucle infinito [bucle infinito] En nuestra programación empresarial normal, deberíamos intentar evitar el bucle infinito. ¡Afectará el rendimiento del programa o hará que el programa se
congele y se bloquee! Package com.company. whiledemo01;
public class Whiledemo1 {
public static void main (String [] args) {
//输出1-100
int i = 0;
while (i < 5201314){
i++;
System.out.println(i);
}
}}
Calcula 1 + 2 +. . +100
public class Whiledemo3 {
public static void main (String [] args) {
// 计算 1 + 2 + 。。 + 100
int i = 0;
int sum = 0;
while (i<=100){
sum = sum + i;
i++;
}
System.out.println(sum);
}}
hacer ... mientras bucle
Para la instrucción while, si no se cumple la condición, no puede ingresar al ciclo. Pero a veces necesitamos ejecutar al menos una vez incluso si no se cumplen las condiciones.
El bucle do ... while es similar al bucle while, la diferencia es que el bucle do ... while se ejecutará al menos una vez
do {
// declaración de código
} while (expresión booleana);
Utilice la instrucción do ... while para calcular 1 + 2 +. . +100
paquete com.company. whiledemo01;
public class dowhiledemo1 {
public static void main (String [] args) {
int i = 0;
int suma = 0;
hacer {
suma = suma + i;
i ++;
} while ((i <= 100));
System.out.println (suma);
}
}
public class dowhiledemo2 {
public static void main (String [] args) {
int a = 0;
while (a<0){
System.out.println(a);
a++;
}
System.out.println("===========");
do{
System.out.println(a);
a++;
}while (a<0);
}La diferencia entre while y do ... while:
Mientras se juzga primero y luego se ejecuta, ¡se ejecuta primero y luego se juzga!
HACER ... mientras siempre garantiza que el cuerpo del bucle se ejecutará al menos una vez. Ésta es su principal diferencia.
en bucle
Un bucle for mejorado que se utiliza principalmente para matrices se introduce en Java5