Literais em Java

1. Literais inteiros

E agora um novo tópico interessante — literais. Os dados gravados diretamente no código do programa são chamados de literais . Não estamos falando de nenhum dado antigo, mas dos valores dos tipos primitivos e do Stringtipo.

Por exemplo, suponha que você tenha o seguinte código:

int a = 5;
int b = a + 10;
String s = "Sum=" + (a + b);

5
10
"Sum="

Os literais neste código são o número 5, o número 10e a string ' Sum = '.

Em Java, tudo, inclusive literais, tem um tipo. Por padrão, todos os literais inteiros (números inteiros) no código são ints. O tipo int é o tipo inteiro Java padrão.

Além do mais, se você decidir atribuir um literal inteiro a uma variável de byte ou uma variável curta em seu código, não haverá problemas. Você só precisa garantir que o valor literal esteja dentro do intervalo de valores que o tipo da variável pode armazenar.

O compilador Java é inteligente o suficiente para entender que uma bytevariável pode receber o literal inteiro 100 sem criar problemas.

Exemplos:

int a = 300;

byte a = 100; 

byte a = 300; 

Você também pode escrever longliterais em seu código. Para fazer isso, adicione a letra latina 'L' ou 'l' no final do número inteiro.

Exemplos:

long a = 3000000000L; 

long a = 3000000000; 

int a = 3000000000L; 

Você notou como é difícil ler grandes números de 10 ou mais dígitos? Você não pode dizer imediatamente se o código diz 3 bilhões ou 30 bilhões. Para tornar o código mais legível (e isso é importante!), Java permite a inserção de sublinhados em literais numéricos (eles não afetam o valor do número).

O exemplo acima pode ser reescrito com sublinhados para torná-lo um pouco mais claro:

long a = 3_000_000_000L; 

long a = 3_000_000_000; 

int a = 3_000_000_000L; 

Mas não podemos usar vírgulas em literais numéricos porque elas já são usadas para outra finalidade. Por exemplo, para separar argumentos uns dos outros ao chamar um método.

2. Literais de números reais

Em seu código, você pode especificar não apenas números inteiros, mas também literais de ponto flutuante (números reais).

Na verdade, a regra é bastante simples: se um número no código tiver um ponto decimal, o número é um literal de ponto flutuante. E não qualquer literal, mas um doubleliteral.

Você pode criar um float literal, mas precisa colocar a letra 'F' (ou 'f') no final do número para fazer isso .

Exemplos:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

A propósito, você pode converter explicitamente um literal inteiro em um float ou double literal simplesmente ). Exemplos: appending the suffix 'F' (for float) or D (for double)

double a = 100D; 

float a = 100F; 

int a = 300D; 

Literais de ponto flutuante podem usar notação científica : além da parte com sinal do número, você também pode especificar uma potência de dez. Exemplo:

1.23E2

1.23 * 102

123.0

1.23E3

1.23 * 103

1230.0

1.23E-6

1.23 * 10-6

0.00000123

1E6

1.0 * 106

1000000.0

1E-10

1.0 * 10-10

0.0000000001

3. Literais de string

Você também pode especificar linhas inteiras de texto em seu código. Para dizer ao compilador para tratar uma string como dados (um literal) e não como parte do código, a string inteira é cercada por aspas duplas em ambos os lados.

Se uma única linha de código tiver várias aspas duplas, elas serão divididas em pares. A primeira aspa dupla indica o início de um literal. O próximo indica o fim do literal. O próximo depois disso mais uma vez marca o início de um novo literal. E o próximo marca o fim do segundo literal. E assim por diante.

Cada um desses literais é um String.

Exemplos

"+" + "+" + "+" + "+" + "+"

""

"2+3" + "-5"

"return" + ";"

Se uma string literal for muito longa, ela pode ser dividida em várias linhas e colada com o 'operador de mais':

String s = "I hold it true, whate'er befall, "
         + "I feel it when I sorrow most; "
         + "'Tis better to have loved and lost "
         + "Than never to have loved at all.";

4. Literais de caracteres

Você pode especificar não apenas strings literais em seu código, mas também literais compostas por caracteres individuais. Observe que não estamos falando de uma string composta por um único caractere, mas sim de literais cujo tipo é char.

Ao contrário de uma string, um caractere literal é colocado entre aspas simples . Dentro das aspas simples deve haver um caractere e apenas um caractere. Você não pode usar aspas simples vazias.

Exemplos:

'A'

'@' 

'本' 

'\u1f3a'

O último exemplo atribui um caractere Unicode usando uma notação especial: primeiro temos o prefixo \u, seguido por 4 caracteres hexadecimais. As próximas lições incluem informações detalhadas sobre isso.