INF111 – Programmation Orientée Objet

Service des enseignements généraux.

Francis Bourdeau, copyright 2022
Cours 1 – Notion 3 : Les types, les variables et les
constates.
1.3.1 La représentation des nombres
Les humains comprennent aisément les nombres écrits en base 10. Ainsi, la séquence des chiffres 285
représente la quantité deux cent quatre-vingt-cinq. Inconsciemment, nous calculons la valeur de cette quantité
en multipliant chaque coefficient du nombre par un poids associé à la position du coefficient.
Poids 102 101 100
Coefficient 4 8 5

𝑉𝑎𝑙𝑒𝑢𝑟 = 4 ∗ 100 + 8 ∗ 10 + 5

Les ordinateurs fonctionnent dans avec des nombres écrits en base 2. Toutefois, le même principe s'applique
pour calculer la quantité représentée par une séquence de bit. Ainsi la séquence : 0100 0011 vaut la quantité
67.
Poids 231 ¨¨ 27 26 25 24 23 22 21 20
Coefficient 0 ¨¨ 0 1 0 0 0 0 1 1

𝑉𝑎𝑙𝑒𝑢𝑟 = 0 + 64 + 0 + 0 + 0 + 0 + 2 + 1

Cette dernière affirmation est vraie seulement si l'on interprète la séquence de bits comme étant un entier. Si
l'on considère cette séquence de bits comme étant une valeur réelle à simple précision, elle représente la
donnée 9.4x10-44. Et encore, si l'on considère cette séquence de bits comme du texte, elle représente la lettre
'C'.

INF111 – Programmation Orientée Objet 1

1.3.2 Les types
Tous les identifiants (variables, constantes, méthodes, valeurs, etc.) présent dans un programme en Java
possède un type. Le type d'un identifiant détermine :
- les valeurs possibles que peuvent prendre un identifiant ;
- les opérateurs qui peuvent s'appliquer sur un identifiant ;
- le comportement des opérateur qui s'applique sur un identifiant.

Types primitif Signification Taille en octet Plage de valeurs acceptée

byte Octet 1 ( 8 bits) -128 à 127
short Entier court 2 (16 bits) - 32 768 à 32 767
int Entier 4 (32 bits) - 2 147 483 648 à 2 147 483 647
long Entier Long 8 (64 bits) -263 à 264
unsigned long int Entier long non signé 4 0 à 4 294 967 295

Tableau 1 : Les types représentant les nombres entiers.

Contrairement à plusieurs langages de programmation, il n'est pas possible de déclarer des valeurs non-signés
en Java. Tous les nombres entiers, sont représentés en compléments à deux ce qui implique la représentation
des nombres négatifs. À moins de nécessiter l'emploi d'une très grande valeur, j'emploierai toujours le type
primitif "int" pour représenter un nombre entier.

Types de données en C Signification Taille en octet Plage de valeurs acceptée

float Flottant (réel) 4 (32 bits) 3.4*10-38 à 3.4*1038

double Flottant double (réel) 8 (64 bits) 1.7*10-308 à 1.7*10308

Tableau 2 : Les types représentant les nombres réels.

La distinction entre le float et le double réside dans le nombre de bits employés pour conserver ces valeurs sous
le format IEEE-754. De telle différence sont très subtils et de faible importance. Dans ce cours, j'emploierai
toujours le type primitif "double" pour représenter un nombre réel.

Types primitif Signification Taille en octet Plage de valeurs acceptée

boolean État logique non-précisé true, false
char Caractère 2 (16 bits) Les caractères Unicode.
Autant de caractères que votre
String Mots, phrases non-précisé
RAM accepte.

Tableau 3 : Autres types primitifs.

Il est à noter que le type String n'est pas un type primitif, mais nous le traitons comme tel pour l'instant. Un
cours complet sera dédié à la manipulation de ce type. Toutes les Strings sont immuables, ce qui signifie qu'elles
ne peuvent changer de valeur une fois qu'elles ont été créées.

INF111 – Programmation Orientée Objet 2

1.3.3 Déclarations et définitions de variables
En Java, tout identifiant doit être déclaré avant de pouvoir être utilisé dans un programme. La déclaration d'un
identifiant implique de fixer son type. Une variable est un type d'identifiant permettant de représenter une
donnée située dans une case mémoire de la RAM de l'ordinateur.

La syntaxe suivante permet de déclarer une variable (sans la définir).

// Syntaxe :
type nom_variable;

// Voici des exemples de déclarations de variables

public static void main(String[] args)
{
int nbCours;
double moyenneGpa;

String sigle;
char cote;
boolean aPasser;

/*************************************/
/* Les instructions du programme ... */
/*************************************/
}

En Java, tout identifiant doit être défini avant de pouvoir être utilisé dans un programme. La définition d'un
identifiant implique de fixer son contenu. La définition d'une variable équivaut à l'initialiser avec une valeur.

La syntaxe suivante permet de définir une variable (sans la déclarer). Notez que les définitions de variables
peuvent être situées à n'importe quel endroit dans le corps d'un programme, mais doivent être fait avant la
première lecture de la variable.
// Syntaxe :
nom_variable = valeur_initiale;

// Voici des exemples de déclarations de variables

public static void main(String[] args)
{
int nbCours;
double moyenneGpa;

String sigle;
char cote;
boolean aPasser;

// Voici des exemples de définitions de variables

nbCours = 3;
moyenneGpa = 3.72;

sigle = "INF111";
cote = 'A';
aPasser = true;

/*************************************/
/* Les instructions du programme ... */
/*************************************/
}

INF111 – Programmation Orientée Objet 3

Notez qu'il est possible de déclarer et définir une variable simultanément.
// Voici des exemples de déclarations et définition de variables
public static void main(String[] args)
{
int nbCours = 3;
double moyenneGpa = 3.72;

String sigle = "INF111";

char cote = 'A';
boolean aPasser = true;

/*************************************/
/* Les instructions du programme ... */
/*************************************/
}

On remarque que les données numériques et booléennes peuvent être assignées directement aux variables.
Pour ce qui est des caractères, il faut les placer entre apostrophes, alors que les mots et les phrases doivent être
placés entre guillemets.

Lors de la déclaration d’une variable, il est important d’expliquer à quoi cette variable servira à l’aide d’un
commentaire positionné à droite de sa déclaration. Le nom de l’identificateur de la variable doit être significatif
selon son usage. On tente généralement d’éviter les identificateurs d’une seule lettre, sauf dans des cas très
précis tels que :
- i, j et k (indice de boucles);
- x, y et z (coordonnées);
- f, m et a (des notions de physiques comme la force, la masse, etc.).

Référez-vous au normes de programmation officiel en java pour plus de détail :

https://www.oracle.com/java/technologies/javase/codeconventions-namingconventions.html

INF111 – Programmation Orientée Objet 4

1.3.4 Déclarations et définitions de constantes
Une constante est un identifiant qui conserve la même valeur tout au long de l'exécution du programme. Une
fois la constante déclarée et définie, elle ne peut plus changer de valeur. Pour s'assurer qu'un identifiant ne peut
changer de valeur, le mot final est ajouté devant sa déclaration. Généralement, les constantes sont déclarées à
l'extérieur du programme principal, à l'intérieur de la classe, afin qu'elles puissent être disponibles dans toutes
les méthodes d'une application.
public class Exemple1
{
//
// Exemple de déclarations de variables
//
final int NB_VIES = 3;

final double PI = 3.141592;

final int JOUEUR_BLANC = 1;

final int JOUEUR_NOIR = 2;

public static void main(String[] args)

{
int joueur_humain = JOUEUR_BLANC;
int joueur_ordinatuer = JOUEUR_NOIR;

double rayon = 5.0;

double circonference = rayon * 2 * PI;

/*************************************/
/* Les instructions du programme ... */
/*************************************/
}
}

On remarque qu'il est tout à fait possible d'employer des constantes des assignations et des calculs.

INF111 – Programmation Orientée Objet 5