Correction de l'erreur de types d'opérandes incorrects en Java

1. Mauvais types d’opérandes pour l’opérateur & en Java
2. Mauvais types d’opérandes pour l’opérateur && en Java
3. Mauvais types d’opérandes pour l’opérateur == en Java
4. Mauvais types d’opérandes pour l’opérateur <= en Java

Ce tutoriel présente l’erreur mauvais types d'opérandes pour les opérateurs binaires en Java.

Un opérateur binaire est un opérateur qui nécessite deux opérandes. Les opérateurs tels que les opérateurs arithmétiques et les opérateurs relationnels sont appelés opérateurs binaires.

Les opérateurs jouent un rôle vital dans la programmation, et parfois, un opérateur binaire peut donner une erreur bad operand types en raison d’une mauvaise utilisation. L’erreur bad operand types est une erreur de compilation lorsque les deux types d’opérandes sont incompatibles.

Par exemple, nous obtiendrons cette erreur lors de la comparaison d’une chaîne avec un entier. Cet article examinera différents exemples de la façon dont cette erreur se produit et comment la résoudre.

Parfois, l’ordre de priorité des opérateurs peut également conduire à des types d’opérateurs incompatibles et entraîner une erreur dans la console.

Mauvais types d’opérandes pour l’opérateur & en Java

Commençons par comprendre le cas le plus courant où une Bad Operand Types peut se produire dans le code Java. Regardez un exemple de code ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    if (x & 21 == 1) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

MyClass.java:4: error: bad operand types for binary operator '&'
      if( x & 21 == 1){
            ^
  first type:  int
  second type: boolean
1 error

Cette erreur se produit car la priorité de l’opérateur == (égal) est supérieure à celle de l’opérateur &. Ceci conduit à l’évaluation 21 == 1, qui nous donne une valeur booléenne.

Maintenant, notez que le & a un opérande entier et un booléen. Comme les deux opérateurs sont de types différents, l’opérateur & ne peut pas fonctionner, nous obtenons donc une erreur.

Nous utiliserons des parenthèses pour indiquer que x & 21 doit être évalué en premier pour résoudre cette erreur. Regardez le code modifié ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    if ((x & 21) == 1) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

if block executing

Mauvais types d’opérandes pour l’opérateur && en Java

De même, si vous travaillez avec l’opérateur logique && (et), vous pouvez rencontrer une erreur bad operand types dans certains cas, comme dans l’exemple de code ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    if ((x > 10) && (x * 5)) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

MyClass.java:4: error: bad operand types for binary operator '&&'
      if((x > 10) && (x*5)){
                  ^
  first type:  boolean
  second type: int
1 error

Cette erreur se produit car l’opérande && attend deux opérandes booléens.

Ici, l’expression x * 5 donne une valeur entière. Par conséquent, l’opérateur && a ici un opérande entier et nous donne l’erreur bad operand types.

Pour résoudre cette erreur, nous allons modifier ce code tel que x * 5==21 qui renvoie une valeur booléenne. Regardez le code modifié ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    if ((x > 10) && (x * 5 == 21)) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

else block executing

Mauvais types d’opérandes pour l’opérateur == en Java

Vous pouvez obtenir la même erreur lorsque vous travaillez avec l’opérateur égal à ==. Cela peut donner une mauvaise erreur d’opérateur si les deux opérandes passés sont de types différents.

Regardez l’exemple ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    String y = "43";
    if (x == y) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

MyClass.java:5: error: bad operand types for binary operator '=='
      if(x == y){
           ^
  first type:  int
  second type: String
1 error

Cette erreur se produit car les opérandes de l’opérateur égal == sont de types différents. L’un est une chaîne et l’autre est un entier.

Pour résoudre cette erreur, nous devrons convertir l’un d’entre eux pour obtenir les mêmes types de données. Si nous convertissons des entiers en chaînes, la comparaison se fera dans l’ordre lexicologique.

Nous allons donc convertir string en int. Regardez le code modifié ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    String y = "43";
    if (x == Integer.parseInt(y)) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

if block executing

Mauvais types d’opérandes pour l’opérateur <= en Java

Comme dans l’exemple de cas précédent, l’opérateur <= (inférieur à égal à) peut également donner une erreur Bad Operand Types lorsque les deux opérandes sont de types différents. Regardez l’exemple ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    String y = "43";
    if (x <= y) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

MyClass.java:5: error: bad operand types for binary operator '<='
      if(x <= y){
           ^
  first type:  int
  second type: String
1 error

Pour résoudre cette erreur, nous devrons convertir l’un d’entre eux pour obtenir les mêmes types de données. Regardez le code modifié ci-dessous :

public class MyClass {
  public static void main(String args[]) {
    int x = 43;
    String y = "43";
    if (x <= Integer.parseInt(y)) {
      System.out.println("if block executing");
    } else {
      System.out.println("else block executing");
    }
  }
}

Production :

if block executing