Operadores básicos en Java | Explicado

Java tiene muchos operadores que ayudan a realizar varias operaciones en variables/valores. Estos operadores se dividen en varios tipos y los operadores que realizan operaciones similares se colocan en la misma categoría.

Por ejemplo, los operadores Java que realizan suma, resta, división, multiplicación, etc. se colocan en la categoría aritmética de operadores. Del mismo modo, los operadores que proporcionan la relación entre las variables se colocan dentro de la categoría del operador relacional.

Este artículo enumera el uso y la aplicabilidad de los operadores básicos en Java. Entonces, comencemos.

¿Cuáles son los operadores básicos en Java?

Esta sección describe la funcionalidad de los operadores básicos en Java.

Operadores de Asignación

Estos operadores ayudan a asignar valor a una variable en Java. Esta acción de asignación se puede realizar utilizando uno de los siguientes operadores:

"=": funciona en dos operandos y asigna el valor colocado en el lado derecho a la variable escrita en el lado izquierdo.

"+=": agrega operandos de ambos lados y luego asigna el valor a la variable escrita en el lado izquierdo

"-=": Resta el operando colocado a la derecha desde la izquierda, y luego asigna el valor a la variable colocada en el lado izquierdo

"*=": multiplica ambos operandos y luego asigna la respuesta a la variable en el lado izquierdo

"/=": informa el resto dividiendo los operandos o dividiendo el operando izquierdo por un valor específico.

"%=": obtiene el resto usando este % primero, y luego la respuesta se asigna a la variable en el lado izquierdo.

Se pueden seguir las siguientes sintaxis:

operand1 = operandd2; // usando =
operand1 += operand2 // usando +=
operand1- = operand2 // usando -=
operand1 *= operand2 // usando *=
operand1 /= operand2 // usando /=
operand1 %= operand2 // usando %=

Operadores aritméticos

Esta categoría trata de las operaciones aritméticas y los siguientes operadores residen en esta categoría.

"+": Se usa para agregar dos variables/valores

"-": proporciona la diferencia entre dos variables/valor

"*": multiplica dos variables/valores

"/": Se utiliza para dividir una variable sobre otra y el cociente se muestra en la salida.

"%": informa el resto () de dos variables/valores

La sintaxis de estos operadores se proporciona a continuación, el Operand1 y Operand2 se refieren a las variables/valores. Se observa que se requieren dos operandos para llevar a cabo operaciones aritméticas.

operand1+operand2; //suma
operando1-operando2; //sustracción
operand1*operand2; //multiplicación
operand1/operand2; //división
operando1%operand2; //resto

Operadores unarios

Este tipo realiza varias operaciones en una variable/valor. Los operadores incluidos en esta categoría se describen a continuación:

"+": Asigna signo positivo a un operando (generalmente no se muestra un signo positivo, ya que es opcional)

"-": Cambia el signo de un operando

"++": incrementa el valor de un operando por 1. El operador de incremento se puede aplicar como postfix y prefijo

"-": El valor de una variable/valor es disminuido por 1. Como incremento, también se puede usar como prefijo o postfix

"!": El valor booleano (verdadero/falso) se invierte utilizando este operador

Puede consultar la sintaxis de estos operadores proporcionados a continuación:

+operando; // unary plus
-operando; // unary menos
++operando; // Incremento de prefijo
operando ++; // incremento postfix
operando--; // DISMACIÓN POSTFIM
--operando; // Decremento de prefijo
!operando; // complemento lógico

Operadores logicos

Estos operadores ayudan a realizar operaciones lógicas como y, y no. Estos se describen a continuación:

Y(&&): Esto funciona en dos variables/valores, devuelve verdadero si ambas variables son verdaderas y falsas en otros casos.

O (||): Este operador construye lógica de tal manera que, si ambos valores son falsos, el resultado sería falso de lo contrario.

NO (!) Esto también se refiere a la categoría unaria y devuelve resultados falsos/verdaderos

Puede consultar las siguientes sintaxis para usar operadores lógicos:

operand1 && operand2 // lógico y
Operand1 || operand2 // lógico o
!operando // lógico no

Operadores de bit a bit

La clase de este operador se ocupa de los valores binarios y, por lo tanto, todas las operaciones se realizan poco a poco. y se practican los siguientes operadores:

"&": Esto se conoce como binario y funciona igual que los valores lógicos y binarios.

"|": Esto también funciona en el mismo patrón que lógico o, pero realiza la operación bit a poco.

"^": Esto se conoce como XOR, devuelve verdadero si ambos valores son diferentes y devuelven falsos si ambos valores son los mismos.

"~": Este operador cambia el bit de 0 a 1 y 1 a 0

"<<“: Este operador de cambio izquierdo cambia el número de bits a la izquierda. El usuario decide el número de bits y puede ser cualquier número.

">>": Los cambios de operador de cambio derecho elimina el número de bits del lado derecho.

">>>": Esto se conoce como cambio derecho sin cifras y cambia el número de bits por "0"

Las siguientes sintaxis se refieren a los operadores bit a bit:

operando1 | operando2; // bitwise o
operand1 y operand2; // bitwise y
operand1 ^ operand2; // xor bit a bit
~ operando; // complemento bit a bit
operando<operando >> número; // cambio bit a bit a la derecha
operando >>> número; // Shift bitwise sin firmar a la derecha sin firmar

Operadores relacionales

Esta categoría se refiere a relacionarse más de una variable utilizando símbolos específicos. Estos operadores ayudan a tomar decisiones en la programación de Java.

"==": Se practica este operador verificando la igualdad de dos operandos

"!= ": Se utiliza para verificar que la desigualdad de los operandos

"<“: practicó verificar menos que la relación entre dos operandos

">": se usa para verificar el operando izquierdo es más alto o no

"> =": para verificar que el operando izquierdo sea "mayor o igual" a la derecha o no

"<=”: se practica verificación si la variable izquierda es menor o igual a la derecha

Los operadores relacionales se pueden practicar utilizando las sintaxis proporcionadas a continuación:

operand1 == operand2; //igual a
operando1!= operando2; //no igual a
operand1> operand2; //mas grande que
operando1operand1> = operand2; //Mayor qué o igual a
operando1<=operand2; //less than or equal to

Cómo usar operadores básicos en Java

Esta sección proporciona el uso de operadores básicos en Java. Cada ejemplo demuestra el código Java que utiliza operadores de una categoría específica.

Ejemplo 1: Uso de los operadores de asignación

El siguiente código Java practica varios operadores de asignación en variables.

Paquete Newpack;
Asignación de clase pública
public static void main (string [] args)
// usando "=" para asignar valores
int a = 3, b = 4, c = 5, d = 6, e = 7;
// usando "+=" en un
a+= 3;
Sistema.afuera.println ("nuevo valor de a sería:" +a);
// usando "-=" en B
b- = 3;
Sistema.afuera.println ("El nuevo valor de B sería:" +B);
// usando "*=" en c
C*= 2;
Sistema.afuera.println ("Nuevo valor de C sería:" +C);
// usando "/=" en D
d/= 2;
Sistema.afuera.println ("Nuevo valor de D sería:" +D);
// usando "%=" en e
e%= 2;
Sistema.afuera.println ("Nuevo valor de E sería:" +E);

El código mencionado anteriormente se describe aquí:

• En primer lugar, los valores se asignan a variables usando =
• La instrucción "A+= 3" agrega 3 al valor actual de un
• restando 3 de b usando "-="
• multiplica el valor de c por 2 usando "*="
• divide el valor de d por 2 usando "/="
• El valor de E se divide por 2 y luego el resto se almacena como un nuevo valor de E.

La salida del código se proporciona a continuación:

Ejemplo 2: Uso de operadores aritméticos

El siguiente código Java realiza operaciones aritméticas en dos números a = 5 y b = 11.

Paquete Newpack;
clase pública arithop
public static void main (string [] args)
// Inicialización de variables
int a = 5, b = 11;
// usando + en A y B
Sistema.afuera.println ("a+b ="+(a+b));
// Usando - en A y B
Sistema.afuera.println ("a-b =" + (a-b));
// usando * en A y B
Sistema.afuera.println ("a-b =" + (a*b));
// usando /en A y B
Sistema.afuera.println ("a/b =" + (b/a));
// usando % en A y B
Sistema.afuera.println ("a%b =" + (a%b));

En el código indicado anteriormente, las variables se inicializan primero y luego cada línea representa la aplicación de un operador de asignación diferente.

La salida se proporciona a continuación:

Ejemplo 3: Uso de operadores relacionales

El siguiente código Java practica los operadores relacionales en dos variables x = 3 e y = 5.

Paquete Newpack;
clase pública Relop
public static void main (string [] args)
// Inicialización de variables
int x = 3, y = 5;
//usando < operator
Sistema.afuera.println ("es x menos que y? " + (X operador
Sistema.afuera.println ("es x mayor que y? " + (x> y));
// usando == operador
Sistema.afuera.println ("es x igual a y? " + (x == y));

El código escrito anteriormente implementa tres operadores relacionales en X e Y. Del mismo modo, el código se describe como:

• inicializa dos variables x e y
• informa el resultado de x
• Imprime resultados verdaderos o falsos para la condición x> y
• verifica e imprime la igualdad de x e y

La salida del código se proporciona a continuación:

Ejemplo 4: Uso de operadores lógicos

El siguiente código Java practica los operadores lógicos en la declaración condicional if-else.

Paquete Newpack;
Logop de clase pública
public static void main (string [] args)
int a = 4, b = 5, c = 5;
if (a == b || (b == c && c!= a))

Sistema.afuera.println ("La condición es verdadera");

demás

Sistema.afuera.println ("La condición es falsa");

El código anterior se describe como.

• Se inicializan tres variables
• En la condición if, utilizamos el operador y (&&) entre B == C y C!= A. Además, esta declaración se une con A == B usando o (||) operador.
• La condición indicada anteriormente es verdadera, por lo tanto, el bloque if de la declaración if-else se ejecutaría.

La salida del código se muestra en la imagen a continuación:

Ejemplo 5: Uso de operadores unarios

Los operadores unarios se practican en el siguiente código Java.

Paquete Newpack;
clase pública UNOP
public static void main (string [] args)
// Inicialización de variables
int a = 4, b = 6;
// usando unary minus en un
Sistema.afuera.println ("Valor actualizado de A es:" + (-a));
// Uso de un incremento de prefijo en B
Sistema.afuera.println ("El valor actualizado de B es:"+(++ b));

La descripción del código es:

• Se inicializan dos variables A y B
• Imprime la respuesta después de aplicar unary minus en un
• muestra el resultado después de aplicar el operador de incremento de prefijo en B

La salida del código se proporciona aquí:

Ejemplo 6: Uso de operadores bitwise

El siguiente código Java implementa varios operadores bit a las variables/valores.

Paquete Newpack;
Bitop de clase pública
public static void main (string [] args)
int a = 3, b = 5;
// Uso del operador de cambio de izquierda bitwise en un
Sistema.afuera.println ("La respuesta es:" + (a3));

El código se describe como:

• Las variables A y B se inicializan
• usó el operador de cambio de izquierda en un y la respuesta está impresa. El binario del número 3 sería desplazado a la izquierda por 2 bits.
• Imprime la respuesta después de aplicar el operador de cambio correcto en B. Las 3bits del número B se eliminarían del lado derecho del binario del número 3.

La salida del código es:

Conclusión

Los operadores básicos en Java son los operadores que se utilizan con frecuencia en los programas de Java. Java admite una larga lista de operadores que ayudan a realizar diversas operaciones en variables/valores. Los operadores que tienen una aplicabilidad similar se colocan en la misma categoría. Por ejemplo, los operadores que definen las relaciones se pueden encontrar en la categoría relacional de operadores. Este artículo enumera los operadores básicos en Java y proporciona su aplicación utilizando el código Java. Habría aprendido la descripción general y la aplicabilidad preliminar de todos los operadores básicos en Java.