Le
catalogue de l' étape de base de Java contrôle de processus :
interaction utilisateur Scanner
structure de séquence
structure de sélection
structure en boucle
break et continuer
exercices
1. Objet du scanner
La grammaire de base que nous avons appris avant ne se rendent pas compte de l'interaction entre les programmes et les gens, mais Java nous fournit un Outils, nous pouvons obtenir l'entrée de l'utilisateur. Java.util.Scanner est une nouvelle fonctionnalité de Java5, nous pouvons obtenir les entrées de l'utilisateur via la classe Scanner.
Syntaxe de base:
Scanner s = nouveau scanner (System.in);
Récupérez la chaîne d'entrée via les méthodes next () et nextLine () de la classe Scanner. Avant de lire, nous devons généralement utiliser hasNext () et hasNextLine () pour déterminer s'il y a encore des données d'entrée.
prochain():
Vous devez lire les caractères valides avant de pouvoir terminer la saisie. // Il doit être entré sinon le programme ne s'arrêtera pas
Pour les blancs rencontrés avant de saisir des caractères valides, la méthode next () les supprimera automatiquement. // Hello World affiche uniquement Hello à cause des espaces
Uniquement lorsqu'un caractère valide est saisi, le blanc saisi après celui-ci sera utilisé comme séparateur ou terminateur. / '/ Fin uniquement s'il y a un espace dans le programme'
next () ne peut pas obtenir une chaîne avec des espaces.
Exemples d'utilisation de next ():
package com.company.base;
import java.util.Scanner;
public class demo1 {
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 ()
prend Enter comme terminateur, ce qui signifie que la méthode nextLine () renvoie tous les caractères avant le retour chariot.
Peut avoir des blancs.
package com.company.base;
import java.util.Scanner;
public class demo2 {
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();
}}
Package de scanner com.company.base pour juger des nombres entiers et décimaux ;
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 ();
}}
Faire une simple calculatrice
package com.company.base;
import java.util.Scanner;
public class demo5 {
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. Structure de séquence
La structure de base de Java est la structure de séquence, sauf indication contraire, la responsabilité est exécutée conformément à l'ordre.
La structure de séquence est la structure d'algorithme la plus simple.
Entre les phrases et les phrases, les boîtes et les boîtes sont exécutées dans l'ordre de haut en bas. Il se compose de plusieurs étapes de traitement exécutées en séquence. C'est un algorithme de base qui ne peut être séparé d'aucun algorithme. structure.
Si vous ne l'avez pas encore compris, donnez simplement le RUN ci-dessous et vous saurez
package 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. Sélectionnez la structure (très important)
si la structure à sélection unique si la structure à
double sélection
si la structure à sélection multiple est
imbriquée si la structure
change la structure à sélection multiple si la structure à sélection
unique
Nous devons souvent juger si quelque chose est faisable, puis nous exécutons , Un tel processus est représenté par une instruction if dans le programme
grammaire:
if (expression booléenne) {
// L'instruction qui sera exécutée si l'expression booléenne est vraie, sinon skip
}
Lorsque la structure à double choix if
nécessite deux jugements, une structure à double choix est nécessaire, il existe donc une structure if-else.
Syntaxe:
if (expression booléenne) {
// Si la valeur de l'expression booléenne est vraie
} else {
// Si la valeur de l'expression booléenne est fausse
}
package com.company.ifdemo;
import java.util.Scanner;
classe publique 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("不及格");
}
}}
S'il s'agit d'une structure à sélection multiple,
nous avons constaté que le code ne correspond pas à la situation réelle. Dans la situation réelle, il peut y avoir ABCD, et il y a des jugements d'intervalle à plusieurs niveaux. Par exemple, 90-100 est A, 80-90 est B, et ainsi de suite. Dans de nombreux cas dans la vie, nos choix vont au-delà de ces deux-là, nous avons donc besoin d'une structure à choix multiples pour faire face à de tels problèmes.
if (expression booléenne 1) {
// Exécute le code
si la valeur de l'expression booléenne 1 est vraie } else if (expression booléenne 2) {
// Exécute le code
si la valeur de l'expression booléenne 2 est vraie } else if (expression booléenne Equation 3) {
// Exécuter du code si la valeur de l'expression booléenne 3 est vraie
} else {
// Exécuter du code si aucune des expressions booléennes ci-dessus n'est vraie
}
package com.company.ifdemo;
import java.util.Scanner;
classe publique if3 {
public static void main(String[] args) {
//考试分数大于60就是及格，小于60分就是不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();/ L'
instruction if a au plus une instruction else, et l'instruction else suit toutes les instructions else if.
L'instruction if peut avoir plusieurs instructions else if et elles doivent précéder l'instruction else.
Une fois que l'une des instructions else if est testée comme vraie, les autres instructions if et else seront ignorées
/
if (score == 100) {
System.out.println ("Félicitations, vous avez tous les points");
} else if (score <100 && score> = 90) {
System.out.println ("A-level");
} else if (score <90 && score> = 80) {
System.out.println ("B-level");
} else if (score <80 && score> = 70) {
System.out.println ("C-level");
} else if (score <70 && score> = 60) {
System.out.println ("D-level") ;
} else if (score <60 && score> = 0) {
System.out.println ("Impossible de réussir et d'étudier dur");
}
}
}
-
Structure si imbriquée
-
Il est légal d'utiliser des instructions if ... else imbriquées. En d'autres termes, vous pouvez utiliser une instruction if ou else if dans une autre instruction if ou else if. Vous pouvez imbriquer else if ... else comme les instructions if.
- Syntaxe
if (Boolean expression 1) {
// Exécuter du code
si la valeur de l'expression booléenne 1 est vraie if (Boolean expression 2) {
// Exécuter du code si la valeur de l'expression booléenne 2 est true
}
}
-
4. Changer de
structure à choix multiples Il existe une autre façon de réaliser la structure à choix multiples est l'instruction de cas de commutation.
L'instruction switch case peut déterminer si une variable est égale à une certaine valeur dans une série de valeurs, et chaque valeur est appelée une branche.
Le type de variable dans l'instruction switch peut être:
byte, short, int ou char.
À partir de Java SE 7,
switch prend en charge le type String String
et le libellé de cas doit être une chaîne constante ou un littéral.
Switch (expression) {
case value:
// instruction
break; // option
case value:
// instruction
break; // facultatif
// vous pouvez avoir n'importe quel nombre d'instructions case
default: // facultatif
// instruction
}
Le premier exemple:
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("未知等级");
}
}}
Le deuxième exemple:
package com.company.jiaohuan;
public class JH2 {
public static void main (String [] args) {
String name = "chb";
// Nouvelle fonctionnalité de JDK 7, le résultat de l'expression peut être une chaîne! ! !
// La nature des personnages est toujours des nombres! ! !
//反编译 java----class(字节码文件)---反编译（IDEA）switch (nom) {
case "RAP":
System.out.println ("RAP");
Pause;
case "整 活":
System.out.println ("整 活");
par défaut:
System.out.println ("妹 有 啊");
}
}
}
5. Structure de la
boucle while boucle
while (expression booléenne) {
// contenu de la boucle
}
- Tant que l'expression booléenne est vraie, la boucle continuera à s'exécuter.
- Dans la plupart des cas, nous arrêterons la boucle. Nous avons besoin d'un moyen d'invalider l'expression pour terminer la boucle.
- Un petit nombre de cas doivent être exécutés en boucle, comme la surveillance de la réponse aux demandes du serveur.
- Si la condition de boucle est toujours vraie, cela provoquera une boucle infinie [boucle infinie] Dans notre programmation commerciale normale, nous devrions essayer d'éviter une boucle infinie. Cela affectera les performances du programme ou provoquera le
blocage et le blocage du programme! 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);
}
}}
Calculez 1 + 2 +. . +100
classe publique 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);
}}
faire ... boucle while
Pour l'instruction while, si la condition n'est pas remplie, elle ne peut pas entrer dans la boucle. Mais parfois, nous devons exécuter au moins une fois même si les conditions ne sont pas remplies.
La boucle do ... while est similaire à la boucle while, la différence est que la boucle do ... while sera exécutée au moins une fois
do {
// Instruction de code
} while (expression booléenne);
Utilisez l'instruction do ... while pour calculer 1 + 2 +. . +100
package com.company.whiledemo01;
public class dowhiledemo1 {
public static void main (String [] args) {
int i = 0;
somme int = 0;
faire {
somme = somme + i;
i ++;
} tandis que ((i <= 100));
System.out.println (somme);
}
}
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 différence entre while et do ... while:
Alors qu'il est jugé en premier et ensuite exécuté, le dowhile est d'abord exécuté, puis juge!
FAIRE ... tandis que garantit toujours que le corps de la boucle sera exécuté au moins une fois! C'est leur principale différence.
pour boucle
Une boucle for améliorée principalement utilisée pour les tableaux est introduite dans Java5