Literais em Java

Na fase de criação de uma aplicação, o desenvolvedor, via de regra, conhece apenas sua estrutura e não assume quais dados irá processar. No entanto, em algumas situações, é necessário especificar explicitamente alguns dados no código do programa (por exemplo, o número de iterações ou a mensagem a ser emitida). Nesse caso, os literais vêm em socorro. Contente:

• O que são literais
• Tipos de literais e seus usos
• Literais numéricos
• Literais de string
• Literais de caracteres
• Literais booleanos
• Técnica Jedi com literais
• Literais no curso JavaRush
• Conclusão

O que são literais?

Literais são valores especificados explicitamente no código do programa - constantes de um determinado tipo que estão no código no momento da inicialização.

class Test {
   public static void main(String[] args) {
       System.out.println("Hello world!");
   }
}

Nesta aula “Olá, mundo!” - literalmente. Literais vêm em diferentes tipos, determinados por sua finalidade e como são escritos.

Tipos de literais e seus usos

Todos os literais são valores primitivos (strings, números, caracteres, booleanos). Você não pode criar um objeto literal. O único literal associado a um objeto é null. De acordo com as primitivas, os literais também são divididos em seções:

1. Numérico:
   • Inteiros;
   • Ponto flutuante;
2. Corda;
3. Personagem;
4. Quebra-cabeças.

Literais numéricos

Literais inteiros

Este tipo de literal é o mais simples. Os números são escritos em sua forma padrão, sem indicar caracteres ou qualquer outra coisa. Qualquer número inteiro é um literal inteiro por padrão. Ou seja, você pode definir explicitamente o valor de uma variável ou o número de iterações em um loop. Java suporta 4 sistemas numéricos:

• Binário
• octal
• Decimal
• Hexadecimal

O JDK 7 introduziu a capacidade de escrever valores binários . Isso é feito usando o prefixo 0b ou 0B . Em seguida, vem a escrita usando 0 e 1. Os números em octal são escritos usando um 0 à esquerda. Os dígitos válidos são de 0 a 7. Escrever 09 ou 08 causará um erro de compilação. Não há problemas com o sistema numérico decimal : os números são indicados na forma que conhecemos. A única limitação é que o número não pode começar com 0, pois o compilador o considerará como octal. Os números em hexadecimal são escritos usando os prefixos 0x e 0X. Os números válidos vão de 0 a 15, onde os números de 10 a 15 são indicados por símbolos AF, respectivamente.

public static void main(String[] args) {
       int a = 0b1101010110;
       int b = 012314;
       int c = 456;
       int d = 0x141D12;
       System.out.println("Число a в двоичной системе: " + a);
       System.out.println("Число b в восьмеричной системе: " + b);
       System.out.println("Число c в десятичной системе: " + c);
       System.out.println("Число d в шестнадцатеричной системе: " + d);
}

Saída: Número a em sistema binário: 854 Número b em sistema octal: 5324 Número c em sistema decimal: 456 Número d em sistema hexadecimal: 1318162 Apesar de os números serem especificados em diferentes sistemas numéricos, no programa eles são processados ​​​​como decimais números. Exceder os valores resultará em erro de compilação:

int b = 012914; // Ошибка
int d = 0x141Z12; // Ошибка

Quando executado na fase de compilação, obtemos o seguinte resultado:

Error:(13, 25) java: integer number too large: 012914
Error:(14,30) java: ';' expected

E quanto à digitação? Qualquer literal inteiro tem um tipo padrão de int. Se o seu valor estiver fora dos limites da variável atribuída, ocorre um erro de compilação. Ao utilizar um tipo, longdeve-se colocar um símbolo no final Lindicando este tipo:

long x = 0x1101010110; // Ошибка
long b = 1342352352351351353L; // Все в порядке

Tentando compilar resulta no seguinte erro:

Error(11, 26) java: integer number too large: 1101010110

Literais de ponto flutuante

Números de ponto flutuante, ou números fracionários, podem ser escritos de duas maneiras. A primeira é uma fração decimal clássica: 3,14159 ou 2,718281282459045. A segunda está na forma científica, ou seja, uma fração decimal ordinária mais um sufixo na forma do símbolo e ou E e a potência de 10 pela qual a fração especificada deve ser multiplicada. Por exemplo, 4,05E-13, isso significa 4,05 * 10 ^-13 .

double a = 2.718281828459045;
double d = 4.05E-13;
System.out.println("Тип double в классическом виде: " + a);
System.out.println("Тип double в научном виде: " + d);

Saída: Tipo duplo clássico: 2.718281828459045 Tipo duplo científico: 4.05E-13 Ao contrário dos números inteiros e dos sistemas numéricos, a notação científica é armazenada em uma variável e processada da mesma maneira que a notação clássica. E quanto à digitação? Qualquer número de ponto flutuante cria um tipo double. Se precisar usar o tipo float, você deve adicionar um fou no final F. Neste caso doubleserá reduzido ao tipo float. Isso não acontece automaticamente:

float a = 2.718281828459045; // Ошибка
float d = 4.05E-13F; // Все в порядке

Ao iniciar na fase de compilação, vemos o seguinte erro:

Error:(11, 27) java: incompatible types: possible lossy conversion from double to float

Literais de string

Literais de string são um conjunto de caracteres entre aspas duplas. Este tipo é usado com a mesma frequência que literais numéricos. A linha também pode conter caracteres de serviço que precisam ser escapados (as chamadas sequências de escape). Exemplo:

String simpleString = "Это обычная строка. Такая же стандартная и непримечательная, How и все мы.";
String uniqueString = "А это необычная \"строка\". Хотя бы потому, что часть \"слов\" в ней в \"кавычках\".";
System.out.println(simpleString);
System.out.println(uniqueString);

Saída: Esta é uma string normal. Tão padrão e normal quanto o resto de nós. E esta é uma “linha” incomum. Até porque algumas das “palavras” nele contidas estão entre “aspas”.

Literais de caracteres

Literais de caracteres em Java são representados pelo conjunto de caracteres Unicode, ou seja, cada caractere é um valor de 16 bits. Para indicar um símbolo no código, ele é separado por aspas simples. Com base na experiência, existem dois tipos de símbolos:

1. Aqueles que podem ser inseridos no teclado são caracteres comuns;
2. Símbolos que não podem ser simplesmente inseridos no teclado (símbolos de vários idiomas, formas e assim por diante).

Caracteres regulares podem ser especificados explicitamente: ' ,' ou ' @'. Se um caractere for um caractere de serviço (por exemplo, uma quebra de linha ou tabulação), esse caractere deverá ser escapado com uma barra invertida. Os caracteres que não podem ser simplesmente inseridos no console podem ser especificados no formato de 16 bits. Para fazer isso, você deve especificar o código do caractere com um prefixo \u, por exemplo ' \u00F7'. Você também pode especificar caracteres no estilo octal (número de três dígitos) simplesmente adicionando uma barra invertida no início, por exemplo ' \122'. Na minha opinião, é muito mais fácil de usar \u. Exemplo de uso:

System.out.println("Амперсанд - " + '&');
System.out.println("Символ деления - " + '\u00F7');

Saída: E comercial - e símbolo de divisão - ÷

Literais booleanos

O literal mais simples é lógico. Existem apenas 2 valores: falsee true, que são especificados explicitamente sem vários símbolos. Esses literais podem ser atribuídos a variáveis ​​​​do tipo booleano ou especificados em um local onde o tipo booleano é esperado (por exemplo, em um bloco if, embora essa prática seja considerada falta de educação, para dizer o mínimo).

boolean flag = false;

if(true) {
    // Действия будут выполняться всегда.
}

Técnica Jedi com literais

Graças aos símbolos em Java, você pode fazer muitas coisas interessantes, incluindo gerenciar emojis. Por exemplo, vamos exibir um rosto sorridente:

int smile = 0x1F600; // Здесь шестнадцатеричный code эмоджи
StringBuilder sb = new StringBuilder();
sb.append(Character.toChars(smile)); // Собираем в StringBuilder
System.out.println("Улыбающееся лицо: " + sb.toString()); // Выводим

Conclusão: Rosto sorridente: 😀 Embora a exibição de emojis possa ser assustadora (dependendo da implementação), esta solução faz bem o trabalho. No entanto, é difícil procurar o emoji desejado na tabela de codificação padrão; a seção Emoticon no site oficial é escassa. É muito mais fácil usar bibliotecas adicionais.

Literais no curso JavaRush

No curso JavaRush, os literais são estudados no nível 10 na aula 8 do curso Java Syntax , onde exemplos explicam o que são literais e por que são necessários. JavaRush é um curso online de programação Java com ênfase na prática: mais de 1200 tarefas com verificação instantânea, miniprojetos, jogos.

Conclusão

Literais em Java são convenientes em qualquer programa, mas devem ser usados ​​nos locais onde for apropriado. Você não deve codificar parâmetros de conexão de banco de dados ou quaisquer valores que possam mudar durante o ciclo de vida do programa no código-fonte.