Littéraux en Java

Au stade de la création d'une application, le développeur ne connaît généralement que sa structure et ne suppose pas quelles données il va traiter. Cependant, dans certaines situations, vous devez spécifier explicitement certaines données dans le code du programme (par exemple, le nombre d'itérations ou le message à afficher). Dans ce cas, les littéraux viennent à la rescousse. Contenu:

• Que sont les littéraux
• Types de littéraux et leurs utilisations
• Littéraux numériques
• Littéraux de chaîne
• Littéraux de caractères
• Littéraux booléens
• Technique Jedi avec des littéraux
• Littéraux dans le cours JavaRush
• Conclusion

Que sont les littéraux ?

Les littéraux sont des valeurs explicitement spécifiées dans le code du programme - des constantes d'un certain type qui se trouvent dans le code au moment du lancement.

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

Dans ce cours « Bonjour tout le monde ! » - littéral. Il existe différents types de littéraux, déterminés par leur objectif et la manière dont ils sont écrits.

Types de littéraux et leurs utilisations

Tous les littéraux sont des valeurs primitives (chaînes, nombres, caractères, booléens). Vous ne pouvez pas créer un objet littéral. Le seul littéral associé à un objet est null. Selon les primitives, les littéraux sont également divisés en sections :

1. Numérique :
   • Nombres entiers ;
   • Point flottant;
2. Chaîne;
3. Personnage;
4. Casse-tête.

Littéraux numériques

Littéraux entiers

Ce type de littéral est le plus simple. Les nombres sont écrits sous leur forme standard sans indiquer de caractères ou quoi que ce soit d'autre. Tout entier est un littéral entier par défaut. Autrement dit, vous pouvez définir explicitement la valeur d'une variable ou le nombre d'itérations dans une boucle. Java prend en charge 4 systèmes numériques :

• Binaire
• Octal
• Décimal
• Hexadécimal

JDK 7 a introduit la possibilité d'écrire des valeurs binaires . Cela se fait en utilisant le préfixe 0b ou 0B . Vient ensuite l'écriture en utilisant 0 et 1. Les nombres en octal sont écrits en utilisant un 0 non significatif. Les chiffres valides vont de 0 à 7. L'écriture de 09 ou 08 provoquera une erreur de compilation. Il n'y a aucun problème avec le système de nombres décimaux : les nombres sont indiqués sous la forme qui nous est familière. La seule limitation est que le nombre ne peut pas commencer par 0, puisque le compilateur le prendra comme octal. Les nombres en hexadécimal sont écrits en utilisant les préfixes 0x et 0X. Les nombres valides vont de 0 à 15, les nombres 10 à 15 étant respectivement indiqués par les symboles AF.

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);
}

Sortie : Nombre a en système binaire : 854 Nombre b en système octal : 5324 Nombre c en système décimal : 456 Nombre d en système hexadécimal : 1318162 Bien que les nombres soient spécifiés dans différents systèmes numériques, dans le programme, ils sont traités comme décimaux Nombres. Le dépassement des valeurs entraînera une erreur de compilation :

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

Lorsqu'il est exécuté au stade de la compilation, nous obtenons le résultat suivant :

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

Et si vous tapiez ? Tout littéral entier a un type par défaut de int. Si sa valeur est en dehors des limites de la variable affectée, une erreur de compilation se produit. Lorsque vous utilisez un type, longvous devez mettre un symbole à la fin Lindiquant ce type :

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

En essayant de compiler les résultats, vous obtenez l'erreur suivante :

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

Littéraux à virgule flottante

Les nombres à virgule flottante, ou nombres fractionnaires, peuvent être écrits de deux manières. La première est une fraction décimale classique : 3,14159 ou 2,718281282459045. La seconde est sous forme scientifique, c'est-à-dire une fraction décimale ordinaire plus un suffixe sous la forme du symbole e ou E et la puissance 10 par laquelle la fraction spécifiée doit être multipliée. Par exemple, 4.05E-13, cela signifie 4.05 * 10 ^-13 .

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

Sortie : Type double classique : 2.718281828459045 Type double scientifique : 4.05E-13 Contrairement aux nombres entiers et aux systèmes numériques, la notation scientifique est stockée dans une variable et traitée de la même manière que la notation classique. Et si vous tapiez ? Tout nombre à virgule flottante crée un type double. Si vous devez utiliser le type float, vous devez ajouter un for à la fin F. Dans ce cas, doubleil sera réduit au type float. Cela ne se fait pas automatiquement :

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

Au démarrage de la phase de compilation, nous voyons l'erreur suivante :

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

Littéraux de chaîne

Les littéraux de chaîne sont un ensemble de caractères entourés de guillemets doubles. Ce type est utilisé aussi souvent que les littéraux numériques. La ligne peut également contenir des caractères de service qui doivent être échappés (ce qu'on appelle des séquences d'échappement). Exemple:

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

Sortie : Il s’agit d’une chaîne normale. Tout aussi standard et banal que le reste d’entre nous. Et c’est une « ligne » inhabituelle. Ne serait-ce que parce que certains des « mots » qu’il contient sont entre « guillemets ».

Littéraux de caractères

Les caractères littéraux en Java sont représentés par le jeu de caractères Unicode, c'est-à-dire que chaque caractère est une valeur de 16 bits. Pour indiquer un symbole dans le code, il est séparé par des guillemets simples. D’après l’expérience, il existe deux types de symboles :

1. Ceux qui peuvent être saisis à partir du clavier sont des caractères ordinaires ;
2. Symboles qui ne peuvent pas être simplement saisis au clavier (symboles de différentes langues, formes, etc.).

Les caractères normaux peuvent être spécifiés explicitement : ' ,' ou ' @'. Si un caractère est un caractère de service (par exemple, un saut de ligne ou une tabulation), ce caractère doit être échappé avec une barre oblique inverse. Les caractères qui ne peuvent pas être simplement saisis depuis la console peuvent être spécifiés sous leur forme 16 bits. Pour ce faire, vous devez spécifier le code du caractère avec un préfixe \u, par exemple ' \u00F7'. Vous pouvez également spécifier des caractères en style octal (nombre à trois chiffres) en ajoutant simplement une barre oblique inverse au début, par exemple «\122 ». À mon avis, c'est beaucoup plus facile à utiliser \u. Exemple d'utilisation :

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

Sortie : Esperluette - & symbole de division - ÷

Littéraux booléens

Le littéral le plus simple est logique. Il n'y a que 2 valeurs : falseet true, qui sont spécifiées explicitement sans divers symboles. De tels littéraux peuvent être attribués à des variables de type booléen ou spécifiés à un endroit où le type booléen est attendu (par exemple, dans un bloc if, bien que cette pratique soit considérée comme de mauvaises manières, pour le moins).

boolean flag = false;

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

Technique Jedi avec des littéraux

Grâce aux symboles en Java, vous pouvez faire beaucoup de choses intéressantes, notamment gérer les emojis. Par exemple, affichons un visage souriant :

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

Conclusion : Visage souriant : 😀 Bien que l'affichage des emoji puisse être effrayant (selon l'implémentation), cette solution fait bien le travail. Cependant, il est difficile de rechercher l'emoji souhaité dans la table d'encodage standard ; la section Émoticônes sur le site officiel est clairsemée. Il est beaucoup plus simple d'utiliser des bibliothèques supplémentaires.

Littéraux dans le cours JavaRush

Dans le cours JavaRush, les littéraux sont étudiés au niveau 10 dans la leçon 8 du cours Java Syntax , où des exemples expliquent ce que sont les littéraux et pourquoi ils sont nécessaires. JavaRush est un cours en ligne sur la programmation Java mettant l'accent sur la pratique : plus de 1200 tâches avec vérification instantanée, mini-projets, jeux.

Conclusion

Les littéraux en Java sont une chose pratique dans n'importe quel programme, mais ils doivent être utilisés là où cela est approprié. Vous ne devez pas coder en dur les paramètres de connexion à la base de données ou toute valeur susceptible de changer au cours du cycle de vie du programme dans le code source.