Programmation Orientée Objet avec Java

03 : Éléments de Base - Commentaires, Identificateurs et Types Primitifs

Commentaires en Java

Java supporte trois formes de commentaires qui permettent de documenter le code :

1. Commentaires de ligne simple : `// …Texte…`

Commence dès // et se termine à la fin de la ligne
Sur une seule ligne
À utiliser de préférence pour les commentaires généraux

2. Commentaires de bloc : `/* …Texte… */`

Le texte entre /* et */ est ignoré par le compilateur
Peuvent s'étendre sur plusieurs lignes
Ne peuvent pas être imbriqués
Peuvent être utiles pour désactiver temporairement une zone de code

3. Commentaires de documentation : `/** …Texte… */`

Commentaire de documentation (comme /* … */ mais avec fonction spéciale)
Interprétés par l'utilitaire javadoc pour créer une documentation au format HTML
Peuvent contenir des balises de documentation (@author, @param, …)
Peuvent contenir des balises HTML

Exemple complet de commentaires :

/**
* Somme : Calcule une somme
*
* @author Marc Duchemin
* @version 2.3 08.07.2014
*/
public class Somme {
/*--------------------------------------------------+
| Programme principal |
+--------------------------------------------------*/
    public static void main(String[] params) {
        //--- Initialisation des variables
        int a = 1;
        int b = 2;
        int total; // Totalisateur
        total = a + b;
        //--- Affichage du résultat de l'addition
        System.out.println("Résultat = " + total);
    }
}

Identificateurs

Les identificateurs sont des noms symboliques permettant de référencer les éléments des programmes Java (variables, fonctions, ...).

Règles pour les identificateurs :

Doivent commencer par une lettre ou un souligné _ (ou, à éviter, un caractère monétaire $)
Suivi (éventuellement) d'un nombre quelconque de lettres, chiffres ou soulignés (ou, à éviter, de caractères monétaires)
Distinction entre les majuscules et les minuscules (case sensitive)
Utilisent le jeu de caractères Unicode (16 bits)
Les mots réservés du langage sont exclus

Attention : Éviter de créer des identificateurs qui ne se distinguent que par la casse. Selon les plates-formes, les caractères alphabétiques spéciaux (caractères accentués, lettres grecques, …) peuvent poser des problèmes ⇒ À éviter.

Exemples d'identificateurs valides :

maVariable
_temp
resultat2
MAX_VALUE
$compteur // À éviter

Exemples d'identificateurs invalides :

2resultat // Commence par un chiffre
ma-variable // Contient un tiret
class // Mot réservé

Mots réservés (Keywords)

Mots réservés principaux	Mots réservés secondaires	Littéraux prédéfinis
`abstract` `assert` `boolean` `break` `byte` `case` `catch` `char` `class` `const` `continue`	`default` `do` `double` `else` `enum` `extends` `final` `finally` `float` `for` `goto`	`true` `false` `null`
`if` `implements` `import` `instanceof` `int` `interface` `long` `native` `new` `package`	`private` `protected` `public` `return` `short` `static` `strictfp` `super` `switch` `synchronized`
`this` `throw` `throws` `transient` `try` `void` `volatile` `while`

Notes :

const et goto : mots réservés mais non utilisés actuellement
assert : disponible depuis la version 1.4 du JDK
enum : disponible depuis la version 1.5 du JDK

Notion de Variable

Définition :

Une variable définit une case mémoire nommée et typée.

Le nom est représenté par un identificateur
Le type définit le genre d'informations qui sera enregistré ainsi que les opérations possibles
Il existe des types prédéfinis mais il est possible de créer ses propres types

Syntaxe de déclaration :

Type Identificateur;
float note;
Polygone triangle;

Représentation en mémoire :

// Déclaration
float note;
// Représentation mémoire :
// note → [adresse mémoire] → contenu indéfini

// Affectation
note = 5.2;
// Représentation mémoire :
// note → [adresse mémoire] → 5.2

Exemples de déclarations :

int unNombreEntier; // Type primitif int
String motDePasse; // Classe String (prédéfinie)
Point position; // Classe Point
char[] voyelles; // Tableau de caractères
Point[] nuage; // Tableau de Point(s)

Types Primitifs

Tableau des types primitifs :

Type	Contient	Taille	Valeurs
`boolean`	Booléen	[1 bit]	`true`, `false`
`char`	Caractère (entier non-signé)	16 bits	`\u0000..\uFFFF`
`byte`	Entier signé	8 bits	`-128..127`
`short`	Entier signé	16 bits	`-2¹⁵.. 2¹⁵-1`
`int`	Entier signé	32 bits	`-2³¹.. 2³¹-1`
`long`	Entier signé	64 bits	`-2⁶³.. 2⁶³-1`
`float`	Nombre en virgule flottante	32 bits	`±3.4*10³⁸`
`double`	Nombre en virgule flottante	64 bits	`±1.7*10³⁰⁸`

Détails des types primitifs :

Booléen (`boolean`) :

Ne peuvent prendre que deux valeurs : true ou false
Ne peuvent pas être interprétés comme des valeurs numériques [0, 1]

Caractère (`char`) :

Caractères Unicode (codage normalisé sur 16 bits)
Peuvent être traités comme des entiers non-signés
Séquences d'échappement pour caractères spéciaux :

Code	Signification
`\b`	Retour en arrière (Backspace)
`\t`	Tabulateur horizontal
`\n`	Saut de ligne (Line-feed)
`\f`	Saut de page (Form-feed)
`\r`	Retour de chariot (Carriage-Return)
`\"`	Guillemet
`\'`	Apostrophe
`\\`	Barre oblique arrière (Backslash)
`\xxx`	Caractère Latin-1 (xxx : valeur octale 000..377)
`\uxxxx`	Caractère Unicode (xxxx : valeur hexadécimale 0000..FFFF)

Entiers signés (`byte`, `short`, `int`, `long`) :

Valeurs littérales (int par défaut) : notation habituelle
Suffixe l ou L pour type long (L est préférable)
Préfixe 0 (zéro) pour valeur octale (base 8)
Préfixe 0b ou 0B pour valeur binaire (base 2) - Java 7+
Préfixe 0x ou 0X pour valeur hexadécimale (base 16)

0 // valeur de type int
123 // valeur de type int
-56 // valeur de type int
0377 // 377 [octal] = 255 [décimal]
433L // valeur de type long
0b1011 // valeur binaire de type int
0xff // valeur hexadécimale de type int
0xA0B3L // valeur hexadécimale de type long

Nombres en virgule flottante (`float`, `double`) :

Norme IEEE 754-1985
Précision : float ≈ 6 chiffres significatifs, double ≈ 15 chiffres significatifs
Valeurs littérales (double par défaut) : notation habituelle (n.m)
Suffixe f ou F pour type float
Suffixe d ou D pour type double (rarement nécessaire)
Notation exponentielle avec e ou E suivi de l'exposant
Valeurs spéciales : infini, -infini, zéro négatif, NaN (Not a Number)

Attention : Les nombres en virgule flottante sont des approximations de nombres réels (tous les nombres réels ne peuvent pas être représentés de manière exacte). Il faut en tenir compte dans les comparaisons.

Questions de Cours

Question 1: Types de commentaires

Quelle est la différence fondamentale entre les commentaires /* */ et /** */ en Java?

Réponse :

Les commentaires /* */ sont des commentaires de bloc standards, ignorés par le compilateur.

Les commentaires /** */ sont des commentaires de documentation interprétés par l'utilitaire javadoc pour générer automatiquement de la documentation HTML. Ils peuvent contenir des tags spéciaux comme @author, @param, @return, etc.

Question 2: Règles des identificateurs

Parmi les identificateurs suivants, lesquels sont valides en Java et pourquoi?

maVariable
2resultat
_temp
class
ma-variable

Réponse :

maVariable : Valide - commence par une lettre
2resultat : Invalide - commence par un chiffre
_temp : Valide - commence par un underscore
class : Invalide - mot réservé du langage
ma-variable : Invalide - contient un caractère spécial (-)

Question 3: Types primitifs entiers

Quelle est la plage de valeurs pour le type byte en Java et pourquoi cette plage est-elle limitée?

Réponse :

Le type byte a une plage de valeurs de -128 à 127.

Cette limitation vient du fait qu'un byte utilise 8 bits en mémoire. Avec 8 bits, on peut représenter 2⁸ = 256 valeurs différentes. Comme il s'agit d'un type signé, la plage est divisée entre valeurs négatives et positives : -128 à 127.

Question 4: Caractères et Unicode

Quelle est la différence entre 'A' et "A" en Java? Expliquez en termes de type de données.

Réponse :

'A' est un caractère de type char - il représente un seul caractère Unicode entre apostrophes.

"A" est une chaîne de caractères de type String - c'est un objet qui représente une séquence de caractères entre guillemets, même s'il n'y a qu'un seul caractère.

Question 5: Séquences d'échappement

Que produira l'instruction suivante et pourquoi?

System.out.println("Ligne1\nLigne2\tTabulation");

Réponse :

Cette instruction produira :

Ligne1
Ligne2 Tabulation

Explication :

\n : séquence d'échappement pour un saut de ligne
\t : séquence d'échappement pour une tabulation horizontale

Question 6: Notation des nombres

Quelles sont les valeurs décimales des littéraux suivants?

0377
0xFF
0b1010
123L

Réponse :

0377 = 255 (notation octale : 3×8² + 7×8¹ + 7×8⁰)
0xFF = 255 (notation hexadécimale : 15×16¹ + 15×16⁰)
0b1010 = 10 (notation binaire : 1×2³ + 0×2² + 1×2¹ + 0×2⁰)
123L = 123 (notation décimale normale, type long)

Question 7: Variables et mémoire

Expliquez ce qui se passe en mémoire lors de la déclaration et de l'initialisation d'une variable.

Réponse :

Lors de la déclaration int age; :

La JVM réserve un espace mémoire de 32 bits (taille d'un int)
Cet espace est associé à l'identificateur "age"
La valeur initiale est indéfinie (peut contenir n'importe quelle valeur)

Lors de l'initialisation age = 25; :

La valeur 25 est stockée dans l'espace mémoire réservé
La variable devient utilisable dans le programme

Question 8: Types flottants

Pourquoi faut-il être prudent lors de comparaisons avec des nombres à virgule flottante en Java?

Réponse :

Les nombres à virgule flottante sont des approximations de nombres réels en raison :

De la représentation binaire qui ne peut pas représenter exactement certaines fractions décimales
Des erreurs d'arrondi lors des calculs
De la précision limitée (6 chiffres pour float, 15 pour double)

Il est donc déconseillé de faire des comparaisons d'égalité exacte (==) avec des flottants. On préfère comparer la différence avec une tolérance :

// Au lieu de : if (x == y)
// On utilise :
if (Math.abs(x - y) < 0.0001) { ... }

Résumé

Java propose trois types de commentaires : ligne simple (//), bloc (/* */) et documentation (/** */)
Les identificateurs doivent suivre des règles strictes de nommage
Les mots réservés ne peuvent pas être utilisés comme identificateurs
Une variable représente une case mémoire nommée et typée
Java a 8 types primitifs : boolean, char, byte, short, int, long, float, double
Les caractères utilisent l'encodage Unicode avec des séquences d'échappement
Les nombres peuvent être représentés en décimal, octal, hexadécimal et binaire