Chapter II - Operators and Statements

Question 1

Ordem de operações no Java (OCA):

• Post-unary operators (expression++ ou – )
• Pre-unary operators (++ expression ou – )
• other unary operators (~, - (numero negativo), !)
• depois o padrão comum

Question 2

Para valores inteiros, os resultados de divisões têm como base o “floor” do número resultante.
Ex: 10 / 3 = 3 (pegou a parte inteira do que seria o resultado quebrado).

Question 3

Numeric Promotion Rules:

1 - Se duas variáveis têm tipos diferentes, a que tiver o menor tamanho será promovida para a que tem o tipo de maior tamanho.
Ex: long x + int y (y será promovida para long).

2 - Os tipos byte, short, e char serão sempre promovidas para int. Após isso pode haver outra promoção, caso a regra um se aplique (unary operators não se aplicam a essa regra, ex: short x++ ainda será um short).
*Obs: se eu tiver uma operação entre duas variáveis short, por exemplo, ainda assim o resultado será um int.

3 - Obviamente, o resultado de uma operação aritimética entre tipos diferentes, após as promoções, terá o mesmo tipo dos dois valores que foram utilizados na operação.

*Promoções também podem ocorrer entre um int e um número de ponto flutuante, óbvio!
int x + double y, vai resultar em um double.

Question 4

Exemplo de tricky expression usando operadores unários:

int x = 3;
int y = ++x * 5 / x -- + -- x;
int y = 4 * 5 / x -- +-- x ; // step 1
int y = 20 / 4 + -- x // step 2
int y = 5 + 2 // step 3
int y = 7.

Question 5

Obviamente, eu não consigo converter tipos maiores para menores. Ex:

long t = 123912391231923 //ele considera esse número um inteiro (precisaria do L).
short g = 23123123 //ele também considera esse número um inteiro.

A forma de eu conseguir fazer isso é por meio de casting. Ex:

long t = 123912391231923L
short g = (short) 23123123

Question 6

Compound operators ( += e -=) fazem o cast necessário caso eu tente armazenar na variável um valor que seja de um tipo maior. Ex:

long x = 10;
int y = 3;
y *= x //vai fazer o cast do resultado para int.

Question 7

Massa!

A diferença entre os operadores &, | e &&, || é que os primeiros fazem a verificação de todas as expressões enquanto o segundo só vai ao fim se for necessário, se ele ja “souber” que uma expressão não precisa ser alcançada, ele não irá até o fim.

Question 8

Fazer uso dos short-circuit operators podem prevenir NullPointersExceptions por exemplo:

if ( x != null && x.getValue() < 5) { // se x for nulo, ele já entra no if e não lança exceção}

if ( x != null & x.getValue() < 5) { // se x for nulo, ele vai tentar fazer a segunda verificação e vai lançar exceção}

Question 9

Lembrar que o Java não considera o “0” e o “1” como expressões booleanas.

Question 10

O switch não pode receber variáveis do tipo boolean ou long.

Question 11

Switches em Java só aceitam valores literais, enums ou constantes como parâmetro. Não posso passar para um switch uma variável que o Java não saiba seu valor.

Question 12

Se eu não colocar breaks em meu cases de um switch, assim que ele der match em um dos cases, ele vai dar match em todos os outros depois desse até encontrar uma instrução break ou terminar o switch em si.

Question 13

A instrução default de um bloco switch não precisa ser a última, o que faz ela ser executada por último não é sua posição, mas sim a expressão do switch não ter dado match em nenhum case.

Question 14

Tipos de variáveis que o switch aceita como parâmetro:

• literals;
• constants enum;
• final constants variable.

Question 15

Um “for” loop pode conter várias secções separadas por vírgula (na inicialização ou no update, não pode ter aonde fica a expressão booleana), ex:

for(int i = 0, int j = 10; i < 10; i++, j++; ) { }

Question 16

Todas as 3 partes de um “for” são opcionais, o que me possibilita criar um loop infinito:

for( ; ; ;) { }

Não posso redeclarar uma variável no bloco de inicialização, mas posso redefinir o valor:

long y = 10;
for(long y = 0, x = 4; x < 5 && y < 10; x++, y++){ } //tentando redeclarar “y”

long y = 10;
for(y = 0, x = 4; x < 5 && y < 10; x++, y++){ } //apenas redefinindo o valor de “y”, OK

Todas as minhas variáveis no bloco de inicialização precisam ser do mesmo tipo, não posso declarar uma variável do tipo long e outra do tipo int:

for(long y = 0, int x = 4; x < 5 && y < 10; x++, y++){ } //Não compila

Question 17

Break statements com labels me permite sair para além do bloco de código que ele está inserido (mais precisamente ele vai sair relacionado ao label que ele se referir).

Question 18

“continue” statement faz o fluxo de execucao terminar e volta o controle para a expressao boolean do loop que entao ira decidir se deve continuar ou nao.

Resumindo: ele termina a iteracao atual do loop.

Question 19

Lembrar de que posso armazenar tipos menores dentro de tipos mais abrangentes (uma expressao que me retorna um int pode ser armazenada em um int, long e double)

Question 20

Expressoes ternarias podem ser esquisitas, sem parenteses e ainda assim funcionar.

Question 21

Casting tem maior precedencia quando uma expressao vai ser interpretada. Isso significa dizer que preciso fazer o casting da expresssao inteira (fazer uso dos parenteses) e nao apenas deixar o casting na frente.
Ex:
byte a + 40, b + 50;
byte sum = (byte) a + b; //nao compila, no final das contas vou estar tentando colocar um int dentro de um byte.

Question 22

O fato de eu fazer um assignment dentro de um “if” nao faz com que o codigo nao compile. Um assignment dentro de um if retorna “true”.

Question 23

Atencao.

Variaveis criadas dentro do escopo do bloco “do” nao estam disponiveis dentro da expressao boolean do “while”.