Literais para Tipos Primitivos

Um literal primitivo é apenas uma representação de código-fonte dos tipos de dados primitivos, em outras palavras, um número inteiro, número de ponto flutuante, booleano que é digitado ao escrever código.

Literais Inteiros

Existem três formas de representar números inteiros em Java: decimal (base 10), octal (base 8) e hexadecimal (base 16).

Literais Decimais

Inteiros decimais são representados como realmente são.

Literais Octais

Inteiros octais usam somente os dígitos de 0 a 7. Em Java, um número na forma octal é representado pela colocação de um zero na frente do número. Quando chega ao número 7, deve-se voltar para o 0 e adicionar o número 1 na sua frente, e assim por diante.

Literais Hexadecimais

Números hexadecimais são construídos utilizando 16 símbolos diferentes. Como nunca foram inventados símbolos digitais únicos para números de 10 a 15, são utilizados caracteres alfabéticos para representar esses dígitos (a linguagem aceita letras maiúsculas ou minúsculas nesse caso, sem fazer diferença entre elas).

É possível ter até 16 dígitos em um número decimal, não incluindo o prefixo 0x.

Obs.: todas as três literais (octal, decimal e hexadecimal) são definidas como int por default, mas elas também podem ser atribuídas a uma variável long, colocando o sufixo L ou l depois do número.

Literais de Ponto Flutuante

Números de ponto flutuante são definidos por um número, um símbolo decimal, e mais números representando a fração.

Literais de ponto flutuante são definidos como double (65 bits) por default, então se for necessário assinar uma literal de ponto flutuante como float, deve-se colocar o sufixo F ou f no número.

É possível também colocar o sufixo D ou d para literais double, mas não é necessário porque este já é o default.

Literais Boolean

Um valor boolean somente pode ser definido como true ou false.

Literais Character

Um literal character é representado por um único caractere em aspas simples. Também pode receber o valor Unicode de um caractere.

Caracteres são apenas 16-bits, isso significa que qualquer literal numérica pode ser atribuída, desde que se encaixe nos 16 bits (65535 ou menos). Isso quer dizer que um char pode receber um literal decimal, octal ou hexadecimal, por exemplo, desde que caiba nos 16 bits; caso contrário, será necessário casting com perda de dados.

Valores Literais para Strings

Uma literal string é o valor de um objeto String. Uma string não é um tipo primitivo, mas pode ser representada como literal porque pode ser digitado diretamente no código.

public class Literais_Primitivos {

     

      //literal decimal

      byte num = 15;

     

      //literal octal

      int six = 06; //equivale ao decimal 6

     

      //literal hexadecimal

      int hex = 0x0001;

      long hex2 = 0xFFFFFFFL;

     

      //literais de ponto flutuante

      //erro - perda de precisão

      float f = 23.467890;

      //ok - sufixo F

      float g = 23.467890F;

      //sufixo D é opcional

      double d = 110599.995011D;

     

      //literais boolean

      boolean teste = false;

     

      //litetais character

      char ch = 'A';

      char ch2 = '\u004E'; //letra N

      char ch3 = 0x892; //hexadecimal literal

      char ch4 = 982; // int literal

      //necessário cast, pois o valor possui

      //mais que 16 bits - perda de precisão

      char ch5 = (char)70000;

     

      //literais string

      String nome = "Kamilla";

     

}

Fonte: SCJP Sun Certified Programmer for Java 6 Study Guide