6 – Operadores e Atribuições

Afonso Alcantara
Seed Technology Solutions
1

1
Objetivos
„ Atribuições de tipos primitivos
„ Deslocamento de bits
„ Passagem de parâmetros
„ Atribuição de objetos
„ Operadores de Abreviação
„ Operadores bit-a-bit
„ Outros operadores
„ Operadores matemáticos
„ Incremento e decremento

2
 Atribuições de tipos
primitivos
A forma mais comum de se atribuir um valor a uma
variável é:
x = 0;
Agora, preste a atenção nesta atribuição:
byte x = 10;
int k = y = z = 10;

Este é um dos capítulos mais importantes do curso, um

assunto que qualquer linguagem de programação tem, as diversas formas
de se atribuir e manipular valores em variáveis locais e atributos.
As variáveis têm um papel único na geração de programas e
suas peculiaridades serão abordadas neste módulo.
A forma mais comum de se atribuir um valor a uma variável é:
x = 0;
Agora, preste a atenção nesta atribuição:
byte x = 10;
Olhando rapidamente, não há nada de errado com essa linha,
certo? Errado! Vamos nos lembrar do capítulo 3. Esta atribuição é composta
de uma variável do tipo byte e de um inteiro 10. Uma variável do tipo byte só
tem capacidade para 8 bits e uma do tipo int de 32 bits. Então temos um
erro de compilação, certo? Errado! Neste caso, até +127 o compilador fará
uma conversão implícita.

3
 Atribuições de tipos
primitivos
byte x = 19 ;
byte x = (byte)19 ;
byte x = 128 ; //Erro! Necessita de conversão
//explícita
byte x = (byte)128 ; //ok

Atribuições de tipos primitivos

Como foi dito anteriormente, as atribuições a tipos primitivos
seguem regras que devemos prestar bastante atenção ao código. Veja os
exemplo abaixo:
byte x = 19 ; byte x = (byte)19 ;
byte x = 128 ; //Erro! Necessita de conversão explícita
byte x = (byte)128 ; //ok
Como já foi visto, a atribuição necessita de uma conversão
explícita porque +128 ultrapassa a capacidade de bits de uma variável do
tipo byte. Mas qual o resultado da variável x? Teremos:
0000 0000 0000 0000 0000 0000 1000 0000 <--> +128
O compilador despreza os 24 bits restantes, pois o tipo byte só
suporta 8 bits, então ficamos com:
1000 0000

4
 Atribuições de tipos
primitivos
„ Mas o bit mais significativo é usado para guardar o
sinal. Então temos um valor negativo nesse caso. Se
você imaginou -0, você está errado. Para descobrir o
valor negativo, inverta todos os bits da seqüência,
teremos:
0111 1111
„ Pegue esse valor e passa para a base 10, que é igual a
127 e some com 1, temos -128.

Mas o bit mais significativo é usado para guardar o sinal.

Então temos um valor negativo nesse caso. Se você imaginou -0, você está
errado. Para descobrir o valor negativo, inverta todos os bits da seqüência,
teremos:
0111 1111
Pegue esse valor e passa para a base 10, que é igual a 127 e
some com 1, temos -128.

5
 Deslocamento de bits
„ Apenas pode aplicar deslocamento de bits em tipos
inteiros
„ Os deslocamentos são:
>> deslocamento de bits à direita com sinal;
<< deslocamento de bits à esquerda com sinal;
>>> deslocamento de bits à direita sem sinal.

Deslocamento de bits
Talvez você não esteja habituado a deslocar bits, então
vamos começar a nos habituar. A primeira regra é: Apenas é aplicável em
tipos inteiros.
Os deslocamentos são:
>> deslocamento de bits à direita com sinal;
<< deslocamento de bits à esquerda com sinal;
>>> deslocamento de bits à direita sem sinal.

6
 Deslocamento de bits
„ Deslocamento de bits à direita com sinal (>>)
O deslocamento de bits à direita com sinal funciona
movendo um dado número de bits à direita. Veja o
exemplo abaixo:
int x = 16 ;
x = x >> 2 ;
Essa operação resulta em 4.

Deslocamento de bits à direita com sinal (>>)

O deslocamento de bits à direita com sinal funciona movendo
um dado número de bits à direita. Veja o exemplo abaixo:
int x = 16 ;
x = x >> 2 ;

Essa operação resulta em 4. Porque? Para entender isso,

deve-se recorrer à representação binária. Veja:
0000 0000 0000 0000 0000 0000 0001 0000
Isso é 16 na base 2. A operação de deslocamento, deslocou 2
bits para a direita, deixando a representação assim:
0000 0000 0000 0000 0000 0000 0000 0100
Nesta operação, uma regra bem simples é aplicada. O sinal
sempre é mantido! Podemos chegar ao valor 4 de uma fórmula matemática.
Divida o valor da variável (16) por 2(base binária) elevado ao
número de bits que devem ser deslocados.

7
Deslocamento de bits
Para entender isso, deve-se recorrer à
representação binária. Veja:
0000 0000 0000 0000 0000 0000 0001 0000
Isso é 16 na base 2. A operação de
deslocamento, deslocou 2 bits para a direita, deixando a
representação assim:
0000 0000 0000 0000 0000 0000 0000 0100
Nesta operação, uma regra bem simples é
aplicada. O sinal sempre é mantido!

8
 Deslocamento de bits
„ Deslocamento de bits à esquerda com sinal (<<)
O funcionamento deste deslocamento é
semelhante ao do anterior, apenas mudando a direção do
deslocamento. Veja o exemplo:
int x = 16;
x = x << 2;
No momento da atribuição tínhamos:
0000 0000 0000 0000 0000 0000 0001 0000
Após o deslocamento, ficamos com:
0000 0000 0000 0000 0000 0000 0100 0000
Temos 64 na base 10.

Deslocamento de bits à esquerda com sinal (<<)

O funcionamento deste deslocamento é semelhante ao do
anterior, apenas mudando a direção do deslocamento. Veja o exemplo:
int x = 16;
x = x << 2;
No momento da atribuição tínhamos:
0000 0000 0000 0000 0000 0000 0001 0000
Após o deslocamento, ficamos com:
0000 0000 0000 0000 0000 0000 0100 0000
Temos 64 na base 10.
Aqui também temos uma regra matemática para ajudar nossa
vida, multiplique ao invés de dividir.

9
 Deslocamento de bits
„ Em valores negativos, temos:
int x = -200 ;
x = x << 3;
O sinal é mantido e o resultado é: -1600.
Veja como ficou o número em representação binária.
Antes:
1000 0000 0000 0000 0000 0000 1100 1000
Depois:
1000 0000 0000 0000 0000 0110 0100 0000

10

Vamos aplicar o deslocamento em um número negativo.

int x = -200 ;
x = x << 3;
O sinal é mantido e o resultado é: -1600. Veja como ficou o
número em representação binária.
Antes:
1000 0000 0000 0000 0000 0000 1100 1000
Depois:
1000 0000 0000 0000 0000 0110 0100 0000

10
 Deslocamento de bits
„ Deslocamento de bits à direita sem sinal (>>>)
int x = 200 ;
x = x >>> 2 ;
O valor de x em bits antes do deslocamento:
0000 0000 0000 0000 0000 0000 1100 1000
Após o deslocamento, temos:
0000 0000 0000 0000 0000 0000 0011 0010

11

Deslocamento de bits à direita sem sinal (>>>)

A principal mudança neste deslocamento é que o bit do sinal
não é mantido. O bit mais significativo será preenchido com zero, então com
a exceção de um caso particular que explicaremos depois, todo número
deslocado com esse sinal sempre terá como resultado um número positivo.
Vamos aos exemplos:
int x = 200 ;
x = x >>> 2 ;
O valor de x em bits antes do deslocamento:
0000 0000 0000 0000 0000 0000 1100 1000
Após o deslocamento, temos:
0000 0000 0000 0000 0000 0000 0011 0010

11
 Deslocamento de bits
int x = -200 ;
x = x >>> 2;
O valor de x em bits antes do deslocamento:
1000 0000 0000 0000 0000 0000 1100 1000
Após o deslocamento, temos:
0010 0000 0000 0000 0000 0000 0011 0010

12

Até aqui ele funciona como o deslocamento com sinal, mas vamos analisar
o que acontece quando temos um número negativo. Veja o exemplo:
int x = -200 ;
x = x >>> 2;
O valor de x em bits antes do deslocamento:
1000 0000 0000 0000 0000 0000 1100 1000
Após o deslocamento, temos:
0010 0000 0000 0000 0000 0000 0011 0010

12
 Deslocamento de bits
„ Quando tentamos descolar mais bits que a capacidade
da variável.
int x = 90 ;
x = x >>> 35 ;

13

Existe uma particularidade que você deve está atento. Caso você tente
deslocar mais bits do que a capacidade da variável. O que acontecerá é que
o compilador irá fazer alguns cálculos para descobrir o valor. Veja o
exemplo:
int x = 90 ;
x = x >>> 35 ;
O compilador irá dividir o número de bits que você está tentando deslocar
pelo número de bits que a variável suporta. Neste caso, 35 dividido por 32.
O resto da divisão será a capacidade a ser deslocada. No caso citado, o
resto é 3.
Vamos ver o exemplo impar em deslocamentos binário. Vamos imaginar um
deslocamento em um tipo byte (8 bits). Agora vamos tentar descolar 12 bits.
byte x = (byte) 8 >>> 12 ;
Então temos 12 dividido por 8, o resto da divisão é 4. Agora vamos imaginar
o seguinte cenário. O que acontecerá se você tentar deslocar 16 ou 32 bits.
Teremos que dividir 16 ou 32 por 8, certo? Certo, com apenas um detalhe.
O resto da divisão será zero. Então se você tiver uma variável do tipo int
com um valor negativo e tentar deslocar 32 bits, o resultado será o mesmo
valor.

13
 Atribuição de Objetos
„ Tem o mesmo princípio da atribuição de tipos
primitivos, mas usa referência e não valores
class Carro {
public double preco = 0;
}
class Audi extends Carro { }
public class Teste {
public static void main(String[] args) {
Carro a = new Carro();
Audi b = new Audi();
Carro c = new Audi();
Audi d = new Carro();
}
} 14

Atribuição de Objetos
A atribuição de objetos é basicamente como atribuição de
tipos primitivos, mas usando referências e não valores. Grave essa
informação, pois a usaremos mais tarde. Veja o exemplo abaixo:

1. class Carro {
2. public double preco = 0;
3. }
4.
5. class Audi extends Carro { }
6.
7. public class Teste {
8. public static void main(String[] args) {
9. Carro a = new Carro();
10. Audi b = new Audi();
11. Carro c = new Audi();
12. Audi d = new Carro();
13. }
14. }

14
 Atribuição de Objetos
„ Temos atribuições de referências no código acima, mas existem
regras para que elas aconteçam. Lembra do exemplo do copo,
onde não podíamos colocar todo o conteúdo da lata no copo? O
mesmo exemplo pode ser aplicado aqui.
‹ Na linha 9, temos uma atribuição de uma referência de Carro
em uma variável do tipo Carro. É perfeitamente viável.
‹ Na linha 10, temos uma atribuição de uma referência de Audi
em uma variável do tipo Audi. Também é perfeitamente viável.
‹ Na linha 11, temos uma atribuição de uma referência de Audi
em uma variável do tipo Carro. É perfeitamente viável, pois
Audi estende Carro, logo Audi é um carro. Relacionamento is a.
‹ Na linha 12, temos uma atribuição de uma referência de Carro
em uma variável do tipo Audi, o que gera um erro de
compilação, pois Carro é a super-classe de Audi, Logo seu
volume é maior do que o “recipiente” de Audi. É necessária
uma conversão explicita para resolver o problema.
15

Temos atribuições de referências no código acima, mas

existem regras para que elas aconteçam. Lembra do exemplo do copo,
onde não podíamos colocar todo o conteúdo da lata no copo? O mesmo
exemplo pode ser aplicado aqui.
Na linha 9, temos uma atribuição de uma referência de Carro
em uma variável do tipo Carro. É perfeitamente viável.
Na linha 10, temos uma atribuição de uma referência de Audi
em uma variável do tipo Audi. Também é perfeitamente viável.
Na linha 11, temos uma atribuição de uma referência de Audi
em uma variável do tipo Carro. É perfeitamente viável, pois Audi estende
Carro, logo Audi é um carro. Relacionamento is a.
Na linha 12, temos uma atribuição de uma referência de Carro
em uma variável do tipo Audi, o que gera um erro de compilação, pois Carro
é a super-classe de Audi, Logo seu volume é maior do que o “recipiente” de
Audi. É necessária uma conversão explicita para resolver o problema.

15
 Passagem de parâmetros
„ Somente há passagem de parâmetros para métodos
por valor e não por referência

16

Passagem de parâmetros
Em Java só existe passagem de parâmetros para métodos por
valor, ou seja, será feita uma cópia dos bits da variável em questão e
passada ao método.

16
 Variáveis de tipo primitivo
public class Teste {
public static void main(String[] args) {
byte x = 10;
System.out.println("X antes: "+x);
altera(x);
System.out.println("X depois: "+x);
}
public static void altera(byte a) {
a = 2;
}
}

17

Variáveis de tipo primitivo

A passagem de valor para variáveis de tipo primitivo é de
simples entendimento. Sempre é criada uma cópia da variável. Veja o
exemplo:
public class Teste {
public static void main(String[] args) {
byte x = 10;
System.out.println("X antes: "+x);
altera(x);
System.out.println("X depois: "+x);
}
public static void altera(byte a) {
a = 2;
}
}
Uma variável local do tipo byte foi declarada com valor inicial
10 e foi passada para o método altera, o valor impresso é 10. O que
acontece é que o compilador copia os bits da variável, 00001010, e passa
para o método. O método altera essa cópia e altera para 2, 0000 0010, após
o final da execução do método a variável local a é descartada, assim como
qualquer outra variável que venha a ser criada nesse método.

17
 Variável de Instância
„ Exemplo:
public class Teste {
public static void main(String[] args) {
Carro c = new Carro();
c.preco = 13990.00;
System.out.println("preço antes: "+c.preco);
anula(c);
System.out.println("preço depois: "+c.preco);
}
public static void anula(Carro p) {
p = null;
}
}

18

Variável de Instância
Precisamos de um pouco mais de atenção nesse momento,
pois o comportamento para variáveis de instância é o mesmo, só que, uma
variável de instância é um repositório de bits que contém a localização do
valor da instância na memória, se fizermos uma cópia, teremos duas
variáveis apontando para o mesmo valor, com isso se você alterar o valor
da variável de instância em um método, o que acontecerá? Veja o exemplo:
public class Teste {
public static void main(String[] args) {
Carro c = new Carro();
c.preco = 13990.00;
System.out.println("preço antes: "+c.preco);
anula(c);
System.out.println("preço depois: "+c.preco);
}
public static void anula(Carro p) {
p = null;
}
}

18
 Variável de Instância
„ Se o Java usasse passagem por referência, ao final da
execução do método anula teríamos o lançamento de
uma exceção. Uma NullPointerException, como isso
não acontece, o valor impresso é 13990.00.

19

Se o Java usasse passagem por referência, ao final da

execução do método anula teríamos o lançamento de uma exceção. Uma
NullPointerException, como isso não acontece, o valor impresso é
13990.00.

19
 Operadores de Abreviação
„ Existem dois operadores de abreviação e podem ser
usados em instruções de condição:
São eles:
and (&&)
or (||)

20

Operadores de Abreviação
São os operadores mais comuns em qualquer linguagem. Em
Java são dois, and (&&) e or (||).

20
 Operadores de Abreviação
„ Operador &&
‹ Os dois valores devem ser verdadeiros.

class Teste {
public static void main(String[] args) {
int x = 10;
int y = 10 ^ 8;
boolean isMore = true;
if((x > y ) && isMore)
System.out.println(“Entrou aqui”);
}
}

21

Operador &&
É um operador binário que prima em ter dois valores
verdadeiros. Veja o exemplo:
class Teste {
public static void main(String[] args) {
int x = 10;
int y = 10 ^ 8;
boolean isMore = true;
if((x > y ) && isMore)
System.out.println(“Entrou aqui”);
}
}
Note que no exemplo anterior o if é composto de duas
condições e o bloco de código só será executado se as duas forem
verdadeiras.
Este operador verificará a primeira condição, caso ela seja
falsa, como nesse caso, ele não verificará a próxima condição.

21
 Operadores de Abreviação
„ Operador ||
‹ Um dois valores deve ser verdadeiro.
class Teste {
public static void main(String[] args) {
int x = 10;
int y = 10 ^ 8;
boolean isMore = true;
if((x > y ) || isMore)
System.out.println(“Entrou aqui”);
}
}

22

Operador ||
É também um operador binário como o operador and, mas
precisa apenas que um dois valores seja verdadeiro para que o bloco de
código seguinte ao if seja executado. Vamos alterar o exemplo anterior,
temos:
class Teste {
public static void main(String[] args) {
int x = 10;
int y = 10 ^ 8;
boolean isMore = true;
if((x > y ) || isMore)
System.out.println(“Entrou aqui”);
}
}
O operador testará os dois valores, no nosso caso, o primeiro
valor é falso e o operador testará o segundo. Caso o primeiro fosse
verdadeiro, o operador não testaria o segundo.

22
Operadores bit a bit
„ Existem três tipos de operadores bit a bit e podem
também ser usado em condições como os operadores
de abreviação. São eles:
& = and
| = inclusive or
^ = exclusive or

23

23
 Operadores bit a bit
„ Operador &
‹ Compara os valores binários dos valores da
condição e resulta 1 onde seus valores binários são
iguais.
int x = 10 & 9 ;
Assim, temos:
1010
1001
1000 = 8

24

Operador &
O operador & compara os valores binários dos valores da
condição e resulta 1 onde seus valores binários são iguais. Veja o exemplo:
int x = 10 & 9 ;
Após uma breve conversão, temos:
1010
1001
1000
Voltando para a base 10, temos 8 como resposta.

24
 Operadores bit a bit
„ Operador | (Inclusive or)
‹ Compara os valores binários dos valores da
condição e resulta 1 quando um dos dois valores é
1.
int x = 10 | 9 ;
Na representação binária, temos:
1010
1001
1011 = 11

25

Operador | (Inclusive or)

O operador | compara os valores binários dos valores da
condição e resulta 1 quando um dos dois valores é 1. Veja o exemplo:
int x = 10 | 9 ;
Na representação binária, temos:
1010
1001
1011
Totalizando em decimal 11.

25
 Operadores bit a bit
„ Operador ^ (Exclusive or)
‹ Esse operador tem o funcionamento inverso ao
operador em condições onde existe “verdade”.
int x = 10 ^ 9 ;
Assim, temos:
1010
1001
0011 = 3

26

Operador ^ (Exclusive or)

Esse operador tem o funcionamento inverso ao operador em
condições onde existe “verdade”. Veja o Exemplo:
int x = 10 ^ 9 ;
Em bits, temos:
1010
1001
0011
Resultando em: 3

26
 Outros operadores
„ Operador bit complementar
‹ Operador unário, que envolve apenas uma variável.

byte x = 10 ; //0000 1010

x = ~x ; // 1111 0101 = -11

27

Operador bit complementar

Este operador é unário, ou seja, envolve somente uma variável
e deve ser usado quando é necessário inverter todos os bits da variável.
Veja o exemplo:
byte x = 10 ; //0000 1010
x = ~x ; // 1111 0101 = -11

27
 Outros operadores
„ Operador Ternário
‹ Também conhecido como condicional, é utilizado
quando queremos realizar uma condição e só pode
ser usado em atribuições.

int tamanho = 19 ;
String texto = (tamanho > 10) ? “maior que 10” : “Menor
que 10” ;

28

Operador Ternário
O operador ternário, também conhecido como condicional, é
utilizado quando queremos realizar uma condição, leia-se if, em uma única
linha. Veja o exemplo:
int tamanho = 19 ;
String texto = (tamanho > 10) ? “maior que 10” : “Menor que
10” ;
System.out.println(texto) ;
Existem outras formas de aplicação de operador e essas são
as mais fáceis de serem encontradas no exame. Veja o código abaixo:

class Teste {
public static void main(String[] args) {
int x = 10 ^ 8;
int y = ~x;
System.out.println(( x > y )? "x é maior que y“ : "x é menor que y");
}
}
No código acima o valor impresso é: x é menor que y.

28
 Outros operadores
„ Operador instanceof
‹ É usado para saber se um objeto é uma instância de
uma classe.

String nome = “SeedTS";

if (nome instanceof String) {
System.out.println("nome é do tipo String");
} else {
System.out.println("nome não é do tipo String");
}

29

Operador instanceof
Este operador é usado para saber se um objeto é uma
instância de uma classe. Veja o exemplo:
String nome = " SeedTS ";
if (nome instanceof String) {
System.out.println("nome é do tipo String");
} else {
System.out.println("nome não é do tipo String");
}

29
 Outros operadores
„ Exemplo:
public class Veiculo { }
public class Audi extends Veiculo { }
public class Teste {
public static void main(String[] args) {
Audi a = new Audi();
Veiculo v = new Veiculo();
if (a instanceof Audi) System.out.println("a é do tipo Audi");
if (v instanceof Veiculo) System.out.println("v é do tipo Veiculo");
if (v instanceof Audi) System.out.println("v é do tipo Audi");
if (a instanceof Veiculo)
System.out.println("a é do tipo Veículo");
}
}
„ O resultados impressos são:
‹ a é o tipo Audi
‹ v é do tipo Veículo
‹ a é do tipo Veículo
‹ Lembre-se do relacionamento is a.
30

Você também pode comparar a instância de um objeto de uma

subclasse com uma superclasse. Veja o exemplo:
public class Veiculo { }
public class Audi extends Veiculo { }
public class Teste {
public static void main(String[] args) {
Audi a = new Audi();
Veiculo v = new Veiculo();
if (a instanceof Audi) System.out.println("a é do tipo Audi");
if (v instanceof Veiculo) System.out.println("v é do tipo Veiculo");
if (v instanceof Audi) System.out.println("v é do tipo Audi");
if (a instanceof Veiculo)
System.out.println("a é do tipo Veículo");
}
}
O resultados impressos são:
a é o tipo Audi
v é do tipo Veículo
a é do tipo Veículo
Lembre-se do relacionamento is a.

30
 Outros operadores
„ Exemplo:
public interface Acao { }
public class Veiculo implements Acao { }
public class Audi extends Veiculo { }
public class Moto { }
public class Teste {
public static void main(String[] args) {
Audi a = new Audi();
Veiculo v = new Veiculo();
Moto m = new Moto();
if (a instanceof Acao) System.out.println("a é membro de Acao");
if (v instanceof Acao) System.out.println("v é membro de Acao");
if (m instanceof Acao) System.out.println("m é membro de Acao");
}
}
„ Os resultados impressos são:
‹ a é membro de Acao
‹ v é membro de Acao
‹ Aqui devemos lembrar do relacionamento has a.

31

O operador pode ser usado também para verificar se o objeto

implementa uma interface. Veja o exemplo:
public interface Acao { }
public class Veiculo implements Acao { }
public class Audi extends Veiculo { }
public class Moto { }
public class Teste {
public static void main(String[] args) {
Audi a = new Audi();
Veiculo v = new Veiculo();
Moto m = new Moto();
if (a instanceof Acao) System.out.println("a é membro de Acao");
if (v instanceof Acao) System.out.println("v é membro de Acao");
if (m instanceof Acao) System.out.println("m é membro de Acao");
}
}
Os resultados impressos são:
a é membro de Acao
v é membro de Acao
Aqui devemos lembrar do relacionamento has a.

31
 Operadores Matemáticos
„ Usados para realizar operações matemáticas e toda
operação envolvendo tipos primitivos inteiros resultará
em um tipo int.
„ Podem ser:
Unários: -- e ++
Binários: +, -, *. / e %

32

Operadores Matemáticos
Em Java™ temos operadores matemáticos unários e binários.
A utilização desses operadores traz uma importante
informação, toda operação envolvendo tipos primitivos inteiros resultará em
um tipo int, mesmo que a operação envolva uma multiplicação entre um
byte e um short.
Um outro detalhe importante é que em Java™ não existe
divisão de números inteiros por zero, assim como em outra linguagem
qualquer, mas uma divisão por zero em um tipo de ponto flutuante pode
resultar em zero positivo ou zero negativo.
Os operadores são:
Unários: -- e ++
Binários: +, -, *. / e %
No exemplo abaixo abordaremos dois tópicos supra citados.
int x = 10 / 0;//Erro em tempo de execução.
Java.lang.ArithmeticException

32
 Incremento e Decremento
„ São operadores unários.
„ Podem ser pré-fixados ou pós-fixados.

int x = 10;
System.out.println("x é "+(++x));

int x = 9;
System.out.println("x vale: "+x--);
System.out.println("o valor final de x é "+x);

33

Incremento e Decremento
Típico em qualquer linguagem, as operações de incremento e
decremento têm peculiaridades em Java™. Eles são operadores unários.
Tenha-os em mente, podem ser pré-fixados ou pós-fixados. Veja os
exemplos:
int x = 10;
System.out.println("x é "+(++x));
Neste caso você pediu gentilmente para o compilador
incrementar sua variável e ele o fará. O resultado impresso será: 11

int x = 9;
System.out.println("x vale: "+x--);
System.out.println("o valor final de x é "+x);
Temos uma situação interessante neste trecho de código,
vamos analisá-la.
O primeiro comando de impressão imprimirá 9 e o segundo 8.
Isso acontece porque o operador de incremento e decremento pós-fixado só
age após o término da execução

33
 Exercícios

34

Exercício
1) Crie um programa que use os operadores de deslocamento de bits para
direita com sinal, esquerda com sinal e direita sem sinal.
2) Crie um programa passe parâmetros para métodos que retornem tipos
primitivos e este teste o retorno deste métodos.

34
Sumário
Nesta lição você aprendeu:
„ Sobre os atribuições de tipos primitivos

„ Sobre deslocamento de bits e como usá-los

„ Sobre os atribuição de objetos e como usá-los

„ Sobre os operadores de Abreviação e como usá-los

„ Sobre os operadores bit-a-bit e como usá-los

„ Sobre os outros operadores e como usá-los

„ Sobre os operadores matemáticos e como usá-los

„ Como usar incremento e decremento

35

35