Bgames
Olá visitante! Seja bem vindo ao nosso fórum!

Para você ter total acesso ao nosso fórum é preciso que você se cadastre.

Cadastre-se Aqui!


PARA VER LINKS E IMAGENS É PRECISO SE REGISTRAR!

Expressões [Java 05]

Ver o tópico anterior Ver o tópico seguinte Ir em baixo

Expressões [Java 05]

Mensagem por BGames em Qua 29 Fev 2012 - 11:49

[Você precisa estar registrado e conectado para ver esta imagem.]


Expressões são combinações ordenadas de valores, variáveis, operadores, parênteses e chamadas de métodos, permitindo realizar cálculos aritméticos, concatenar strings, comparar valores, realizar operações lógicas e manipular objetos. Sem expressões, uma linguagem de programação seria praticamente inútil. O resultado da avaliação de uma expressão é em geral um valor compatível com os tipos dos dados que foram operados.

A maneira como uma expressão é avaliada (ou calculada) obdece as mesmas regras familiares da Matemática. A regra mais simples é a da associatividade. Quando um mesmo operador aparece mais de uma vez em uma expressão, como em a+b+c, então o operador mais à esquerda é avaliado primeiro e em seguida o da direita, e assim por diante. Esta seria então equivalente a ((a+b)+c).

Precedência

Há situações em que é necessário juntar operadores diferentes numa mesma expressão. Nesse caso a associatividade não se aplica mais trivialmente. Nesse caso como descobrir quais são os operandos de um operador, e quais operadores são avaliados primeiro? A resposta está na precedência dos operadores. Por exemplo, excrevendo a+b*c, somos levados naturalmente a multiplicar primeiro b com c e em seguida o somar o produto com a. Isto porque a multiplicação tem precedência sobre a adição. A precedência é então um conjunto de regras que permitem determinar quais são os operandos de um dado operador.

Como a linguagem Java é rica em operadores, alguns pouco familiares, precisamos conhecer a precedência desses operadores.

Na tabela a seguir, está indicada a pecedência dos operadores comumente usados em Java. A tabela apresenta os operadores ordenados da maior precedência para a menor. Observe que, existem alguns operadores que naturalmente não requerem preocupação quanto à sua precedência, devido a forma como são empregados.
































































Operador Descrição
. [] ()

(tipo)
Máxima precedência: separador, indexação, parâmetros, conversão de tipo
+ - ~ ! ++ -- Operador unário: positivo, negativo, negação (inversão bit a bit), não (lógico), incremento, decremento
* / % Multiplicação, divisão e módulo (inteiros)
+ - Adição, subtração
<<

>>

>>>
Translação (bit a bit) à esquerda, direita sinalizada, e direita não sinalizada (o bit de sinal será 0)
<

<=

>=

<
Operador relacional: menor, menor ou igual, maior ou igual, maior
== != Igualdade: igual, diferente
& Operador lógico e bit a bit
^ Ou exclusivo (xor) bit a bit
| Operador lógico ou bit a bit
&& Operador lógico e condicional
|| Operador lógico ou condicional
?: Condicional: if-then-else compacto
= op= Atribuição

Conversão entre tipos de dados

Ao trabalhar com expressões, salvo quando todos os operando são do mesmo tipo, é inevitável ter que considerar conversões entre um tipo de dado e outro. Há basicamente dois tipos de conversões de dados. O primeiro se refere a conversão implicita na qual, os dados são convertidos automaticamente, praticamente sem a preocupação do programador. Isto ocorre no caso de conversão de dados de tipo interio para real e de números para strings. Por exemplo:

double x;
int i = 20;

x = i;
Neste caso o valor do inteiro i é convertido automaticamente para um double antes de ser armazenado na variável x. As regras de conversão implícita empregadas pela linguagem Java são as seguintes:

os operadores unários ++ e -- convertem um tipo byte e short são convertidos para um int, e os demais tipos não são afetados
para os operadores binários, as regras são um pouco mais complicadas. Para operações envolvendo apenas inteiros, se um dos operandos for long, o outro será convertido para um long antes de realizar a operação, a qual resultará num long. Caso contrário, ambos os operandos são convertidos para um int e o resultado será também um int, a menos que o resultado da operação seja grande demais para caber num int. Nesse caso, o resultado será convertido para um long. Para operações envolvendo números de ponto flutuante, se um dos operadores for double, o outro será convertido para double antes de realizar a operação e o resultado será um double. Do contrário, ambos os operando são convertidos para float, e o resultado será um float.
Algumas vezes, porém, as conversões implícitas não são suficientes para garantir um resultado esperado em uma expressão. Nesses cados, é importante podermos controlar precisamente a ocorrência de uma conversão de tipo. Isto pode ser feito por meio de um operador unário de conversão. Por exemplo:

float eventos = 25.7;
float dias = 7.2;
x = (int)(eventos / dias);
O resultado da expressão acima será precisamente 3, isto é a parte inteira de 25.7 dividido por 7.2. A diferença é que o operador de conversão de tipo (int) transformou o valor do quociente 25.7/7.2 em um inteiro, truncando as casas decimais. Note que o operador de conversão é um operador unário de maior precedência, logo, tivemos de colocar a divisão entre parênteses para garantir que o resultado dessa divisão formasse um único operando. A conversão entre quaisquer inteiros e entre inteiros e números de ponto flutuante é permitida. Porém, não é permitido converter dados do tipo boolean para nenhum outro tipo, enquanto a conversão entre objetos somente é permitida para classes parentes.

Vejamos ainda um outro exemplo de utilização do operador de conversão de tipo:

int a = 3;
int b = 2;
double x;
x = a / b;
Neste exemplo, desejamos que a variável x tenha o valor do quociente entre a e b. Como x é um dado de ponto flutuante, presume-se que o resultado desejado neste exemplo seja, digamos, x=3/2=1.5. Como porém os operandos da divisão são ambos inteiros, o resultado será também um inteiro, isto é, teremos x = 1.0. Para contornar essa situação, podemos converter explicitamente um dos operandos para um dado em ponto flutuante, fazendo:

x = (double)a / b;
Observamos que a conversão entre inteiros de maior comprimento para inteiros de menor comprimento pode causar perda de informação na representação dos valores. Caso o valor a ser convertido ocupe mais bits do que o tipo da variável recebendo esse valor, então o valor é truncado.

int l = 393;
byte b;
b = l;
System.out.println("O valor de b é " + b);
Neste exemplo teremos como resultado:

O Valor de b é -119
Por que isso aconteceu? Fica mais fácil de compreender isso se interpretarmos os números acima na notação binária. O número 393 é representado em base dois pelo número 110001001, que tem 9 bits de comprimento (omitimos os zeros não significativos). Como a variável b é do tipo byte e seu comprimento é de apenas 8 bits, teremos os 8 primeiros bits da direita para a esquerda atribuídos a b, isto é, 10001001, que representa o número -119 em base dois, na notação de complemento de dois.

BGames


Mensagens : 1808
Pontos : 16497
Evolução : 100


Ver perfil do usuário

Voltar ao Topo Ir em baixo

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo


 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum