Java/Literais

Origem: Wikilivros, livros abertos por um mundo aberto.
< Java
Saltar para a navegação Saltar para a pesquisa

Literais[editar | editar código-fonte]

Literais são as representações de dados dentro do código fonte. Na linguagem Java, literais representam os dados dos tipos primitivos, dos tipos String e dos tipos nulo, por exemplo.
Assim, podemos subdividir os literais em:
  • Literais Booleanos ou Lógicos: correspondem ao valores true (verdadeiro) e false (falso).
  • Literais inteiros: representam os números inteiros e podem ser de base octal, decimal, ou hexadecimal. Assim:
    • Literais Inteiros Decimais: são números em base decimal que representam um valor inteiro. Eles podem ser tanto byte, como short, int ou long. Para escrever um literal inteiro na base decimal, basta digitar o seu valor com um desses dígitos: 0 1 2 3 4 5 6 7 8 9.
    • Literais Inteiros Octais: são números em base octal que representam um valor inteiro. Para representar este tipo de literal, basta escrever os seus dígitos colocando 0 (dígito zero) antes. Os dígitos para este tipo são: 0 1 2 3 4 5 6 7.
    • Literais Inteiros Hexadecimais: são números em base hexadecimal que representam um valor inteiro. Para representar este tipo de literal basta escrever os seus dígitos normalmente precedidos pelos caracteres 0x (zero xis) ou 0X. Os dígitos permitidos são: 0 1 2 3 4 5 6 7 8 9 A a B b C c D d E e F f.
  • Literais Fracionários (de Ponto Flutuante): correspondem aos números racionais (fracionários). Para representá-los, basta escrever um número inteiro seguido por um ponto e por sua parte decimal - o ponto faz o lugar da vírgula. Outra opção seria escrever o número em notação científica, escrevendo primeiro o valor da mantissa, seguido do caractere "e" e do valor do expoente (de base 10).
  • Literais Caracteres: correspondem a um caractere. Para representá-los, basta escrever o caractere cercado por apóstrofos. Também podem armazenar caracteres de controle de formatação (quebra de linha, etc.) e também caracteres no formato unicode.
  • Literais de cadeias de caracteres - Strings: correspondem às cadeias de caracteres. Para representá-los, escreva o(s) caracter(es) cercado(s) por aspas.
  • Literal nulo: representa a ausência de tipo e de dado (valor). Para representar utiliza-se a palavra null.
Os literais atribuem valores às variáveis ou partes do código. Ou seja, eles são usados para fazer com que variáveis passem a ter um valor ou se executem cálculos. Exemplos:
 boolean ligado=true;
 int velocidade=128;
 int x=0012;
 int peso=0x12a;
 float preco=1.24;
 char letra='f';
 int pesoTotal;
 pesoTotal=x*peso/4;
 String texto="Isto é um exemplo de cadeia de caracteres";

Nos exemplos acima, pudemos ver exemplos da atribuição de valores iniciais às diversas variáveis no momento da declaração assim como, a partir da declaração de pesoTotal (sem valor inicial), do cálculo de pesoTotal igual a x vezes o peso dividido por 4. A variável ligado recebe o valor "verdadeiro", velocidade recebe o número 128, x recebe 12 em octal que é o mesmo que 10 em decimal, peso recebe 12A em hexadecimal que é o mesmo que 298 em decimal, preco recebe 1,24 e letra recebe f. Já a variável texto recebe Isto é um exemplo de cadeia de caracteres.

Regras para representar literais fracionários (de ponto flutuante)[editar | editar código-fonte]

Regras básicas[editar | editar código-fonte]

  • Os literais do tipo float são representados colocando-se a letra F ou f após o número. Por exemplo:
 12f
 22F
Observação: é importante a utilização do F (ou f) após o número para representar o tipo float já que sua omissão implicará que o literal passe a ser automaticamente interpretado como sendo do tipo double. Por exemplo:
  • Os literais do tipo double são representados colocando-se a letra D ou d após o número.
 12d
 22D
  • A separação entre a parte inteira e fracionário do número é feita através do ponto - ao invés da vírgula. Por exemplo:
12.0f representa o número 12
22.23F representa o número 22,23
  • Caso a parte inteira seja 0 ("zero"), ela poderá ser omitida desde que se coloque o ponto (representando a vírgula) e a parte fracionária. Por exemplo:
.1f representa o número 0,1     
.0F representa o número 0

Outras variações de representação[editar | editar código-fonte]

Os literais fracionários também podem ser representados com o uso de uma exponenciação em base 10, ou seja, através do número seguido da letra e ou E seguido do expoente de base 10 a ser multiplicado e do f ou F. Exemplo:
1e3f representa o número , ou seja, 1000
-1e3F representa o número , ou seja, -1000
1e-2F representa o número , ou seja, 0,01
-1e-3F representa o número , ou seja, -0,001
Exista também a representação de literais fracionários em hexadecimal.
a fazer

Representação de caracteres de controle de texto[editar | editar código-fonte]

Caracteres de controle de texto podem ser representados da seguinte forma:
Código Significado
Escape Unicode
\b \u0008 caractere de retrocesso (backspace - BS)
\t \u0009 tabulação horizontal tab (horizontal tab - HT)
\n \u000a quebra de linha (linefeed - LF)
\f \u000c quebra de página (form feed - FF)
\r \u000d retorno de carro (carriage return - CR)
\" \u0022 aspas (double quote - " )
\' \u0027 apóstrofo (single quote - ' )
\\ \u005c barra invertida (backslash - \ )

Representação de caracteres no formato Unicode-16[editar | editar código-fonte]

Unicode é padrão que define um conjunto de caracteres universais. O padrão Unicode-16 define caracteres com o uso de 2 bytes (16 bits). Na linguagem Java, define-se esses caracteres com \u seguido de 4 dígitos hexadecimais (dígitos 0 1 2 3 4 5 6 7 8 9 A a B b C c D d E e F f). Assim, a representação poderá variar de \u0000 até \uFFFF. Exemplos:
Caractere
Unicode-16
Caractere
gerado
\u7Fff 翿
\u7Ffc
\u0062 b
\u0078 x
Exemplo de declaração de uma variável do tipo char usando o literal Unicode-16:
 char letrax='\u0078';