Aprendendo Java Para Certificação #11

Operadores Aritméticos

Operadores aritméticos são muitas vezes encontrados na matemática que inclui a adição (+), subtração (-), multiplicação (*), divisão (/) e módulo (%).

São também incluídos os operadores unitários, ++ e –. Há também a regra de ordem de prevalência dos operadores.

Por exemplo, os operadores (*, /, %) tem prevalência diante os operadores (+, -). Vejamos a seguinte expressão:

int x = 2 * 5 + 3 * 4 - 8;

Primeiro devemos resolver as multiplicações, fazendo isso a expressão diminui.

int x = 10 + 12 - 8;

Agora com os termos restantes que tem a mesma relevância, temos que resolver a expressão da esquerda para direita. O resultado do x será 14.

Se não houver parênteses na expressão, deve-se seguir a regra apresentada. Vamos ver um exemplo com parênteses.

int x = 2 * ((5 + 3) * 4 – 8);

A regra para resolver a expressão é a mesma, a única coisa que muda é que temos que resolver primeiro as expressões que estão dentro dos parênteses.

int x = 2 * (8 * 4 - 8);

Novamente, vamos resolver a expressão dentro do parêntese, seguindo a regra de prevalência.

int x = 2 * (32 – 8);

Antes de multiplicar por 2, temos que resolver a expressão dentro dos parênteses.

int x = 2 * 24;

Agora sim faz-se a multiplicação por dois e o resultado é 48.

Todas as operações aritméticas podem ser utilizadas nas variáveis primitivas do Java, exceto o boolean.

Na classe String os operadores de adição (+) e (+=) podem ser utilizados para aplicar valores ao String, isso irá resultar na concatenação da String.

Caso não saiba o operador módulo (%) irá trazer o resultado do resto de uma divisão. Por exemplo: 9 % 3 = 0 e 11 % 3 = 2.

Comparando divisão e módulo:

System.out.println(9 / 3); // resultado 3
System.out.println(9 % 3); // resultado 0
System.out.println(10 / 3); // resultado 3
System.out.println(10 % 3); // resultado 1
System.out.println(11 / 3); // resultado 3
System.out.println(11 % 3); // resultado 2
System.out.println(12 / 3); // resultado 4
System.out.println(12 % 3); // resultado 0

Promoção Numérica

Algumas conversões numéricas são feitas automaticamente pelo Java. Todo número inteiro é tratado pelo Java como int e todo número fracionado é tratado como double.

Isso quer dizer que se você declarar que uma variável float é igual a 2.5 (float = 2.5;), o Java vai tratar como (double = 2.5;). A não ser que você especifique que o Java trate como float, fazendo o seguinte: float = 2.5F;

O Java só faz a conversão automática quando o número escolhido é menor do que o padrão.

No exemplo do float, o float tem menor capacidade de guardar valores do que o double, sendo assim mesmo que você colocasse um valor acima do que o float suporta, o Java trataria como double, porque como mencionado o Java trata valores fracionados não especificados como double.

Vamos enumerar algumas regras:

  1. Se dois valores têm diferentes tipos, o Java irá automaticamente promover o valor para o mais alto dos dois tipos.
  2. Se um valor é inteiro e o outro fracionado, o Java irá automaticamente promover o valor inteiro para o tipo fracionado.
  3. Os tipos pequenos como o byte, short e char são promovidos para o tipo int, mesmo que não haja um tipo int no meio da operação.
  4. Depois que as promoções numéricas forem executadas o resultado da operação será do tipo promovido.

Vamos ver alguns exemplos:

Qual será o tipo do resultado para a expressão x * y?

int x = 1;
long y = 33;

Seguindo a primeira regra o long tem um tipo maior que int, então o resultado será do tipo long.

Qual será o tipo do resultado para a expressão x + y?

double x = 39.21;
float y = 2.1;

Nessa situação não entra em nenhuma das quatro regras. Vai acontecer o que foi explicado nas conversões automática do Java.

Qual será o tipo do resultado para a expressão x / y?

short x = 10;
short y = 3;

Nessa expressão será utilizada a regra 3. Então o resultado será int.

Qual será o tipo do resultado para a expressão x * y / z?

short x = 14;
float y = 13;
double z = 30;

Nessa expressão o short será convertido automaticamente para int pela conversão automática.

Para x * y ser executado o short que foi modificado para int será modificado novamente para float, seguindo a primeira regra.

Só que o float não está especificado como float (float y = 13F;), sendo assim como já vimos, o Java irá tratar o y como double. No fim, essa expressão terá o resultado do tipo double.

Trabalhando com Operadores Unitário

Por definição, um operador unitário requer exatamente um operando ou variável para a função.

Veja a tabela como as operações são simples, um incrementa mais 1 ao valor de uma variável, outro apenas inverte o valor de um booleano.