Operadores Unary en Java | Explicado

Java admite varias categorías de operadores como aritmética, relacional, unary, etc. Los operadores unaros actúan de manera diferente a otros operadores, ya que solo requieren un operando para realizar una operación específica. Los operadores unarios se utilizan para cambiar el signo del operando, incremento/disminución de un operando o revertir un valor booleano. Esta guía de operadores unarios serviría a los siguientes resultados de aprendizaje:

• Conociendo el funcionamiento de los operadores unary
• Usando varios operadores unaros en Java

Cómo funcionan los operadores unary en Java

Aquí se define la sintaxis de cada operador unario compatible con Java que lo ayudaría a obtener el flujo de trabajo básico de operadores unarios.

Más (+): Este operador se practica para representar un operando positivo. Se sigue la siguiente sintaxis para usar esto:

+operando;

Menos(-): Este operador cambia el signo de un operando y se utiliza siguiendo la sintaxis que se proporciona a continuación:

-operando;

Incremento (++): Este operador unario agrega 1 al operando mediante el prefijo o publica la reparación del "++"A la operando. La siguiente sintaxis se refiere al incremento Postfix y de prefijo:

++operando; // Incremento de prefijo
operando ++; // incremento postfix

Decremento(-): La disminución unaria resta 1 del valor actual de la variable/valor. Se puede utilizar prefijo o publicar la reparación del "-" a un operando. La sintaxis proporcionada a continuación se usa para una disminución unaria:

--operando; // Decremento de prefijo
operando--; // DISMACIÓN POSTFIM

Nota: Si una variable se asocia con PostFix, eso significa que la variable se usará primero para la computación y luego su valor se incrementará/disminuirá. Mientras que el prefijo incrementa el valor antes de calcular.

Complemento lógico (!): Este operador es aplicable en valores booleanos y los altera de verdadero a falso y viceversa. La sintaxis proporcionada a continuación se sigue para esto:

!operando;

Cómo usar los operadores unaros en Java

Esta sección proporciona varios ejemplos de Java que demuestran el uso de operadores unaros en Java.

Usando el unary plus: El Unary Plus no realiza un cambio en el valor, ya que el signo positivo es opcional y, por lo tanto, no se muestra en ningún lugar después de la asignación. El siguiente código Java declara una variable A con +5, pero cuando se usa después de eso, el signo positivo está exento.

Paquete Newpack;
clase pública UNOP
public static void main (string [] args)
int a =+5;
Sistema.afuera.println (a);

La salida muestra que el signo positivo está exento cuando el a está impreso.

Usando unary Minus: El código Java que se proporciona a continuación practica el Unario menos en los valores positivos y negativos.

Paquete Newpack;
clase pública UNOP
public static void main (string [] args)
int a = 5, b = -6;
// usando unary minus en un
a =-(a);
Sistema.afuera.println (a);
// usando unary menos en b
b =-(b);
Sistema.afuera.println (b);

El código se describe a continuación:

• inicializar a como positivo y b Como valor negativo
• aplicado unary menos en a y actualizar a
• Imprime el nuevo valor de a
• aplicado unary menos en b y actualizar el valor de b
• Imprime el nuevo valor de b

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

Uso de prefijo y incremento postfix: El prefijo y los operadores de incremento postfix incrementan el valor en 1. Pero el prefijo y el postfix se usan según sus requisitos, ya que el prefijo se incrementa antes de la ejecución y el postfix incrementa el valor después de la ejecución de la variable.

Para mostrar el uso del incremento Postfix y de prefijo, se ejecutan las siguientes líneas de código Java:

Paquete Newpack;
clase pública UNOP
public static void main (string [] args)
int x = 99, y = 9;
// Uso de un incremento de prefijo unario en x
++X;
Sistema.afuera.println (x);
// Uso de un incremento de postfix unario en y
y ++;
Sistema.afuera.println (y);

El código se describe como:

• inicializa dos variables X y Y
• incremento de prefijo aplicado en X
• Imprime el valor después del incremento
• Usar incremento postfix en Y
• Imprime el valor incrementado de Y

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

Uso de prefijo y disminución postfix: El concepto de disminución es el mismo que el incremento, sin embargo, disminuye el valor en 1. El código proporcionado a continuación disminuye el valor de las variables mediante el prefijo/postifación -::

Paquete Newpack;
clase pública UNOP
public static void main (string [] args)
int a = 20, b = 10;
// Uso de una disminución de prefijo unario en un
--a;
Sistema.afuera.println (a);
// Uso de una disminución posterior a Postfix en B
b--;
Sistema.afuera.println (b);

El código anterior,

• en primer lugar declara dos variables a y b
• Usar disminución de prefijo e imprimir un nuevo valor de a
• Uso de la disminución de Postfix y muestra el valor actualizado de b

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

Usando un complemento lógico: El operador del complemento lógico invierte el orden de un valor booleano. El siguiente código Java ejerce el booleano falso a verdadero y viceversa:

Paquete Newpack;
clase pública UNOP
public static void main (string [] args)
// declarando una variable booleana
boolean bool1 = true, bool2 = false;
// Uso del operador de complemento lógico en Bool1
bool1 =!bool1;
Sistema.afuera.println (bool1);
// Uso del operador de complemento lógico en Bool2
bool2 =!bool2;
Sistema.afuera.println (bool2);

El código se describe a continuación:

• declara dos variables booleanas bool1 y bool2
• aplica "!"Operador en bool1 y actualizaciones del valor de bool1
• aplica "!"Operador en bool2 y actualizaciones del valor de bool2

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

Conclusión

Los operadores unarios le permiten alterar el signo, realizar un incremento/disminución o cambiar el valor booleano (verdadero/falso). Este artículo proporciona el trabajo y el uso de operadores unaros en Java. Habrías aprendido la sintaxis básica de todos los operadores unaros. Para una mejor comprensión, los operadores unarios se ejercen utilizando ejemplos de código Java.