Operadores unários em Java | Explicado

Java suporta várias categorias de operadores como aritmética, relacional, unário, etc. Os operadores unários agem de maneira diferente de outros operadores, pois exigem apenas um operando para realizar uma operação específica. Os operadores unários são usados ​​para alterar o sinal do operando, incrementar/diminuir um operando ou reverter um valor booleano. Este guia de operadores unários serviria os seguintes resultados de aprendizagem:

• Ficar ciente do funcionamento de operadores unários
• Usando vários operadores unários em Java

Como os operadores unários trabalham em java

A sintaxe de cada operador unário suportado por Java é definido aqui que o ajudaria a obter o fluxo de trabalho básico de operadores unários.

Mais (+): Este operador é praticado para representar operando positivo. A sintaxe a seguir é seguida para usar isso:

+operando;

Menos(-): Este operador altera o sinal de um operando e é usado seguindo a sintaxe fornecida abaixo:

-operando;

Incremento (++): Este operador unário adiciona 1 ao operando, prefixando ou pós -fixando o “++”Para o operando. A sintaxe a seguir refere -se ao incremento de pós -fix e prefixo:

++operando; // Incremento prefixo
operand ++; // incremento pós -fix

Decremento (-): O decréscimo unário subtraia 1 do valor atual da variável/valor. Pode ser usado prefixando ou pós-fixando o "-" para um operando. A sintaxe fornecida abaixo é usada para decréscimo unário:

--operando; // decremento prefixo
operando--; // decremento pós -fixo

Observação: Se uma variável estiver associada ao pós -fixo, significa que a variável será usada primeiro para computação e, em seguida. Enquanto o prefixo incrementos/diminui o valor antes da computação.

Complemento lógico (!): Este operador é aplicável aos valores booleanos e os altera de verdadeiro para falso e vice -versa. A sintaxe fornecida abaixo é seguida para isso:

!operando;

Como usar os operadores unários em Java

Esta seção fornece vários exemplos Java que demonstram o uso de operadores unários em Java.

Usando o UNARY Plus: O UNARY Plus não faz uma alteração no valor, pois o sinal positivo é opcional e, portanto, não é exibido em nenhum lugar após a atribuição. O código Java a seguir declara uma variável A com +5, mas quando é usado depois que o sinal positivo está isento.

pacote newpack;
classe pública unop
public static void main (string [] args)
int a =+5;
Sistema.fora.println (a);

A saída mostra que o sinal positivo está isento quando o a está impresso.

Usando unário menos: O código Java fornecido abaixo pratica o unário menos em valores positivos e negativos.

pacote newpack;
classe pública unop
public static void main (string [] args)
int a = 5, b = -6;
// usando unário menos em um
a =-(a);
Sistema.fora.println (a);
// usando unário menos em B
b =-(b);
Sistema.fora.println (b);

O código é descrito abaixo:

• inicializa a como positivo e b como um valor negativo
• aplicado unário menos a e atualizar a
• imprime o novo valor de a
• aplicado unário menos b e atualizar o valor de b
• imprime o novo valor de b

A saída do código é fornecida abaixo:

Usando prefixo e incremento pós -fix: Os operadores de incremento de prefixo e pós -fixo incrementam o valor em 1. Mas o prefixo e o pós -fixo são usados ​​de acordo com seus requisitos, pois os incrementos de prefixo antes da execução e pós -fixo incrementos do valor após a execução da variável.

Para mostrar o uso do incremento do Postfix e do Prefixo, as seguintes linhas do código Java são executadas:

pacote newpack;
classe pública unop
public static void main (string [] args)
int x = 99, y = 9;
// Usando incremento de prefixo unário em x
++x;
Sistema.fora.println (x);
// usando incremento pós -fixo unário em y
y ++;
Sistema.fora.println (y);

O código é descrito como:

• Inicializa duas variáveis x e y
• incremento de prefixo aplicado em x
• imprime o valor após o incremento
• Usando o incremento pós -fixo em y
• imprime o valor incrementado de y

A saída do código é fornecida abaixo:

Usando o prefixo e o decréscimo pós -fix: O conceito de decréscimo é o mesmo que o incremento, no entanto, diminui o valor em 1. O código fornecido abaixo diminui o valor das variáveis ​​prefixando/pós -fixing -:

pacote newpack;
classe pública unop
public static void main (string [] args)
int a = 20, b = 10;
// Usando decrementos de prefixo unário em um
--a;
Sistema.fora.println (a);
// Usando um decréscimo pós -fixo unário em B
b--;
Sistema.fora.println (b);

O código acima,

• declarar primeiro duas variáveis a e b
• Usando decrementos de prefixo e imprimir novo valor de a
• Usando o decréscimo postfix e mostra o valor atualizado de b

A saída do código é fornecida abaixo:

Usando complemento lógico: O operador de complemento lógico reverte a ordem de um valor booleano. O código Java a seguir exerce o booleano falso para verdadeiro e vice -versa:

pacote newpack;
classe pública unop
public static void main (string [] args)
// declarando uma variável booleana
boolean bool1 = true, bool2 = false;
// Usando o operador de complemento lógico no BOOL1
bool1 =!Bool1;
Sistema.fora.println (bool1);
// Usando o operador de complemento lógico no BOOL2
bool2 =!bool2;
Sistema.fora.println (bool2);

O código é descrito abaixo:

• declara duas variáveis ​​booleanas BOOL1 e BOOL2
• Aplica -se “!”Operador ligado BOOL1 e atualizações Valor do BOOL1
• Aplica -se “!”Operador ligado BOOL2 e atualizações Valor do BOOL2

A saída do código é exibida abaixo:

Conclusão

Os operadores unários permitem alterar o sinal, executar um incremento/decremento ou altere o valor booleano (true/false). Este artigo fornece o trabalho e o uso de operadores unários em Java. Você teria aprendido a sintaxe básica de todos os operadores unários. Para uma melhor compreensão, os operadores unários são exercidos usando exemplos de código Java.