Opérateurs numériques en Java

Salut! Aujourd'hui, nous allons aborder un sujet très important, à savoir les opérateurs numériques en Java . En programmation, les chiffres sont partout. Si vous creusez profondément et que vous vous souvenez du lycée, vous vous souviendrez peut-être qu'un ordinateur représente toutes les informations dans un format numérique : des combinaisons de zéros et de uns, également appelées code binaire. Il existe de nombreux opérateurs numériques en programmation, nous allons donc utiliser des exemples pour explorer les plus importants d'entre eux :) Commençons par le plus simple : les opérateurs arithmétiques . Il s'agit des opérateurs bien connus d'addition ( +), de soustraction ( -), de multiplication ( *) et de division ( /).

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Sortie console : 1032 966 32967 30 Vous avez déjà utilisé tout cela. À ce groupe, vous pouvez ajouter le reste ou %l'opérateur modulo ( ).

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Sortie de la console : 1 Dans cet exemple, nous divisons 33 par 2. Cela donne 16, avec une "queue" supplémentaire (un) qui n'est pas divisible par 2. Cette "queue" est le résultat de l'opération "reste de la division". Java implémente également des opérateurs de comparaison/relationnels (comme en mathématiques). Ils vous sont probablement familiers depuis l'école aussi :

• égal à ( ==)
• supérieur à ( >)
• moins de ( <)
• supérieur ou égal à ( >=)
• inférieur ou égal à ( <=)
• pas égal ( !=)

Ici, vous devez faire attention à un point important qui fait que de nombreux débutants font des erreurs. L'opérateur "égal" s'écrit ==, et non =. En Java, un seul =est l' opérateur d'affectation , qui est utilisé lorsqu'une variable se voit affecter un nombre, une chaîne ou la valeur d'une autre variable.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Sortie console : 999 Oups ! Ce n'est évidemment pas le résultat que nous attendions. C'est un type de données totalement différent : nous nous attendions à voir un booléen , mais nous avons obtenu un nombre. Tout cela parce que nous avons utilisé un opérateur d'affectation entre parenthèses au lieu d' une comparaison . x=y La valeur de y(999) a été attribuée à la variable x, puis nous avons affiché la valeur de x. Voici la bonne façon de procéder :

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Sortie de la console : false Nous avons maintenant correctement comparé les deux nombres ! :) Voici une autre fonctionnalité de l'opérateur d'affectation ( =) : il peut être "chaîné" :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Sortie de la console : 256 N'oubliez pas que l'affectation est de droite à gauche . Cette expression ( x = y = z) sera exécutée par étapes :

• y = z, c'est,y = 256
• x = y, c'est,x = 256

Opérateurs unaires.

Ils sont appelés « unaires » du mot « uno », qui signifie « un ». Ils ont reçu ce nom car, contrairement aux opérateurs précédents, ils agissent sur un seul numéro, et non sur plusieurs. Ceux-ci inclus:

• Moins unaire. Il retourne le signe du nombre.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Sortie console : -999 999 Nous avons utilisé l'opérateur moins unaire deux fois. En conséquence, notre nombre était d'abord négatif, puis il est redevenu positif !

• Incrémentation (++) et décrémentation (--)

L' ++opérateur augmente un nombre de un et l' --opérateur réduit un nombre du même montant.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Sortie console : 1000 999 Cette notation peut vous être familière si vous avez entendu parler du langage C++. Ses créateurs ont utilisé ce nom intéressant pour véhiculer l'idée que "C++ est une extension du langage C" Une version améliorée populaire de Notepad s'appelle Notepad++ Voici un point important. Il existe deux types d'opérateurs d'incrémentation et de décrémentation : suffixe et préfixe . x++- suffixe ++x- préfixe Quelle est la différence fondamentale entre mettre les plus/moins avant ou après le nombre ? Nous allons voir dans l'exemple suivant :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Sortie console : 999 Quelque chose ne va pas ! Nous voulions augmenter xde 1 et attribuer la nouvelle valeur à la variable y. En d'autres termes, y devrait être 1000. Mais à la place, nous obtenons autre chose : 999. Il semble que x n'a pas été augmenté et que l'opérateur d'incrémentation n'a pas fonctionné ? Mais ça a marché. Pour vous en convaincre, essayez d'afficher xà la fin :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Sortie console : 999 1000 En fait, c'est précisément pour cette raison que cette opération est appelée postfix : elle est effectuée après l'expression principale. Cela signifie, dans notre cas : int y = x++; y = xest exécuté en premier (et la variable ysera initialisée à la valeur de x), et seulement ensuite sera x++exécuté Et si ce n'est pas le comportement que nous voulons ? Ensuite, nous devons utiliser la notation préfixée :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

Dans ce cas, ++xest traité en premier et ensuite seulement y = x; réalisé. Vous devez enregistrer cette différence dans la mémoire immédiatement pour éviter de faire des erreurs dans un programme réel où l'utilisation de postfix à la place du préfixe pourrait tout bouleverser :)

Opérateurs composés

De plus, en Java, il existe des opérateurs dits composés. Ils combinent deux opérateurs :

• Mission
• Opérateurs arithmétiques

Ceux-ci inclus:

• +=
• -=
• *=
• /=
• %=

Prenons un exemple :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Sortie console : 1032 x += y signifie x = x + y. Les deux symboles sont utilisés consécutivement par souci de brièveté. Les combinaisons -=, *=et /=fonctionnent %=de manière similaire.

Opérateurs logiques

En plus des opérateurs numériques, Java a également des opérations qui impliquent des valeurs booléennes ( true et false ). Ces opérations sont effectuées à l'aide d'opérateurs logiques

• !- NON logique . Il retourne la valeur d'un booléen

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Sortie console : faux

• &&- ET logique . Elle ne renvoie vrai que si les deux opérandes sont vrais.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Sortie console : faux vrai Le résultat de la première opération est faux, car l'un des opérandes est faux, à savoir 100 > 200. Pour retourner vrai, l' &&opérateur exige que les deux opérandes soient vrais (comme c'est le cas dans la deuxième ligne).

• ||- OU logique . Elle renvoie vrai lorsqu'au moins un des opérandes est vrai.

Lorsque nous utilisons cet opérateur, notre exemple précédent produit un résultat différent :

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Sortie de la console : true L'expression 100 > 200est toujours fausse, mais pour l' opérateur OR , il suffit entièrement que la première partie ( 100 > 10) soit vraie.