Operadores Java

Operadores Java Raphael Marques

Objetivo Operadores de atribuição: =, +=, -=, *=, /= Operadores aritméticos: +, -, *, /, %, ++, -- Operadores relacionais: <, <=, >, >=, ==, != Operador instanceof Operadores lógicos: &, |, ^, !, &&, || Operador condicional: ? :

Objetivo Não é assunto da prova: Operadores de deslocamento de bits Operadores binários (bit-a-bit) Complemento de 2 Divisão por zero

Operador de atribuição Para números, o tamanho importa. int x = 5f; ERRO byte b = 500; ERRO Para referências, o “tipo” importa. Integer y = “5”; ERRO

Operador de atribuição boolean b = false; if(b = true) System.out.println("SIM"); else System.out.println("NAO"); Qual a saída?

Operador de atribuição boolean b = false; if(b = true) System.out.println("SIM"); else System.out.println("NAO"); Qual a saída? -> "SIM"

Operador de atribuição boolean b = false; if(b = true) -> (b = true) retorna o valor que é atribuído à b que é um booleano

Operador de atribuição int x = 0; if(x = 1) System.out.println("SIM"); else System.out.println("NAO"); Qual a saída?

Operador de atribuição int x = 0; if(x = 1) -> ILEGAL System.out.println("SIM"); else System.out.println("NAO"); Qual a saída?

Operador de atribuição int x = 0; if(x = 1) -> (x = 1) retorna o valor que é atribuído á x que é um inteiro, por isso não pode ser colocado como condição de um if

Operadores de atribuição compostos x += 5; -> x = x + 5; x -= 5; -> x = x - 5; x *= 5; -> x = x * 5; x /= 5; -> x = x / 5; X %= 5; -> NÃO CAI NA PROVA += -= *= /=

Operadores de atribuição compostos Atualmente a prova não cobra muito precedência de operadores! x = y++ + ++x/z; Em alguns casos sim: x *= 2 + 5; -> x = x * 2 + 5; ERRADO x *= 2 + 5; -> x = x * (2 + 5); CERTO

Operadores relacionais Retornam sempre um valor booleano. <, <=, >, >= apenas tipos numéricos ==, != todos tipos inclusive referência < <= > >= == !=

Operadores de igualdade Comparam números, booleanos e referências Os operandos devem ser compatíveis == !=

Operadores de igualdade if(false == 'a'){} ILEGAL if(65 == 'A'){} LEGAL if(1 == "A"){} ILEGAL if(1 == new Integer(1)){} LEGAL

Operadores de igualdade if(65 == 'A'){} -> um char ('A') é um número e portanto é compativel com int (65) if(1 == new Integer(1)){} -> O objeto Integer é convertido para int

Operadores de igualdade JButton a = new JButton("Exit"); JButton b = new JButton("Exit"); JButton c = a; System.out.println(a == b); System.out.println(a == c); Qual a saída?

Operadores de igualdade JButton a = new JButton("Exit"); JButton b = new JButton("Exit"); JButton c = a; System.out.println(a == b); -> false System.out.println(a == c); -> true Qual a saída?

Operadores de igualdade Integer a = 10; Integer b = 10; System.out.println(a==b); Qual a saída?

Operadores de igualdade Integer a = 10; Integer b = 10; System.out.println(a==b); -> true Qual a saída?

Operadores de igualdade Integer a = 10; Integer b = 10; System.out.println(a==b); -> true -> As classes (Integer, Byte, Short, Character e Long) apontam para a mesma referência quanto recebem um valor até 127 por atribuição.

Operadores de igualdade Integer a = new Integer(10); Integer b = new Integer(10); System.out.println(a==b); -> false -> Usar new garante a criação de objetos diferentes

Operadores de igualdade Integer a = new Integer(5) + 5; Integer b = 10; System.out.println(a==b); -> true -> Em operações que resultam em valores até 127 também são utilizadas as referências constantes

Operadores de igualdade enum Color {RED,GREEN,BLUE} ... Color a = Color.RED; Color b = Color.RED: System.out.println(a==b); -> true -> Enums são objetos, mas cada valor de um enum é uma constante (public static final)

Operador instanceof Verifica se o OBJETO referenciado pelo lado esquerdo “É UM” objeto do tipo do lado direito. Utilizado apenas com referências Também funciona com interfaces Retorna um booleano Ex: referencia instanceof Tipo

Operador instanceof class Animal { } class Baleia extends Animal { } ... Animal a = new Animal(); Baleia b = new Baleia(); Object c = new Baleia(); ... System.out.println(a instanceof Animal); -> true System.out.println(a instanceof Baleia); -> false

Operador instanceof class Animal { } class Baleia extends Animal { } ... Animal a = new Animal(); Baleia b = new Baleia(); Object c = new Baleia(); ... System.out.println(b instanceof Animal); -> true System.out.println(b instanceof Baleia); -> true

Operador instanceof class Animal { } class Baleia extends Animal { } ... Animal a = new Animal(); Baleia b = new Baleia(); Object c = new Baleia(); ... System.out.println(c instanceof Animal); -> true System.out.println(c instanceof Baleia); -> true

Operador instanceof class A { } ... A a = new A(); ... ...println(“x” instanceof A); ILEGAL ...println(a instanceof Object); SEMPRE TRUE ...println(array instanceof Object); SEMPRE TRUE ...println(null instanceof A); SEMPRE FALSE

Operador instanceof interface Animal { } class Manifero implements Animal { } class Baleia extends Mamifero { } ... Baleia b = new Baleia(); ...println(b instanceof Animal); -> true

Operadores aritméticos + adição - subtração * multiplicação / divisão % resto ...println(17 % 5); -> 2 ...println(17.0 % 5.0); -> 2.0

Operadores aritméticos int a = 8; int b = 6; int c = a + b;

Operadores aritméticos short a = 8; short b = 6; short c = a + b; -> ILEGAL

Operadores aritméticos short c = a + b; -> ILEGAL -> Não existe os operadores aritméticos para tipos menores que int -> Os valores são automaticamente convertidos para int, e por isso a expressão não pode ser atribuída a um short

Operadores aritméticos Solução: short a = 8; short b = 6; short c = a; c += b; -> LEGAL

Concatenação de Strings 5 + 4 + “x” -> “9x” ERRO??? 5 + (4 + “x”) -> “54x” “ x” + 5 + 4 -> “x54” ERRO??? “ x” + (5 + 4) -> “x9” String s = “alguma”; s += “coisa”; -> “algumacoisa”

Incremento e Decremento int x = 5; ...println(x++); -> 5 ...println(x); -> 6 ...println(++x); -> 7 ...println(x); -> 7 ...println(x--); -> 7 ...println(x); -> 6

Operador condicional hora < 12 ? "M" : "T" (hora < 12) ? "M" : "T" hora < 12 ? "M" : hora < 18 ? "T" : "N“ hora > 12 ? hora < 18 ? "T" : "N" : "M”

Operador condicional -> O aninhamento é feito igual if-else: cada : casa com o ? anterior mais próximo que ainda não possua um : hora < 12 ? "M" : hora < 18 ? "T" : "N“ hora > 12 ? hora < 18 ? "T" : "N" : "M”

Operadores lógicos Operandos são expressões booleanas O resultado é um booleano Na prova não cai operadores binários!!! & | ^ ! && ||

Operadores lógicos Operadores com curto-circuito && e || Dependendo do valor do 1º operando, o segundo operando pode não ser avaliado if( true || ?????? ){} if( false && ??????){} Cuidado com incrementos/decrementos no segundo operador.

Operadores lógicos Operadores sem curto-circuito & e | Os dois operando sempre serão avaliados

Operadores lógicos XOR (OU exclusivo) ^ Retorna true se APENAS um operando é true Os dois operandos sempre são avaliados Negação ! true -> false false -> true

Operadores Java

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Operadores Java

Mais de Raphael Marques

Operadores Java