Solucione el error de tipos de operandos incorrectos en Java

1. Tipos de operandos incorrectos para el operador & en Java
2. Tipos de operandos incorrectos para el operador && en Java
3. Tipos de operandos incorrectos para el operador == en Java
4. Tipos de operandos incorrectos para el operador <= en Java

Este tutorial presenta el error de tipos de operandos incorrectos para operadores binarios en Java.

Un operador binario es un operador que requiere dos operandos. Los operadores como los operadores aritméticos y los operadores relacionales se denominan operadores binarios.

Los operadores juegan un papel vital en la programación y, a veces, un operador binario puede dar un error de bad operand types debido a un uso inadecuado. El error de bad operand types es un error en tiempo de compilación cuando ambos tipos de operandos son incompatibles.

Por ejemplo, obtendremos este error al comparar una cadena con un número entero. Este artículo analizará diferentes ejemplos de cómo se produce este error y cómo resolverlo.

A veces, el orden de precedencia de los operadores también puede generar tipos de operadores incompatibles y generar un error en la consola.

Tipos de operandos incorrectos para el operador & en Java

Primero comprendamos el caso más común en el que puede ocurrir un error de operador incorrecto en el código Java. Mira un código de ejemplo a continuación:

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");
    }
  }
}

Producción :

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

Este error ocurre porque la precedencia del operador == (igual) es mayor que la del operador &. Esto lleva a la evaluación 21 == 1, que nos da un valor booleano.

Ahora, observe que el & tiene un operando entero y uno booleano. Dado que ambos operadores son de tipos diferentes, el operador & no puede funcionar, por lo que obtenemos un error.

Usaremos paréntesis para indicar que x & 21 debe evaluarse primero para resolver este error. Mira el código modificado a continuación:

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");
    }
  }
}

Producción :

if block executing

Tipos de operandos incorrectos para el operador && en Java

Del mismo modo, si está trabajando con el operador lógico && (y), entonces puede encontrar un error de bad operand types en algunos casos como el siguiente código de ejemplo:

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");
    }
  }
}

Producción :

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

Este error ocurre porque el operando && espera dos operandos booleanos.

Aquí, la expresión x * 5 da un valor entero. Por lo tanto, el operador && aquí tiene un operando entero y nos da el error bad operand types.

Para resolver este error, modificaremos este código de modo que x * 5==21 que devuelva un valor booleano. Mira el código modificado a continuación:

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");
    }
  }
}

Producción :

else block executing

Tipos de operandos incorrectos para el operador == en Java

Puede obtener el mismo error al trabajar con el operador de igualdad ==. Puede dar un error de operador incorrecto si ambos operandos pasados ​​son de diferentes tipos.

Mira el ejemplo de abajo:

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");
    }
  }
}

Producción :

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

Este error ocurre porque los operandos del operador de igual a == son de diferentes tipos. Uno es una cadena y el otro es un número entero.

Para resolver este error, tendremos que convertir uno de ellos para obtener los mismos tipos de datos. Si convertimos enteros en cadenas, la comparación ocurrirá en orden lexicológico.

Entonces, convertiremos string a int. Mira el código modificado a continuación:

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");
    }
  }
}

Producción :

if block executing

Tipos de operandos incorrectos para el operador <= en Java

Al igual que el ejemplo del caso anterior, el operador <= (menor que igual a) también puede generar un error de Bad Operand Types cuando ambos operandos son de tipos diferentes. Mira el ejemplo de abajo:

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");
    }
  }
}

Producción :

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

Para resolver este error, tendremos que convertir uno de ellos para obtener los mismos tipos de datos. Mira el código modificado a continuación:

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");
    }
  }
}

Producción :

if block executing