OPERADORESOPERADORES

SCJP – Otimize-TI

Operadores Java

Resultado: Maioria das operações é um booleano ou numérico.

Não podem ser sobrecarregados(Existem alguns operadores que já vêm sobrecarregado.)

Operadores de Atribuição

•Ao se atribuir um valor a um primitivo, o TAMANHO faz a diferença.(Certifique-se de saber quando uma conversão implícita irá ocorrer, quando a conversão explícita é necessária, e quando poderão ocorrer cortes.

•Lembre-se de que uma variável de referência não é um objeto e sim uma forma de chegar a um objeto.•Ao se atribuir um valor a uma variável de referência, o tipo faz a diferença. Lembre-se das regras para supertipos, subtipos e arrays.

Operadores de Atribuição Compostos

+= -= *= /=

y = y – 6; y -= 6;x = x + 2 * 5; x += 2 * 5;

De qual maneira será interpretada a função x *= 2 + 5;

x = x * (2 + 5)x = (x * 2) + 5

CORRETO

Operadores de Comparação

< <= > >= == !=

Sempre resulta em um BooleanoMas também pode ser atribuído diretamente a um tipo booleano primitivo.

Class CompareTest {public static void main (String [] args) {

boolean b = 100 > 99;System.out.println(“O valor de b é “ + b);

}}

Operadores de Igualdade

Compara dois itens semelhantesRetorna um booleanoQuatro itens que podem ser testados:

NúmerosCaracteresTipos booleanos primitivosVariáveis de referência de objeto

O operador examina o valor da variável. Em outras palavras, o padrão de bits.

== !=

Igualdade de variáveis de referência

Apontam para o mesmo objetoJButton a = new Button (“exit”);JButton b = a;

Import java.awt.ButtonClass CompareReference {

public static void main (String [] args){Button a = new Button (“Exit”);Button b = new Button (“Exit”);Button c = a;System.out.println(“a faz referência com b ?” + (a == b));System.out.println(“a faz referência com c ?” + (a == c));

}}

RESULTADO:a faz referência com b ? falsea faz referência com c ? true

Igualdade de tipos primitivos

Class ComparePrimitives {public static void main (String [] args) {

System.out.println(“a é igual a a ? “ + (‘a’ == ‘a’));System.out.println(“a é igual a b ? “ + (‘a’ == ‘b’));System.out.println(“5 é diferente de 6 ? “ + (5 != 6));System.out.println(“5.0 == 5L ? “ + (5.0 == 5L));System.out.println(“true é igual a false? “ + (true == false));

}}

a é igual a a ? truea é igual a b ? False5 é diferente de 6 ? True5.0 == 5L ? Truetrue é igual a false ? false

RESULTADO

Igualdade para Enums

Depois que você declarou um enum, ele não pode ser expandido em tempo de execução.

Poderá ser usado tanto “==“ quanto “equals” para comparar as constantes enumclassEnumEqual{

enum Color {RED, BLUE} // ; é opcionalpublic static void main (string [] args) {

Color c1 = Color.RED; Color c2 = Color.RED;if (c1 == c2) { System.out.println (“==“); }if (c1.equal (c2)) { System.out.println (“!=“); }

}}

Saída: == e !=

Operador de comparação instanceof

É usado somente com variáveis de referência de objetosUsado para verificar se um objeto é de um tipo específico.Realiza o teste “É-UM”.Prontege o programa contra a tentativa de tentativa de uma conversão inválida.

public static void main (String [] args) {String s = new String (“OTIMIZE-TI”);if (s instanceof String) {

System.out.println(“s é uma variável do tipo String”);}

}

Operador de comparação instanceofO exemplo mostra a validação de um objeto para um de seus subtipos antes de tentar uma converão “redutora”.class A { }class B extends A {

public static void main (String [] args) {A myA = new B();m2 (myA);

}public static void m2 (A a) {

if (a instanceof B)((B)a).doBstuff(); //convertendo uma referência

} //A em uma referência Bpublic static void doBstuff() {

System.out.println (“‘a’ é uma instancia de B”);}

}

Observação para o ExameInstância de uma interface. Uma implementação indireta ocorre quando uma das superclasses do objeto implementa uma interface,mas a própria classe da instância não o faz

inteface Sun { }class A implements Sun { }class B extends A { }. . .A a = new A();B b = new B();

Resultados:a instanceof Sunb instanceof Ab instanceof Sun //implementado indiretamente

Observação para o ExameLembre-se que os Arrays são objetos, mesmo quando armazenam tipos primitivos.

int [] nums = new int [3];If (nums instaceof Object) { } // O resultado é true

Ver tabela página 168.

Operadores aritméticos+ - x /

São usados da maneira padrão.

int x = 5 * 3

int y = x – 4;

System.out.println(“x – 4 é = “ + y); // exibirá 11

Operador Resto%

Divide o operando esquerdo pelo direito com o resultado sendo o resto.

class MathTest {public static void main (String [] args) {

int x = 15;int y = x % 4;System.out.println (“Resto: ” + y);

}}

Resultado: Resto: 3

Operador de concatenação de string+

O sinal de adição também pode ser usado para concatenar duas Strings.String texto = “concatenar” + “ “ + “string”;

Exemplo:String a = “String”;int b = 3;int c = 7;System.out.println (a + b + c);

Qual o resultado

-String10 -String37 - Erro de compilação

CORRETOCORRETO

Operador de acréscimo e decrécimo++ --- Prefixo

- Sufixo

O operador é inserido antes (prefixo) ou depois (sufixo) de uma variável para alterar o valor.Se for prefixo, a operação de acréscimo ou decréscimo deverá ser realizada antes de sua utilização. Caso seja sufixo, deve-se ser utilizado para após sofrer a alteração.

class MathTest {static int players = 0;public static void main (String [] args) {

System.out.println(“Resultado: ”players++);System.out.println(players);System.out.println(++players);

}}Resultado: 012

Operador condicionalOperador ternário (3 operandos).Semelhante ao “if”.Ao invés de executar um bloco de código se o resultado for true, ele atribui um valor à variável.

Exemplo:

class Salary {public static void main (String [] args) {

int numero = 3;String status = (numero<4)?”O número é menor que 4”:”O número é maior que 4”;System.out.println(status);

}}

Operadores Lógicos& | && ||

Operadores Lógicos& | && ||

-Exemplo de validação:

int z = 5;If (++ z > 5 || ++z > 6) z++; //z=7 depois deste código.

int z = 5;If (++ z > 5 | ++z > 6) z++; //z=8 depois deste código.

Operadores Lógicos^ !

- ^ (OR EXCLUSIVO – XOR)- ! (inversão booleana)

-Relaciona-se com operadores de não abreviação. (sempre avalia ambos os operandos)

Exemplo:

public static void main(String[] args) {System.out.println("xor :" + ((2<3) ^ (4>3)));

}

RESULTADO: xor: false

Ou seja: true + true = falsetrue + false = truefalse + true = truefalse + false = false

Dúvidas

contato@otimize-ti.com.br