Complemento Lógico e Operadores de Negação
O operador lógico complementar, !, inverte o valor da expressão booleana. Por exemplo, se o valor é verdadeiro, ele irá converter para falso, e vice versa. Vamos ver um exemplo:
|
1 2 3 4 5 |
boolean x = false; System.out.println(x); //false x = !x; System.out.println(x);//true |
Diferente do operador de negação, -, inverte o sinal de uma expressão numérica, veja um exemplo:
|
1 2 3 4 5 6 7 |
double x = 1.21; System.out.println(x); //1.21 x = -x; System.out.println(x); //-1.21 x = -x; System.out.println(x); //1.21 |
Baseado na descrição, pode ser óbvio que alguns operadores requer a variável ou expressão na qual eles estão agindo para especificar o tipo.
Por exemplo, você não pode aplicar o operador negativo, -, para uma expressão booleana, assim como você não pode aplicar um operador lógico, !, em uma expressão numérica.
Cuidado com algumas expressões que podem falhar na compilação. Vamos ver alguns exemplos:
|
1 2 3 4 |
int x = !5; //não compila boolean y = -true; //não compila boolean z = !0; //não compila |
O primeiro exemplo não irá compilar pelo fato de que o Java não pode utilizar um operador lógico em um valor numérico.
O segundo exemplo não irá compilar pelo fato de que o Java não pode utilizar um operador negativo para um valor booleano.
O terceiro exemplo além de um valor numérico utilizar o valor lógico o valor booleano está sendo atribuído um número.
Operadores de Incremento e Decremento
Operadores de incremento e decremento, ++ e –, respectivamente, pode ser aplicado para operadores numéricos e tem alta ordem de precedência, comparado aos operadores binários. Resumindo, muitas vezes essas operações são aplicadas antes das outras.
Operadores de incremento e decremento requer um cuidado especial de quando eles são aplicados, as aplicações podem mudar o resultado da expressão.
Se o operador é colocado antes do operando, é chamado de operador de pré incremento ou pré decremento, quando o operador é aplicado antes do valor retorna um novo valor da expressão.
Se o operador é colocado depois do operando, chamado de operador pós incremento ou pós decremento, quando o operador é aplicado depois do valor o valor original da expressão é retornado.
Vamos a alguns exemplos:
|
1 2 3 4 5 6 7 |
int counter = 0; System.out.println(counter); //saída 0 System.out.println(++counter); //saída 1 System.out.println(counter); //saída 1 System.out.println(counter--); //saída 1 System.out.println(counter); //saída 0 |
Veja que no incremento do counter a saída é 1, e quando ocorre o decremento o valor continua 1. Isso significa que a pré operação é executada antes do System.out.println e a pós operação é executada depois do System.out.println.
Vamos ver algumas expressões:
|
1 2 3 4 5 |
int x = 3; int y = ++x * 5 / x-- + --x; System.out.println(“x é “ + x); System.out.println(“y é “ + y); |
Vamos resolver essa expressão: o x tem um pré incremento antes de multiplicar por 5, então essa parte ficará desta maneira:
|
1 |
int y = 4 * 5 / x-- + --x; |
Depois da divisão o x tem um pós decremento, o valor do x é 4 e continua com o valor 4.
|
1 |
int y = 4 * 5 / 4 + --x; |
No passo final o valor do x que é 4 muda para o valor 3 por causa do pós decremento. O decremento acontece depois da execução da expressão 4 * 5 / 4.
Em seguida tem um pré decremento do x fazendo o valor do x ter agora o valor 2. No final a expressão fica dessa maneira:
|
1 |
int y = 4 * 5 / 4 + 2; |
Resultado: x é 2 e y é 7.
Deixe um comentário