Étudier Java ②

Résumé de la comparaison, opérateur logique et branchement conditionnel, traitement itératif

Opérateur de comparaison

L'opérateur de comparaison est un symbole qui compare les valeurs et renvoie vrai ou faux. Les opérateurs de comparaison suivants sont disponibles.

Précautions lors de l'utilisation de == et! =

Les types de données Java sont grossièrement divisés en types de base (types primitifs) et types de référence. Il n'y a rien de mal à utiliser ==! = Pour le type de base, mais soyez prudent lorsque vous l'utilisez pour le type de référence. Lorsque vous utilisez ==! = Pour un type de référence, vous devez être conscient que vous ne comparez pas les valeurs détenues par l'objet, mais comparez si les référents référencés par l'objet sont les mêmes. Il y a. Si vous souhaitez comparer les valeurs détenues par les objets, utilisez la méthode equals. Source) Java Road: Operator (2. Comparison Operator)

Je n'ai pas suffisamment fait Java pour savoir comment l'utiliser correctement, mais je pense qu'il est sur le point de se faire prendre. Référence) Différence entre l'opérateur == et la méthode equals

Opérateur logique

&& x && y ・ ・ ・ Renvoie vrai lorsque x et y sont tous les deux vrais.

//x vaut 1
x > 5 && x < 15   //false
//x vaut 10
x > 5 && x < 15   //true
//x vaut 20
x > 5 && x < 15   //false

||

x ||y ・ ・ ・ Renvoie vrai lorsque x ou y est vrai.

//x vaut 1
x < 5 || x > 15   //true
//x vaut 10
x < 5 || x > 15   //false
//x vaut 20
x < 5 || x > 15   //true

! ! x ・ ・ ・ Renvoie vrai si x est faux.

//x vaut 10
x >= 100      //false
!(x >= 100)   //true

if déclaration

if (Expression conditionnelle) {
Processus 1;
} else {
Processus 2;
}

Lorsque l'expression conditionnelle est vraie, le processus 1 est exécuté. Lorsque l'expression conditionnelle est fausse, le processus 2 est exécuté. sinon peut être omis.

De plus, le branchement conditionnel est possible en utilisant else if comme indiqué ci-dessous.

if (Expression conditionnelle A) {
Processus A;
} else if (Expression conditionnelle B) {
Processus B;
} else if (Expression conditionnelle C) {
Processus C;
} else {
Processus D;
}

Si l'expression conditionnelle A est fausse, l'expression conditionnelle B est évaluée et si elle est vraie, le processus B est exécuté. Si l'expression conditionnelle B est également fausse, l'expression conditionnelle C est évaluée et si elle est vraie, le traitement C est exécuté. Si tout est faux, le processus D ci-dessous est exécuté. Vous pouvez écrire autant de ifs que vous le souhaitez. sinon peut être omis.

instruction switch

L'instruction if utilise des valeurs booléennes (true, false) comme critères, tandis que l'instruction switch utilise des valeurs entières comme critères.

switch (Expression conditionnelle) {
valeur de cas 1:
Processus 1;
    break;
valeur de cas 2:
Processus 2;
    break;
  default:
Processus 3;
    break;
}

Tout d'abord, l'expression conditionnelle est déterminée et le traitement de la valeur de cas correspondante est exécuté. break est le processus de rupture de l'instruction switch. Par exemple, si le résultat de l'expression conditionnelle correspond à la valeur 2, le processus 2 est exécuté et l'instruction switch est quittée par l'interruption suivante. S'il ne correspond à aucune valeur de cas, le processus par défaut 3 est exécuté et l'interruption se termine.

default et break peuvent être omis. Cependant, si vous n'écrivez pas ** break, vous ne sortirez pas du processus et exécuterez le processus du cas suivant. ** **

//Lorsque l'expression conditionnelle correspond à la valeur 1
switch (Expression conditionnelle) {
valeur de cas 1:
Processus 1;　　　　　　//Puisqu'il n'y a pas de pause, passez au cas suivant sans sortir
valeur de cas 2:
Processus 2;　　　　　　//Le processus 2 est également exécuté
    break;　　　　　　//Sortez ici
}

Il semble préférable d'écrire break à moins que vous ne souhaitiez exécuter plusieurs cas intentionnellement. (Existe-t-il une telle situation?)

déclaration while

int i = 1;
while (i <= 3) {
  System.out.println("je suis" + i + "est");
  i++;
}

/*résultat
je vaut 1
j'ai 2 ans
j'ai 3 ans
*/

Déterminez l'intérieur de l'expression conditionnelle et, si elle est vraie, exécutez le traitement de {}. Après cela, l'expression conditionnelle est à nouveau déterminée et répétée tant qu'elle reste vraie. Si faux, quittez. S'il est faux depuis le début, le processus n'est jamais exécuté.

Tant que l'expression conditionnelle est vraie, la boucle est répétée, donc si vous n'écrivez pas le processus pour qu'il soit faux un jour, ce sera une boucle infinie **. Dans le cas ci-dessus, si i ++; n'est pas écrit, une boucle infinie se produira.

pour déclaration

for (Initialisation variable;Expression conditionnelle;Mettre à jour les variables) {
En traitement;
}

Lors de l'initialisation des variables, les variables locales (int i = 0; etc.) utilisées pour juger le traitement itératif sont initialisées. Dans l'expression conditionnelle, écrivez une condition qui renvoie une valeur booléenne (vrai, faux). Après traitement, mettez à jour les variables (i ++, etc.).

for (int i = 0; i < 5; i++) {
  System.out.println("je suis" + i + "est");
}

/*résultat
je vaut 0
je vaut 1
j'ai 2 ans
*/

pause et continue

break Il est possible de forcer l'arrêt du processus itératif en utilisant break. Combinez avec des branches conditionnelles telles que l'instruction if

for (int i = 1; i <= 5; i++) {
  if(i > 3) {   //Résiliation forcée lorsque j'atteins 4
    break;
  }
  System.out.println("je suis" + i + "est");
}

/*résultat
je vaut 1
j'ai 2 ans
j'ai 3 ans
*/

continue Seul le traitement de cette semaine est ignoré. Combinez avec des branches conditionnelles telles que l'instruction if

for (int i = 1; i <= 5; i++) {
  if (i % 2 == 0) {   //Quand je suis pair, terminez la boucle autour de cela et passez à la boucle suivante
    continue;
  }
  System.out.println("je suis" + i + "est");
}

/*résultat
je vaut 1
j'ai 3 ans
j'ai 5 ans
*/