Operadores unários
são operadores que envolvem apenas um operando, tais como:
- Negação !
- Pré e pós incremento ++
- Pré e pós decremento --
- Sinal positivo +
- Sinal negativo -
- Inversão de bits ~
- Cast ()
Operador de negação: !
É utilizado para inverter o valor de uma expressão booleana,
ou seja uma expressão !true retorna false e uma expressão !false retorna true.
Vamos à prática:
class OperadorNegacao{
public static void main(String
args[]){
boolean verdadeiro =
true;
System.out.println("Verdadeiro
= " + verdadeiro);
System.out.println("!Verdadeiro
= " + !verdadeiro);
}
}
Operador de incremento e decremento: ++,--
Estes operadores modificam o valor de uma expressão
adicionando ou subtraindo 1. Os operadores de incremento e decremento podem
ser:
-
Pós-fixados: O incremento ou decremento é feito após o uso da variável.
-
Pré-fixados: O incremento ou decremento é feito antes do uso da variável.
Vamos à prática:
class
OperadorIncrementoDecremento{
public static void main(String
args[]){
int incremento = 5;
int decremento = 8;
System.out.println("Pos-fixados:");
System.out.println("incremento
atual=" + incremento);
System.out.println("incremento++="
+ incremento++); // primeiro exibe na tela depois adiciona 1
System.out.println("depois
do incremento=" + incremento);
System.out.println("-----------");
System.out.println("decremento
atual=" + decremento);
System.out.println("decremento--="
+ decremento--); // primeiro exibe na tela depois tira 1
System.out.println("depois
do decremento=" + decremento);
//Neste momento a
variavel incremento é igual a 6
//Neste momento a
variavel decremento é igual a 7
System.out.println("");
System.out.println("Pre-fixados:");
System.out.println("incremento
atual=" + incremento);
System.out.println("++incremento="
+ ++incremento); // primeiro adiciona 1 e depois exibe na tela
System.out.println("depois
do incremento=" + incremento);
System.out.println("-----------");
System.out.println("decremento
atual=" + decremento);
System.out.println("--decremento="
+ --decremento); // primeiro tira 1 e depois exibe na tela
System.out.println("depois
do decremento=" + decremento);
}
}
Operadores de representação de sinal: + e -
Os operadores unários + e – representam positivo e negativo
respectivamente. O operador + não tem outra função a não ser deixar explicito
que um numero é positivo (O operador mais quando utilizando com Strings serve
como concatenação e quando utilizado com dois números como soma, porem para
este tópico ele serve apenas para deixar explicito que um numero é positivo).
Exemplo:
int numeroNegativo = -12;
int numeroPositivo = +12; // numeroPositivo = 12 seria
exatamente igual.
Operador de inversão: ~
Conhecido como Bitwise Inversion Operator (operador de
inversão de bits) converte todos os bits 1 em 0 e todos os 0 em 1.
Exemplo:
int numeroInvertido = ~7 è numeroInvertido = 7 + 1 invertendo o sinal = - 8
int numeroInvertido = ~-20 è numeroInvertido = -20+1 invertendo o sinal = 19
Operador de conversão: Cast
O operador cast é utilizado para uma conversão explicita em
uma expressão:
- Cast pode
ser aplicado para trocar tipos de valores primitivos.
- Cast pode
ser aplicado em referencia a objeto.
Existem dois tipos de cast:
- Cast
explicito:
Quando
queremos que uma variável de tipo maior seja convertida em um tipo menor.
Exemplo quando queremos que double seja convertido em um byte, se não fizermos
o cast explicitamente teremos um erro de compilação.
- Cast
automatico:
Não
precisamos fazer o cast explicito ou seja quando uma variável cabe em outra.
Exemplo quando queremos colocar um byte em um short.
Agora como saber que uma variável cabe em outra? Abaixo
segue uma ordem da esquerda para direita:
byte è
short ou char è
int è
long è
float è
double
Ou seja um byte sempre cabe em um short, um short sempre
cabe eu um int ou em um char e assim por diante, para estes casos podemos
utilizar o cast automático, porem caso você queira colocar um int em short
devera usar o cast explicito onde você estará informando ao compilador “Ei eu
sei o que estou fazendo este valor de int cabe em short”. TENHA CERTEZA DO QUE
ESTA FAZENDO, POIS O COMPILADOR IRÁ REMOVER OS BITS DO VALOR O QUE ACARRETARA
EM UMA PERDA DE PRECISÃO.
Vamos à prática:
class OperadorConversao{
public
static void main(String args[]){
byte
meuByte = 123;
short
meuShort = 1234;
int
meuInt = 12345;
char
meuChar = 'd';
long
meuLong = 123456;
float
meuFloat = 12.4567f; // adicionado o f para forçar float caso não coloque é
considerado um double
double
meuDouble = 123.456785;
System.out.println("Valores
Atuais:");
System.out.println("meuByte
= " + meuByte);
System.out.println("meuShort
= " + meuShort);
System.out.println("meuChar
= " + meuChar);
System.out.println("meuInt
= " + meuInt);
System.out.println("meuLong
= " + meuLong);
System.out.println("meuFloat
= " + meuFloat);
System.out.println("meuDouble
= " + meuDouble);
System.out.println("Cast
automatico:");
meuShort
= meuByte; // meuByte e menor meuShort cast automatico
meuInt
= meuShort; // meuShort e menor meuInt cast automatico
meuLong
= meuInt; // meuInt e menor meuLong cast automatico
System.out.println("meuShort
= " + meuShort);
System.out.println("meuInt
= " + meuInt);
System.out.println("meuLong
= " + meuLong);
System.out.println("Cast
Explicito:");
meuFloat
= (float)meuDouble; // Double é maior que float por isso é necessario informar
ao compilado "Ei sei o que estou fazendo! O valor da minha variavel double
vai caber no float"
meuLong
= 1231312312;
meuInt
= (int)meuLong;
meuShort
= (short)meuInt;
System.out.println("meuFloat
= " + meuFloat);
System.out.println("meuLong
= " + meuLong);
System.out.println("meuInt
= " + meuInt);
System.out.println("meuShort
= " + meuShort); // perceba que o valor mostrado é totalmente diferente ou
seja foi feito um cast erroneamente pois o valor de int não cabe no short.
}
}
Com isso finalizo o post de operadores unários e fica a dica: Tome cuidado com cast explicito tenha
certeza do que esta fazendo pois pode ocorrer perda de precisão.
Até o próximo post.
