O documento descreve os tipos primitivos em Java, incluindo seus tamanhos e faixas de valores. Também discute literais, conversões entre tipos, operadores aritméticos e bitwise.

1. Tipos Primitivos
Java possui oito tipos primitivos, sendo que todos os tipos primitivos iniciam com palavras
em minusculo. Os tipos primitivos são:
* byte, 8 bits com sinal
* short, 16 bits com sinal
* int, 32 bits com sinal
* long, 64 bits com sinal
* char, é representado por caracter Unicode de 16 bits (sem sinal)
* float, 32 bits com sinal
* double, 64 bits com sinal
* boolean, só aceita os valores: true e false
Tipos primitivos em JAVA
Tipos primitivos
em JAVA Tipo
Tamanho (bytes) Faixa
char 2 Caracteres UNICODE
boolean 1 true ou false
byte 1 Inteiro: -128 a 128
short 2 Inteiro: -32768 a 32767
int 4 Inteiro: -2147483648 a
2147483647
long 8 Inteiro: -9223372036854775808
a 9223372036854775807
float 4 Ponto flutuante: +/-3.4E-38 a +/-
3.4E+38
double 8 Ponto flutuante: +/-1.7E-308 a
+/-1.7E+308
Primitiva Classe
boolean Boolean
byte Byte
char Character
int Integer
long Long
float Float
double Double
Converte boolean byte short char int long float double
boolean - N N N N N N N
byte N - S S S S S S
short N C - S S S S S
char N C C - S S S S
int N C C C - S S* S
long N C C C C - S* S*
float N C C C C C - S
double N C C C C C C -

2. onde: N - não pode realizar a conversão; S - conversão de ampliação (não é necessário o uso
de cast); S* - apesar de ser conversão de ampliação pode ocorrer perda de informação; C -
conversão de estreitamento, o uso de cast é obrigatório.
Palavras chave e valores literais
Java possui 49 palavras chave, todas elas são escritas em minúsculas:
byte - short - int - long - char - boolean - double - float - public - private - protected - static -
abstract - final - strictfp - transient - synchronized - native - void - class - interface - implements -
extends - if - else - do - default - switch - case - break - continue - assert - const - goto - throws -
throw - new - catch - try - finally - return - this - package - import - instaceof - while - for - volatile
– super
Possui três identificadores que são valores literais: null, false, true
Cada uma dessas palavras serão vistas mais adiante no tutorial.
Literais
O valor literal é um valor escrito no código fonte e identificado como de um tipo primitivo.
int x = 1; // literal inteiro
char u = 'a'; // literal char
boolean b = true; // literal boolean
double d = 002.11d; // literal double
Há três maneiras de representar literais numéricos inteiros em Java:
– octal (base 8). Representado com um 0 na frente de cada valor numérico. Exemplo:
int x = 01;
int x = 0931;
int x = 021;
– hexadecimal (base 16). Representado com um 0x na frente de cada valor numérico.
Exemplo:
int quinze = 0xF; // 15 (decimal)
int vinte_e_nove = 0x1D; // 29 (decimal)
int vinte_e_nove = 0x1D; // 29 (decimal)
int valor = 0xBAFAFA; // 12253946 (decimal)
int valor = 0XBaFaFa; / / 12253946 (decimal)
Caracteres também possuem representação especial. Todo o caractere se encontra entre
aspas simples, porém pode-se atribuir um valor inteiro ao caractere sem precisar de uma conversão
explícita. Alguns exemplos são:
char a = 'A'; // letra A
char b = '&'; // caractere &
char c = 'u004D'; // letra M (Unicode)
char d = 'n'; // Pula de linha
char e = 't'; // Tab
char f = 'r'; // Retorno de carro
char g = 'b'; // Backspace
char h = 'f'; // FormFeed
char i = ''; // Barra
char j = '''; // Apostrofo
char k = '"'; // Aspas duplas
char l = 65; // char recebe o valor de um int
char m = (char) -1; // fora do intervalo, conversão explícita

3. char n = (char) 100000; // fora do intervalo, conversão explícita
Conversão implícita, quando o tamanho de uma variável é maior que o tamanho da variável
ou o valor que está sendo atribuído. Exemplo:
int y = 10;
long x = y;
O tamanho de int é menor que o de long, portanto é perfeitamente aceitável.
Conversão explícita, quando o tamanho de uma variável é menor que o tamanho da variável
ou o valor que está sendo atribuído. Exemplo:
long y = 10L;
int x = (int) y;
O tamanho de long é maior que o de int, portanto necessita indicar uma conversão. Esta
indicativa é feita pelo tipo da variável, que irá receber o valor, entre parênteses: (int). Se esta
informação não for colocada, ocorreria um erro de compilação indicando tipos incompatíveis. Outra
forma é usar as constantes de identificação de tipos para fazer uma conversão explícita, como em:
long y = 10L;
Operadores aritméticos
Operadores aritméticos são aqueles que efetuam operações aritméticas em um ou mais tipos
primitivos. A seguir são apresentados os operadores aritméticos unários, que atuam sobre um único
identificador.
Op Nome Uso Descrição
++ Incremento var++ / ++var Retorna e adiciona / adiciona e retorna.
-- Decremento var-- / --var Retorna e subtrai / subtrai e retorna.
- Negativo -var Inverte o sinal da variável
+ Positivo +var Não tem efeito.
Operadores bitwise
Os operadores bitwise são aqueles que alteram o valor das variáveis em operações lógicas
diretamente no processador, tornando-as muito mais performáticas. Estas operações são geralmente
chamadas de ? tratamento por bits ? pois são operações que comparam e modificam a variável bit
por bit.
Op Nome Uso Descrição
~ Inversão ~x Inversão dos bits de x.
& E lógico x & y AND bit a bit entre x e y.
| OU lógico x | y OR bit a bit entre x e y.
^ OU excl. lógico x ^ y XOR bit a bit entre x e y.
<< Desloc. a esq. x << y Desloc. a dir os bits de x, y vezes.
>> Desloc. a dir. x >> y Desloca a direita os bits de x, y vezes.
>>> Desloc. a dir. x >>> y Preenche zero a esquerda de x, y vezes.
O operador de atribuição composto
Já foi apresentado o operador de atribuição " = ". Porém este operador pode funcionar em
conjunto com outros operadores reduzindo o tempo de processamento de determinadas chamadas.
O operador de atribuição composto junta um operador aritmético ou de bitwise com o operador de
atribuição. É sempre utilizado na sintaxe var = var como no exemplo abaixo:
public class OperadorAtribuicaoComposto {
public static void main (String [] args) {

4. int x = 1;
x + = 5;
}
}
Neste exemplo a variável inteira x é inicializada com 1 e na linha seguinte é realizado
uma operação composta: A soma e atribuição. Esta instrução é semelhante a esta: x = x + 5;.
O resultado em x será 6. Outros exemplos são:
public class OperadorAtribuicaoComposto {
public static void main (String [] args) {
int x = 1; // Atribui 1 a x
x += 5; // Equivalente a x = x + 5; x é igual a 6
x *= 2; // Equivalente a x = x * 2; x é igual a 12
x /= 2; // Equivalente a x = x / 2; X é igual a 6
x -= 3; // Equivalente a x = x - 3; x é igual a 3
x %= 5; // Equivalente a x = x % 5; x é igual a 3
x |= 4; // Equivalente a x = x | 4; x é igual a 7
x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
x &= 255; / / Equivalente a x = x & 255; x é igual a 6
x <<= 2; / / Equivalente a x = x << 2; x é igual a 24
x >>= 4; // Equivalente a x = x > > 3; x é igual a 1
x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
}
}
Validar unboxing para tipos primitivos
Java, a partir da versão 5, permite que tipos primitivos sejam usados em conjunto com
objetos que os encapsulem sem necessidade de uma conversão explícita. Este processo, que
transforma automaticamente um int em Integer, é chamado de Autoboxing e seu reverso (que
transforma um Integer em int) de unboxing. Entretanto os objetos que encapsulam tipos primitivos
(conhecidos por wrappers) permitem o valor null enquanto os tipos primitivos não aceitam. Um
serviço que receba objetos wrapper deve validar se o objeto não é nulo antes de proceder a
operações que envolvam o unboxing. O trecho de código abaixo:
public void f(Integer wrapper) {
int primitive = 0;
if(wrapper == primitive) {
// ... excuta operação ...
}
}
Pode comprometer a execução da aplicação caso o chamador do serviço envie valores nulos.
Para evitar que o serviço provido seja interrompido por uma exceção, o trecho deve ser reescrito de
forma a testar se o parâmetro é nulo:
public void f(Integer wrapper) {
int primitive = 0;
if(wrapper != null && wrapper == primitive) {
// ... excuta operação ...
}

5. }
Dessa forma evitando o erro ao executar o unboxing.