SCJP - 04 - Operadores - Notas Mentais

E finalmente eu terminei de ler o maldito capitulo 3. Caraca... Até a autora fala que o capítulo é um monstro (de chato)! E de cara, e ja inicio o capitulo 4 lendo uma coisinha que eu não tinha prestado atenção antes.

Operadores de atribuição compostos são aqueles que combinam atribuição e algum outro operador aritmético/lógico, tais como |=, *=, /=, +=, -=, etc. Nós já sabemos, desde do ensino fundamental, que existe uma certa ordem de precedência nos operadores matemáticos, aquelas coisas básicas sobre divizão e multiplicação virem primeiro que adição e subtração...

int a = 10;
a = a + 10;

O trecho de código acima é equivalente, em termos de efeito, ao código abaixo:

int a = 10;
a += 10;

Entretanto, analise o código abaixo:

int a = 10;
a *= 2 + 3 // isso não é "a = a * 2 + 3"...

É... isso mesmo... isso não é uma expressão do tipo a = (a * 2) + 3. O que acontece é que a expressão do lado direito do operador composto é sempre avalidada primeiro. É mais correto pensar no trecho de código acima como uma expressão do tipo a = a * (2 + 3). Estranho, não?

Também tem algo que eu não sabia até então. O operador instanceof pode gerar erro de compilação. Como?

class Teste {}

public class Principal {
    public static void main(String[] args) {
        Teste teste = new Teste();
        Principal principal = new Principal();
   
        if (teste instanceof Principal) {
            System.out.println(
                "teste instanceof Princiipal");
        }
    }
}

É, eu acho que você também pensou que era possivel usar instanceof de qualquer maneira... Mas analisando o erro de compilação gerado (aff, compile e veja! :D), você nota que o operador instanceof só pode ser usado quando o objeto referenciado pertencer à mesma hierarquia de classes que o tipo a ser testado.

Usar instanceof com o literal null sempre resulta em false, para qualquer classe ou inferface.

Também tome cuidado com os operadores de circuito longo, aqueles que não seguem a tal avaliação preguiçosa. São eles o | e o & (favor não confundir com operadores bit a bit - eles não estão na SCJP 6). Tem muita pegadinha que pode ser feita a partir daí. Principalmente quando a gente pensa em envolver operadores pré e pós fixados, e outras coisas que demandam atenção... O próprio livro traz exemplos não tão triviais assim:

int z = 5;
if(++z > 5 || ++z > 6) z++;

a fração ++z > 6 não é avaliada, pq o operador || é de circuito curto. Logo, z é igual 7 após esse trecho.

Esta obra está licenciada sob uma Licença Creative Commons.