Operadores numéricos en Java

¡Hola! Hoy consideraremos un tema muy importante, a saber, los operadores numéricos en Java . En la programación, los números están en todas partes. Si profundiza y recuerda la escuela secundaria, puede recordar que una computadora representa toda la información en un formato numérico: combinaciones de ceros y unos, también conocido como código binario. Hay muchos operadores numéricos en la programación, así que usaremos ejemplos para explorar los más importantes :) Empecemos con los más simples: los operadores aritméticos . Estos son los conocidos operadores de suma ( +), resta ( -), multiplicación ( *) y división ( /).

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Salida de consola: 1032 966 32967 30 Ya usaste todo esto. A este grupo se le puede agregar el %operador resto o módulo ( ).

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Salida de la consola: 1 En este ejemplo, dividimos 33 entre 2. Esto produce 16, con una "cola" extra (uno) que no es divisible por 2. Esta "cola" es el resultado de la operación "resto de la división". Java también implementa operadores de comparación/relacionales (al igual que en matemáticas). Probablemente también te sean familiares de la escuela:

• igual a ( ==)
• mayor que ( >)
• menos que ( <)
• mayor o igual que ( >=)
• menor o igual que ( <=)
• no es igual ( !=)

Aquí debe prestar atención a un punto importante que hace que muchos principiantes cometan errores. El operador "igual" se escribe ==, no =. En Java, un solo =es el operador de asignación , que se usa cuando a una variable se le asigna un número, una cadena o el valor de otra variable.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Salida de la consola: 999 ¡Vaya! Obviamente, este no es el resultado que esperábamos. Es un tipo de datos completamente diferente: esperábamos ver un valor booleano , pero obtuvimos un número. Todo porque usamos un operador de asignación entre paréntesis en lugar de una comparación . Se asignó x=y el valor de (999) a la variable y luego mostramos el valor de . Esta es la forma correcta de hacerlo: yxx

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Salida de la consola: falso ¡ Ahora hemos comparado los dos números correctamente! :) Aquí hay otra característica del operador de asignación ( =): se puede "encadenar" entre sí:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Salida de la consola: 256 Recuerde que la asignación es de derecha a izquierda . Esta expresión ( x = y = z) se ejecutará en pasos:

• y = z, eso es,y = 256
• x = y, eso es,x = 256

Operadores unarios.

Se les llama " unarios " de la palabra " uno ", que significa " uno ". Obtuvieron este nombre porque, a diferencia de los operadores anteriores, actúan sobre un solo número, no sobre varios. Éstas incluyen:

• Menos unario. Da la vuelta al signo del número.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Salida de la consola: -999 999 Usamos el operador menos unario dos veces. Como resultado, nuestro número fue primero negativo, ¡y luego volvió a ser positivo!

• Incremento (++) y decremento (--)

El ++operador aumenta un número en uno y el --operador reduce un número en la misma cantidad.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Salida de la consola: 1000 999 Esta notación puede resultarle familiar si ha oído hablar del lenguaje C++. Sus creadores usaron este interesante nombre para transmitir la idea de que "C++ es una extensión del lenguaje C". Una popular versión mejorada de Notepad se llama Notepad++ Aquí hay un punto importante. Hay dos tipos de operadores de incremento y decremento: posfijo y prefijo . x++- sufijo ++x- prefijo ¿Cuál es la diferencia fundamental entre poner los más/menos antes o después del número? Lo veremos en el siguiente ejemplo:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Salida de la consola: 999 ¡ Algo no está bien! Queríamos aumentar xen 1 y asignar el nuevo valor a la variable y. En otras palabras, y debería ser 1000. Pero en su lugar obtenemos algo más: 999. ¿Parece que x no se incrementó y que el operador de incremento no funcionó? Pero funcionó. Para convencerte, intenta mostrar xal final :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Salida de la consola: 999 1000 De hecho, precisamente por eso esta operación se llama postfijo: se realiza después de la expresión principal. Esto significa, en nuestro caso: int y = x++; y = xse realiza primero (y la variable yse inicializará con el valor de x), y solo entonces se x++ejecutará. ¿Qué pasa si este no es el comportamiento que queremos? Entonces necesitamos usar la notación de prefijo :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

En este caso, ++xse procesa primero y solo después y = x; ejecutado. Debe guardar esta diferencia en la memoria de inmediato para evitar cometer errores en un programa real donde el uso de postfijo en lugar de prefijo podría poner todo patas arriba :)

Operadores compuestos

Además, en Java existen los llamados operadores compuestos. Combinan dos operadores:

• Asignación
• Operadores aritméticos

Éstas incluyen:

• +=
• -=
• *=
• /=
• %=

Consideremos un ejemplo:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Salida de consola: 1032 x += y significa x = x + y. Los dos símbolos se usan consecutivamente por motivos de brevedad. Las combinaciones -=, *=y /=funcionan %=de manera similar.

Operadores logicos

Además de los operadores numéricos, Java también tiene operaciones que involucran valores booleanos ( verdadero y falso ). Estas operaciones se realizan mediante operadores lógicos.

• !- NO lógico . Cambia el valor de un booleano

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Salida de la consola: falso

• &&- AND lógico . Devuelve verdadero solo si ambos operandos son verdaderos.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Salida de la consola: falso verdadero El resultado de la primera operación es falso, porque uno de los operandos es falso, es decir 100 > 200, . Para devolver verdadero, el &&operador requiere que ambos operandos sean verdaderos (como es el caso en la segunda línea).

• ||- OR lógico . Devuelve verdadero cuando al menos uno de los operandos es verdadero.

Cuando usamos este operador, nuestro ejemplo anterior produce un resultado diferente:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Salida de la consola: verdadero La expresión 100 > 200sigue siendo falsa, pero para el operador OR es completamente suficiente que la primera parte ( 100 > 10) sea verdadera.