Opérateur conditionnel en Java

Les opérateurs conditionnels en Java sont ceux qui utilisent trois opérandes et sont utilisés pour travailler sur des conditions. Il s'agit d'un opérateur unique utilisé à la place des instructions If-Else. Le principal avantage de l’opérateur conditionnel est qu’il peut être complété en une seule phrase, alors que l’instruction if-else utilise plusieurs lignes de code. Cependant, l'opérateur conditionnel présente également un inconvénient : il ne peut pas être utilisé pour plusieurs conditions ou, en d'autres termes, lorsque plusieurs lignes de code sont utilisées, le programme devient assez complexe et très difficile à comprendre. Les opérateurs conditionnels sont également appelés opérateurs ternaires en Java.

Commencez votre cours de développement de logiciels libres

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

Syntaxe de l'opérateur conditionnel

Il existe une syntaxe spécifique pour travailler avec des opérateurs ternaires ou conditionnels en Java. La syntaxe d'utilisation des opérateurs ternaires est donnée ci-dessous. Généralement, un opérateur conditionnel est utilisé dans un main() ou une fonction spécifique utilisée pour renvoyer certaines valeurs une fois la condition exécutée. Une fois la condition exécutée, l'expression qui satisfait la condition est exécutée et renvoyée ou imprimée selon les commandes de l'utilisateur.

Variable=Expression1 ? Expression2 : Expression3

L'opérateur conditionnel ci-dessus fonctionne de la même manière qu'une instruction If-Else. L'instruction if-else correspondante est donnée ci-dessous :

Syntaxe :

if(Expression 1)
{
Variable= Expression 2;
}
else
{
Variable= Expression 3;
}

Organigramme :

Exemples d'opérateur conditionnel en Java

Voici les exemples de l'opérateur conditionnel ci-dessous :

Exemple n°1

Dans l'exemple 1, nous allons voir le plus grand entre deux nombres en utilisant des opérateurs ternaires. Nous verrons l'entrée de deux variables qui sont des nombres, puis vérifierons quel nombre est le plus grand dans ce contexte. Nous pouvons voir l'exemple ci-dessous, qui a été écrit ci-dessous.

Code :

// Java program to find largest among two numbers using ternary operator
import java.io.*;
class Ternary
{
public static void main(String[] args)throws IOException
{
// Taking user input of the variables
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter first number " );
int n1= Integer.parseInt(br.readLine());
System.out.println("Enter second number " );
int n2= Integer.parseInt(br.readLine());
int max;//Variable to store the larger of the two values
// Larger among n1 and n2
max = (n1 > n2) ? n1 : n2; //Using ternary operator
// Print the largest number
System.out.println("Larger of the two numbers is " + max);
}
}

Dans le code ci-dessus, nous voyons comment deux nombres sont extraits d'un utilisateur, puis l'opération est effectuée pour calculer le plus grand parmi les deux nombres. Nous verrons deux résultats produits par l’opération. Tout d’abord, nous entrerons les nombres sous la forme (100 200), puis nous entrerons les nombres sous la forme (500, 200). Nous verrons le résultat en conséquence.

Sortie :

Exemple n°2

Dans l'exemple 2, nous verrons une opération effectuée sur deux variables, qui sont toutes deux des nombres. Si le premier nombre est supérieur au deuxième nombre, alors les deux nombres sont ajoutés et imprimés comme indiqué par l'utilisateur. Cependant, si le premier nombre est inférieur au deuxième nombre, alors le deuxième nombre est soustrait du premier nombre et le résultat est imprimé.

Code :

// Java code to illustrate ternary operator
import java.io.*;
class Ternary2
{
public static void main(String[] args)throws IOException
{
// variable declaration
int res;
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.println(" Enter First number: ");
int n1= Integer.parseInt(br.readLine());
System.out.println(" Enter Second number: ");
int n2= Integer.parseInt(br.readLine());
// Performing ternary operation
res = (n1 > n2) ? (n1 + n2) : (n1 - n2);//Calculating the sum
// Print the result
System.out.println("Result = " + res);
}
}

Nous allons voir une seule sortie dans ce cas. Nous allons saisir deux nombres sous la forme (100,50). Comme le premier nombre est supérieur au deuxième nombre, le programme doit imprimer la somme des deux variables, qui constitue la sortie. Nous voyons l’exemple de sortie, présenté ci-dessous.

Sortie :

Exemple #3

Dans le troisième exemple, nous verrons la saisie de trois nombres par l'utilisateur, et nous allons vérifier le plus grand des trois nombres. De même, nous pouvons trouver le plus petit des trois nombres en utilisant une logique similaire. L'avantage d'utiliser un opérateur ternaire est qu'il économise une grande quantité de code dans le programme et permet au code de s'exécuter très rapidement et de manière fluide.

Code :

//Program to Find greatest of three numbers using Conditional Operator
import java.io.*;
public class ConditionalOperator
{
public static void main(String[] args)throws IOException
{
int a,b,c,result;
//Taking input from the user
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter the Three Number : "); //prompt for input
a=Integer.parseInt(br.readLine());   //Read First number
b=Integer.parseInt(br.readLine());    //Read Second number
c=Integer.parseInt(br.readLine());    //Read third number
//Calculate the result based on conditional operator
result = (a>b)? ((a>c)?a:c) : ((b>c)?b:c);
System.out.println( result  + " is Greatest");//Printing the greatest number
}
}

Maintenant, nous allons saisir trois nombres (100 200 300) et nous verrons le plus grand des trois nombres, que le programme imprimera. Selon le programme, le plus grand des trois nombres est imprimé et 300 est le plus grand, qui est imprimé en douceur. Ainsi le programme fonctionne parfaitement.

Sortie :

Exemple n°4

Dans l'exemple 4, nous allons vérifier le plus petit des trois nombres saisis par l'utilisateur. L'exemple de code est donné ci-dessous.

Code :

//Program to Find greatest of three numbers using Conditional Operator
import java.io.*;
public class ConditionalOperator
{
public static void main(String[] args)throws IOException
{
int a,b,c,result;
//Taking input from the user
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter the Three Number : "); //prompt for input
a=Integer.parseInt(br.readLine());   //Read First number
b=Integer.parseInt(br.readLine());    //Read Second number
c=Integer.parseInt(br.readLine());    //Read third number
//Calculate the result based on conditional operator
result = (a<b)? ((a<c)?a:c) : ((b<c)?b:c);
System.out.println( result  + " is Lowest");//Printing the greatest number
}
}

Nous allons saisir trois nombres et vérifier le plus bas d'entre eux. Les trois nombres sont (25,50,75) et le nombre le plus bas doit être 25, comme indiqué dans le résultat ci-dessous.

Sortie :

Conclusion

Dans cet article, nous rencontrons différents programmes mettant en évidence différents aspects des opérateurs conditionnels, et nous voyons les différentes fonctionnalités ainsi que les différents avantages de l'utilisation des opérateurs conditionnels. Les opérateurs conditionnels sont uniques en matière de programmation dans le langage de programmation Java. Ils remplacent la condition If-Else et exécutent en douceur les instructions basées sur les conditions du programme.

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!