Upload
internet
View
107
Download
0
Embed Size (px)
Citation preview
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