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 Booleanbyte Bytechar Characterint Integerlong Longfloat Floatdouble 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 -

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, trueCada uma dessas palavras serão vistas mais adiante no tutorial.

LiteraisO 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

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éticosOperadores 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) {

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 ... }

}Dessa forma evitando o erro ao executar o unboxing.