Operadores Aritméticos
+
Soma, utilizado para somar valores ou concatenar strings.
int A = 20;
int B = 30;
int C;
C = A + B;
print( C ); // 50
O exemplo representa a soma de dois inteiros.
String D;
D = A + B;
Neste caso o compilador gera um erro, não pode atribuir um inteiro a uma string.
D = "" + A + B;
Neste caso compila, porém o resultado não é 50, e sim 2030, os valores foram concatenados.
D = "" + ( A + B );
Usando o parenteses, primeiro é somado os valores A e B, depois concatenados a string, agora o resultado é o esperado: 50.
Outra forma de obter o mesmo resultado:
C = new Integer(A + B).toString();
byte A = 127;
byte B = 1;
byte C;
C = (byte)(A+B);
print( C ); // -128
O resultado esperado seria 128, mas resultou em -128 por que?
Vamos lembrar dos limites do byte, que varia de -128 a 127, logo se estourar a capacidade o valor da variável gira para o próximo valor.
O mesmo acontece com o código abaixo, a expressão A < 128 é sempre verdadeira, quando o A for 127 e adicionado mais um em A++, o A vira -128, e a condição é sempre verdadeira, ficando num loop eterno.
while( A < 128 ) // Nunca será maior que 127.
{
A++;
...
}
-
Subtração, utilizado para subtrair valores. Este operador, diferentemente do operador "+", não é utilizado com String, apenas com valores numéricos.
*
Multiplicação, utilizado para multiplicar dois operandos.
/
Divisão, utilizado para dividir dois operandos. Quando os operandos forem dois inteiros, o resultado é um inteiro truncado.
int A = 5;
int B = 2;
print( A / B ); // 2
%
Resto da divisão (Módulo).
int A = 5
int B = 2
print( A % B ); // 1
Alguns programadores utilizam para saber se um número é par ou impar.
if( ( Value % 2 ) == 0 )
{
... Par
}
A forma mais eficiente para verificar se um número é par ou impar, é utilizando o AND binário (&).
if( ( A & 0x01 ) == 0 ) )
{
... Par
}
Verifique o bit da posição 0 da sequência binária, sempre que o número é par, este bit é zero, quando é impar o bit é um, logo a comparação ( A & 0x01 ) == 0 ) vai indicar se o número é par ou impar.
Operadores de atribuição
=
Atribui o valor da direita na "variável" a esquerda.
int A = 4;
int C, D, E = A;
Para atribuir mais de uma variável, basta coloca-las em sequência, neste exemplo C D e E terão o valor de A que é 4.
Diferente de outras linguagens, uma atribuição não pode ser feita durante uma condição.
if( A = 4 ) // Erro de compilação
O código acima gera um erro de compilação. Devido ao histórico de erros cometidos por programadores em linguagens como o "C", que permite esta sintaxe, no Java foi excluída justamente para evitar erros de codificação, pois neste casso o programador poderia estar com a intenção de comparar o A com o 4, e não de atribuir o valor.
+= Ex: Total += 30; Equivalente a: Total = Total + 30;
-= Ex: Total -= 30; Equivalente a: Total = Total - 30;
*= Ex: Total += 30; Equivalente a: Total = Total + 30;
/= Ex: Total /= 30; Equivalente a: Total = Total / 30;
%= Ex: Total %= 30; Equivalente a: Total = Total % 30;
instanceof
Operador instanceof, permite verificar se um objeto é de um determinado tipo de classe.
if( ObjectCar instanceof JVehicle )
Verifica se o objeto ObjectCar é do tipo JVehicle.
Operadores de incremento
Operadores de incremento e decremento, permitem incrementar ou decrementar uma variável.
Ex: Total--; Equivalente a Total = Total - 1
Total++; Equivalente a Total = Total + 1
Cuidado com resultados não esperados quando alterado a precedência dos operadores.
Ex:
Total = 0;
while( Total++ < 2 )
{
print( "Total = " + Total );
}
A saída será:
Total = 1
Total = 2
Primeiro a variável Total é comparada com 2, depois é somado um a variável Total.
Total = 0;
while( ++Total < 2 )
{
print( "Total " + Total );
}
A saída será:
Total = 1
Primeiro é somado um a variável Total, depois comparado com 2.
Operadores de comparação
Utilizados para comparar variáveis com determinados valores.
>
if( Total > 100 )
....
StringValueA = "A";
StringValueB = "B";
if( ValueA > ValueB ) // Errado
Gera um erro de compilação, para comparar duas strings utilize o método compareTo
if( ValueA.compareTo( valueB ) > 0 )
Se for verdadeiro ValueA é maior que ValueB.
if( ValueA.compareTo( valueB ) < 0 )
Se for verdadeiro ValueA é menor que ValueB.
if( ValueA.compareTo( valueB ) == 0 )
Se for verdadeiro ValueA é igual a ValueB.
OBS: Lembre-se!!! Quando uma string é comparada usa-se a precedência da tabela ASCII, ou dependendo do idioma, verificar a tabela correspondente. Exemplo:
0 = 48
...
9 = 57
...
A = 65
B = 66
C = 67
....
<
Menor que, utilizado para comparar se o operando da esquerda é menor que o da direita.
Ex: if( Total < 10 )
==
Comparação, utilizado para comparar se o operando da esquerda é igual ao valor da direita.
Ex: if( Total == 0 )
Comparação de String.
Não compare duas strings desta forma, utilize o método equals para fazer comparações.
String ValueString = "Teste";
if( "Teste" == "Teste") // Errado
if( ValueString == "Teste") // Errado
Utilize o método equals do objeto que é uma String:
if( "Teste".equals( "Teste" ) )
if( ValueString.equals( "Teste" ) )
Comparação de inteiros.
int A = 5;
int B = 5;
if( A == B )
Retorna verdadeiro, pois o valor de A é igual ao valor de B.
Integer A = new Integer(5);
Integer B = new Integer(5);
if( A == B ) // Errado
Retorna falso, o que está sendo comparado são dois objetos,e não seus valores. Para comparar os valores de dois objetos do tipo Integer, utilize o método equals:
if( A.equals(B) ) //Certo
Utilize "==" para comparar objetos, quando precisar saber se duas variáveis apontam para o mesmo objeto.
JFrame FrameUser = new JFrame();
...
JFrame CurrentFrame = FrameUser;
...
if( CurrentFrame == FrameUser )
!=
Diferente, utilizado para comparar se operando da esquerda é diferente do operando da direita.
if( A != B )
>=
Maior ou igual, utilizado para comparar se operando da esquerda é maior ou igual o operando da direita.
if( A >= B )
<=
Menor ou igual, utilizado para comparar se operando da esquerda é menor ou igual o operando da direita.
if( A <= B )
Operadores lógicos
&&
Condição que retorna verdadeiro quando uma das condições for verdadeira.
if( Total > 100 && Total < 200 )
Retorna verdadeiro se o Total for maior que 100 e se o Total for menor que 200.
Result = ( X == 5 && Total == 100 );
Retorna um valor booleano falso ou verdadeiro, conforme o resultado da comparação efetuada.
||
Condição que retorna verdadeiro se uma as condições for verdadeira.
if( Total > 100 || Saldo < 200 )
!
Nega uma condição, se o retorno da condição for verdadeiro retorna falso, se o retorno da condição for falso retorna verdadeiro.
if( !(Total > 100 && Saldo < 200) )
Retorna verdadeiro se a condição avaliada for falsa.
Operadores binários
Operações utilizadas para comparações e tratamentos a nível binário.
>>
Deslocamento à direita dos bits, conforme operando.
byte Value = 4;
BinaryPrint( Value ); // 00000100
Value = Value >> 1;
BinaryPrint( Value ); // 00000010
Conforme apresentado, ocorreu o deslocamento de um bit para a direita.
<<
Deslocamento à esquerda dos bits, conforme operando.
byte Value = 2;
BinaryPrint( Value ); // 00000010
Value = Value < 1;
BinaryPrint( Value ); // 00000100
Conforme apresentado, ocorreu o deslocamento de um bit para a esquerda.
&
Operação AND bit a bit, retorna verdadeiro quando os dois bits estão ligados (1).
byte ValueA = 2;
byte ValueB = 3;
byte ValueC;
BinaryPrint( ValueA ); // 00000010
BinaryPrint( ValueB ); // 00000011
ValueC = ValueA & ValueB;
BinaryPrint( ValueC ); // 00000010
ValueC tem o retorno da comparação de 00000010 & 00000011, que neste caso os únicos bits ligados nas duas variáveis é o bit 1.
Byte - 0 0 0 0 0 0 0 0
Posição dos bits - 7 6 5 4 3 2 1 0
|
Operação OR bit a bit, retorna verdadeiro quando um dos bits está ligado (1).
byte ValueA = 2;
byte ValueB = 3;
byte ValueC;
BinaryPrint( ValueA ); // 00000010
BinaryPrint( ValueB ); // 00000011
ValueC = ValueA & ValueB;
BinaryPrint( ValueC ); // 00000011
ValueC tem o retorno da comparação de 00000010 | 00000011, que neste caso os únicos bits ligados são o bit 0 e o bit 1.
^
Operação OR exclusiva bit a bit, retorna verdadeiro quando somente um dos bits está ligado (1).
byte ValueA = 46;
byte ValueB = 26;
int ValueC;
BinaryPrint( ValueA ); // 00101110
BinaryPrint( ValueB ); // 00011010
ValueC = ValueA & ValueB;
BinaryPrint( ValueC ); // 00110100
ValueC tem o retorno da comparação de 00101110 | 00011010, que neste caso os únicos bits ligados somente uma vez são o bit 2, 4 e o bit 5.
~
Operação NOT bit a bit, inverte o estado do bit, utilizado com um único operando.
byte ValueA = 255;
BinaryPrint( ValueA ); // 11111111
ValueA = ~ValueA;
BinaryPrint( ValueA ); // 00000000
