Opérateurs unaires en Java

Pour tout langage de programmation, un large éventail d'opérateurs, de méthodes et de fonctions sont disponibles pour une utilisation en fonction des besoins. Le langage de programmation orienté objet basé sur les classes, Java, fournit une large gamme d'opérateurs, et l'un de ces types d'opérateurs en Java est les « opérateurs unaires ».

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Les opérateurs unaires peuvent être un opérateur qui ne prend qu'un seul opérande et effectue un travail simple consistant à incrémenter ou décrémenter la valeur de un. De plus, les opérateurs unaires effectuent également des opérations de négation pour l'expression, et la valeur du booléen peut être inversée.

Types d'opérateurs unaires

Il existe cinq opérateurs unaires capables d'effectuer diverses opérations. Vous trouverez ci-dessous la liste des cinq opérateurs unaires :

• Unary Plus, noté « + ».
• Moins unaire, noté « -«
• Opérateur d'incrémentation unaire, noté « ++ ».
• Opérateur de décrémentation unaire, noté « – »
• Opérateur de complément logique, noté « ! »

Les opérateurs unaires sont assez différents des opérateurs binaires, qui acceptent deux opérandes. Ces opérateurs sont comme des symboles spéciaux utilisés pour exécuter certaines opérations sur un opérande ; l'opérande ici sont des variables et des valeurs.

1. Unaire Plus

Renvoie simplement la valeur comme positive. Quelle que soit la valeur, unaire plus ne renverra pas de forme négative.

2. Unaire Moins

Comme les opérateurs Plus renvoient la valeur positive, Unary Minus renvoie la forme négative de la même valeur. Pour les opérateurs unaires expliqués ci-dessus, nous montrerons un exemple dans lequel nous implémenterons les opérateurs unaires plus et moins.

Code :

class unary_ops {
public static void main(String[] args) {
int num = 6;
num = +num;
System.out.println(num);
num = -num;
System.out.println(num);
}
}

Interprétations du code : Nous avons démontré les opérateurs unaires plus et moins dans l'exemple ci-dessus. Nous avons notre classe, puis la classe principale à l'intérieur, et nous avons déclaré un entier simple avec une valeur de 6. Ensuite, nous avons attribué le num à l'opérateur Unary Plus. Et nous avons ensuite imprimé le résultat, qui sera simple et clair 6. Ensuite, nous avons passé la même variable à l'opérateur Unary Moins, et la valeur change ici. Nous avons imprimé le résultat avec l'instruction print, qui devrait être -6, ce qui signifie moins 6. Lors de l'exécution du code ci-dessus, 6 et -6 sont le résultat attendu.

Sortie :

3. Opérateur d'incrément unaire

Comme son nom l'indique, cet opérateur unaire effectue l'opération d'incrémentation de la valeur de 1. Quelle que soit la valeur d'une variable, après qu'elle soit passée avec l'opérateur d'incrémentation, la valeur est incrémentée de 1. L'opérateur d'incrémentation unaire peut être plus tard classé en deux types, en fonction du moment où l'opération d'incrémentation se produit :

• Post-incrémentation : La valeur est d'abord traitée puis incrémentée. En post-incrémentation, quelle que soit la valeur, elle est d'abord utilisée à des fins informatiques, puis la valeur est incrémentée de un.
• Pré-Incrément : Au contraire, le Pré-incrément fait d'abord l'incrément, puis les opérations de calcul sont exécutées sur la valeur incrémentée.

4. Opérateur de décrémentation unaire

Comme l'opérateur Incrément augmente la valeur de un, l'opérateur de décrémentation unaire diminue la valeur de la variable de 1.

Semblable à l'opérateur d'incrémentation, l'opérateur de décrémentation a deux variétés :

• Post-Décrémentation : En utilisant l'opérateur de décrémentation sous forme de publication, la valeur est d'abord utilisée puis mise à jour.
• Pré-Décrémentation : Avec la forme de préfixe, la valeur est d'abord décrémentée puis utilisée pour toutes les opérations informatiques.

Démontrer l'utilisation des opérateurs d'incrémentation et de décrémentation mentionnés ci-dessus.

Code :

class unary_ops {
public static void main(String[] args) {
int num = 6;
num--;
System.out.println(num);
num++;
System.out.println(num);
}
}

Interprétation du code : Même classe avec la classe principale à l'intérieur, nombre entier avec la valeur de 5. Tout d'abord, nous avons passé l'opérateur de décrémentation à la variable, comme le nombre, et la valeur sera imprimée. Plus tard, nous transmettons la même valeur calculée à l'opérateur d'incrémentation et le résultat sera imprimé. Notre valeur d'origine est 6, et lors de l'exécution, le résultat sera « 5 6 ». Il sera d'abord décrémenté à 5, puis incrémenté de 1, le ramenant à nouveau à 6.

Sortie :

5. Opérateur de complément logique

Cet opérateur est utilisé pour inverser la valeur booléenne de n'importe quelle variable. Ex. Si la valeur booléenne d’une variable est vraie, elle sera inversée en faux après avoir été transmise avec un opérateur logique.

Code:

class unary_ops {
public static void main(String[] args) {
boolean bvalue = false;
System.out.println(bvalue);
System.out.println(!bvalue);
}
}

Code Interpretation: We demonstrated a Logical Complement operator using the Boolean data type. In our class, we have the main class within and our simple boolean variable, which holds the value of false. In our first print statement, we printed the original value and later passed the logical complement operator; as you can see, we’ve used the “!” symbol. This implementation will invert the value of the boolean variable, resulting in a changed output of true.

Output:

Below are the cases, which if executed, will result in errors:

• It is important to understand that these increment and decrement operators can only be used with variables, not constant values. Implementing these operators with contact values will result in an error. Another interesting point is how an unexpected error will occur if you use these operators in nested form. Not acceptable nested form is: int x = ++(++y);
• Operations on Final Variables: Declaring a final variable is as easy as adding a final keyword before the data type, which results in a type variable whose value cannot be changed. Keeping this in mind, we cannot implement these operators on the final variable, as these operations result in a change in value.
• For Boolean values: We can implement these operators on all types of primitive data types except Boolean values.
• In case of any of the scenarios mentioned above, it will result in errors.

Conclusion

There are 5 unary operators and with pre and post as two varieties. We understood each operator with a specific definition and usage. Along with an explanation, we have programs for respective operators, screenshots, and code interpretation. And some essential tips to wisely implement these operators.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!