Opérateurs unaires à Java | Expliqué

Java soutient diverses catégories d'opérateurs comme l'arithmétique, relationnelle, unaire, etc. Les opérateurs unaires agissent différemment des autres opérateurs car ils ne nécessitent qu'un seul opérande pour effectuer une opération spécifique. Les opérateurs unaires sont utilisés pour modifier le signe de l'opérande, incrémenter / décrémenter un opérande ou inverser une valeur booléenne. Ce guide des opérateurs unaires servirait les résultats d'apprentissage suivants:

• prendre conscience du fonctionnement des opérateurs unaires
• Utilisation de plusieurs opérateurs unaires à Java

Comment fonctionnent les opérateurs unaires en Java

La syntaxe de chaque opérateur unaire soutenu par Java est définie ici qui vous aidera à obtenir le flux de travail de base des opérateurs unaires.

Plus (+): Cet opérateur est pratiqué pour représenter l'opérande positif. La syntaxe suivante est suivie pour l'utiliser:

+opérande;

Moins(-): Cet opérateur modifie le signe d'un opérande et est utilisé en suivant la syntaxe fournie ci-dessous:

-opérande;

Incrément (++): Cet opérateur unaire ajoute 1 à l'opérande en préfixant ou en posant la fixation du «++”À l'opérande. La syntaxe suivante fait référence à l'incrément post-fixe et préfixe:

++opérande; // Incrément préfixe
opérande ++; // Incrément post-fixe

Diminution (-): La décrément unaire soustrait 1 de la valeur actuelle de la variable / valeur. Il peut être utilisé en préfixant ou en après la fixation du «-» à un opérand. La syntaxe fournie ci-dessous est utilisée pour une décrémentation unaire:

--opérande; // Préfixe décrément
opérande--; // Postfix décrément

Note: Si une variable est associée à un post-fixe, cela signifie que la variable sera d'abord utilisée pour l'informatique, puis sa valeur sera incrémentée / décrémentée. Tandis que le préfixe incrémente / diminue la valeur avant de calculer.

Complément logique (!): Cet opérateur est applicable sur les valeurs booléennes et les modifie de vrai à False et vice versa. La syntaxe fournie ci-dessous est suivie pour cela:

!opérande;

Comment utiliser les opérateurs unaires en Java

Cette section fournit plusieurs exemples Java qui démontrent l'utilisation des opérateurs unaires en Java.

Utilisation de l'Unary Plus: L'Unary Plus ne modifie pas la valeur car le signe positif est facultatif et donc il n'est affiché nulle part après l'affectation. Le code Java suivant déclare une variable A avec +5, mais lorsqu'elle est utilisée après cela, le signe positif est exempté.

Package NewPack;
classe publique unop
public static void main (String [] args)
int a = + 5;
Système.dehors.println (a);

La sortie montre que le signe positif est exempté lorsque le un est imprimé.

En utilisant unary moins: Le code Java fourni ci-dessous pratiquait les moins unaires sur des valeurs positives et négatives.

Package NewPack;
classe publique unop
public static void main (String [] args)
int a = 5, b = -6;
// en utilisant unary moins sur un
a = - (a);
Système.dehors.println (a);
// en utilisant unary moins sur b
b = - (b);
Système.dehors.println (b);

Le code est décrit ci-dessous:

• initialiser un Aussi positif et b comme valeur négative
• appliqué unary moins sur un et mettre à jour un
• imprime la nouvelle valeur de un
• appliqué unary moins sur b et mettre à jour la valeur de b
• imprime la nouvelle valeur de b

La sortie du code est fournie ci-dessous:

Utilisation de l'incrément préfixe et post-fixe: Les opérateurs d'incrément préfix et post-fixe incrément la valeur de 1. Mais le préfixe et le post-fixe sont utilisés selon leurs besoins, car le préfixe incréments avant l'exécution et le post-fixe n'incrémente la valeur après l'exécution de la variable.

Pour afficher l'utilisation de la postfix et de l'incrément de préfixe, les lignes suivantes du code Java sont exécutées:

Package NewPack;
classe publique unop
public static void main (String [] args)
int x = 99, y = 9;
// en utilisant l'incrément préfixe unaire sur x
++X;
Système.dehors.println (x);
// en utilisant l'incrément post-fixe unaire sur Y
y ++;
Système.dehors.println (y);

Le code est décrit comme:

• initialise deux variables X et y
• Ingmentation du préfixe appliqué sur X
• imprime la valeur après l'incrément
• en utilisant une augmentation de postfix sur y
• imprime la valeur incrémentée de y

La sortie du code est fournie ci-dessous:

Utilisation du préfixe et de la décrémentation du post-fixe: Le concept de diminution est le même que l'incrément, cependant, il diminue la valeur de 1. Le code fourni ci-dessous diminue la valeur des variables par préfixe / post-fixe -:

Package NewPack;
classe publique unop
public static void main (String [] args)
int a = 20, b = 10;
// en utilisant un préfixe unaire décrément sur un
--un;
Système.dehors.println (a);
// en utilisant un post-fixe unary décrément sur b
b--;
Système.dehors.println (b);

Le code ci-dessus,

• Déclarer d'abord deux variables un et b
• en utilisant le préfixe décrément et imprimer une nouvelle valeur de un
• Utilisation de PostFix Decmenment et affiche la valeur mise à jour de b

La sortie du code est fournie ci-dessous:

Utilisation du complément logique: L'opérateur de complément logique inverse l'ordre d'une valeur booléenne. Le code Java suivant exerce le booléen faux à vrai et vice versa:

Package NewPack;
classe publique unop
public static void main (String [] args)
// déclarant une variable booléenne
boolean bool1 = true, bool2 = false;
// Utilisation de l'opérateur de complément logique sur bool1
bool1 =!bool1;
Système.dehors.println (bool1);
// Utilisation de l'opérateur de complément logique sur bool2
bool2 =!bool2;
Système.dehors.println (bool2);

Le code est décrit ci-dessous:

• déclare deux variables booléennes bool1 et bool2
• s'applique "!»Opérateur sur bool1 et met à jour la valeur de bool1
• s'applique "!»Opérateur sur bool2 et met à jour la valeur de bool2

La sortie du code s'affiche ci-dessous:

Conclusion

Les opérateurs unaires vous permettent de modifier le signe, d'effectuer une incrémentation / décrément ou de modifier la valeur booléenne (vrai / false). Cet article fournit le travail ainsi que l'utilisation des opérateurs unaires en Java. Vous auriez appris la syntaxe de base de tous les opérateurs unaires. Pour une meilleure compréhension, les opérateurs unaires sont exercés en utilisant des exemples de code Java.