Faculté Polydisciplinaire

de Sidi Bennour

Programmations Orientées Objet - JAVA

Chap 2 : Notions pour premiers
programmes

Formation LP-IMA - S5
2021/2022
Pr. M. EL GHAZOUANI
 Plan
1. Introduction a Java
Origine?
Pourquoi JAVA?
JAVA : JVM, JDK, API
Programme JAVA : application/applet
Premier programme (application)
2. Types de données
Types primitifs
Types prédéfinis
Classes Enveloppes
Classes String, StringBuer, ...
3. Structures de contrôles
4. Entrées-Sorties standards
Ecriture, lecture de caractère
La classe Scanner
 Origine?
L'origine du langage Java
Java est un langage oriente objet a été mis au point en 1991 par la compagnie "Sun
Microsystems";
Le projet de développement au départ est connu sous le nom "Oak", dont le but est de
constituer un langage pouvant être intégré dans les électroménagers afin de les
contrôler, et permettre une communication entre les appareils.
L'origine du nom "Java"
En l'honneur de la boisson préférée des programmeurs: le café, dont une partie de la
production provient de l‘île Java.
 Pourquoi JAVA?
Java est un langage objet :
Comme la plupart des langages récents, Java est oriente objet. Chaque fichier source
contient la définition d'une ou plusieurs classes qui sont utilisées les unes avec les autres
pour former une application.
 Pourquoi JAVA?
Java est simple :
Le choix de ses auteurs a été d'abandonner des éléments mal compris ou mal exploites
des autres langages, Certains concepts à l'origine de nombreux "bugs" ont été
supprimes en JAVA. :
 la notion de pointeurs (pour éviter les incidents en manipulant directement la
mémoire),
 l'héritage multiple (pour éviter les ambiguïtés),
ou traites implicitement :
 les chaînes de caractères et les tableaux sont désormais des objets faisant partie
intégrante du langage.
 la libération de mémoire devient automatique grâce au garbage collector ...
 Pourquoi JAVA?
Java est robuste et sûr :
Le compilateur Java est fortement typé ; toutes les variables sont typées et il n'existe
pas de conversion automatique qui risquerait une perte de données. Si une telle
conversion doit être réalisée, le développeur doit obligatoirement utiliser un cast ou
une méthode statique fournie en standard pour la réaliser.
Le traitement des exceptions est obligatoire. Le compilateur vérifie que les erreurs sont
traitées par le développeur. Dans le cas contraire le code ne compilera pas;
 Pourquoi JAVA?
Java est sécurisé :
La gestion de la mémoire n'est pas à la charge du développeur
Garbage Collector (ramasse-miettes) : un programme qui libère la mémoire des
objets qui ne sont plus référencé.
Pas de pointeurs : le fait de ne pas manipuler les pointeurs et donc d'accéder à
des zones mémoire sensibles diminue fortement l'introduction des virus
informatiques.
Le chargeur de classes (ClassLoader) est responsable du chargement dynamique des
classes. Il vérifie que la classe chargée n'en écrase pas une autre en mémoire;
Le gestionnaire de sécurité (la classe SecurityManager) permet de définir un certain
nombre d'autorisations d'entrée/sortie locales et sur le réseau.
 Pourquoi JAVA?
Java est interprété, et portable :
La source est compilée en pseudo code ou byte-code puis exécuté par un interpréteur
Java : la Java Virtual Machine (JVM).
Ce concept est a la base du slogan de Sun pour Java : WORA (Write Once, Run
Anywhere : écrire une fois, exécuter partout). Le bytecode peut être exécuté et
obtenir quasiment les mêmes résultats sur toutes les machines disposant d'une JVM.
La machine virtuelle JVM existe par défaut sur de nombreuses plateformes (Linux,
Unix, Windows, Mac, ...);
Pourquoi JAVA?
 Pourquoi JAVA?
Java est multi-thread :
Une application peut être décomposée en unités d'exécution fonctionnant
simultanément (parallélisme).
 JAVA : JVM, JDK, API
JAVA est un environnement de programmation objet composé de :
 le langage oriente objet JAVA
 la machine virtuelle JVM
 un ensemble d'outils de développement JDK (compilateur, générateur de
documentation, ...)
 un ensemble de classes standards API (application programming interface ou
bibliothèque)
 Outils de de développement JDK
L'outil de base : le JDK (Java Development Kit) de SUN :
gratuit
comprend de nombreux outils :
 le compilateur : javac
 l'interpréteur d'application : java
 le débogueur : jdb
 le générateur de documentation : javadoc
 Liens pour JDK et API
Des environnements de développement non commerciaux :
http://www.eclipse.org/
http://www.netbeans.org/
Des environnements de développement commerciaux:
Visual J++ (Microsoft)
JBuilder (Borland/Inprise)
Des classes Java (API):
https://docs.oracle.com/en/java/javase/13/docs/api/index.html
 Programme JAVA : application/applet
Il existe 2 types de programmes avec la version standard de Java : les applications et les
applets.
Une application autonome (stand alone program) est un programme qui s'exécute sous
le contrôle direct du système d'exploitation.
Une applet est un programme qui est chargé par un navigateur et qui est exécuté sous
le contrôle d'un plug in de ce dernier.
 Programme JAVA : application/applet
Les principales différences entre une applet et une application sont :
les applets n'ont pas de méthode main() : la méthode main() est appelée par la
machine virtuelle pour exécuter une application.
les applets doivent ^être testées avec l'appletviewer ou doivent ^être intégrées à une
page HTML, elle même visualisée avec un navigateur disposant d'un plug in Java,
 Premier programme (application)
public class PremProg {
public static void main(String[] args) {
System.out.println("1er programme Java");
}
}

Tout code java doit être défini à l'intérieur d'une classe

Le code de la classe doit être enregistré dans un fichier de même nom que la classe :
PremProg.java
L'entrée pour l'exécution est la méthode main() qui doit être publique et statique et
située dans une classe qui elle même doit être publique.
 Compilation & Exécution
javac est le compilateur qui convertit le code PremProg.java en fichier
PremProg.class (bytecode Java).
javac PremProg.java
S'il ne donne pas de messages d'erreur, javac produit alors le fichier PremProg.class
au même endroit que PremProg.java. Ce fichier appelé "byte code" contient le code
binaire qui peut être exécuté sur n'importe quelle machine virtuelle Java.
 Compilation & Exécution
Notons que l'on peut compiler d'un seul coup plusieurs fichiers dans un même
répertoire, par la commande :
javac *.java
Les fichiers .class générés portent les mêmes noms que les fichiers sources.
L'exécution du programme est appelée par la commande suivante :
java PremProg
La commande java lance la machine virtuelle JVM pour exécuter le "byte code". On ne
précise pas l'extension .class dans ce cas.
 Types de données
2 grands groupes de types de données :
Types primitifs,
Types de données prédéfinis : objets (instances de classe)
Java manipule différemment les valeurs des types primitifs et les objets :
Les variables contiennent :
des valeurs de types primitifs
ou des références aux objets
 Types primitifs
Les types primitifs en Java sont : byte, short, int, long pour les types entiers, float,
double pour les « réels », un seul type caractère qui est char, et un type booléen à
savoir boolean. Notez le fait que tous ces types ont leur première lettre minuscule, ça
montre que ce ne sont pas des classes d'après les conventions de nommage en Java.
 Types primitifs
Une constante "entière" est de type long si elle
est suffixée par "L" et de type int sinon.
Une constante flottante" est de type float si elle
est suffixée par "F" et de type double sinon
Exemples :
int a = 35
long b = 25832469L
double c = 4.567e2 // 456,7
float d = 0.123587E-25F
 Types primitifs
Une constante "entière" est de type long si elle
est suffixée par "L" et de type int sinon.
Une constante flottante" est de type float si elle
est suffixée par "F" et de type double sinon
Exemples :
int a = 35
long b = 25832469L
double c = 4.567e2 // 456,7
float d = 0.123587E-25F
 Classes Enveloppes
Les classes enveloppes (appelées aussi wrappers) sont
nées d'un besoin de pouvoir encapsuler des types
primitifs dans des objets afin de pouvoir par exemple
les mettre dans une collection ou bien dans une base
de données objet.

Ils sont des classes qui encapsulent les données de type

primitif, afin de pouvoir les utiliser comme des objets.

Les classes Byte, Short, Integer, Long, Float, Double se

sont des sous-classes de la classe Number.
 Classes Enveloppes
Depuis Java 5, les opérations de conversion d'un type primitif vers un objet d'une
classe enveloppe, et la conversion inverse sont devenues automatique.
Toutes les sous-classes de Number possèdent les méthodes byte byteValue(),
short shortValue(), int intValue(), long longValue() et double doubleValue() qui
réalisent les conversions des types primitifs.
Toutes les classes enveloppes ont une méthode x X.parseX(String s) qui essaie de
convertir une chaîne de caractères en une donnée de type primitif, si c'est possible
(lèvent une exception NumberFormatException sinon).
 Classes Enveloppes : Exemple
Integer obj = new Integer(95545);
long l = obj.longValue(); // renvoie la valeur (long) de cet objet Integer

int x =Integer.parseInt("9");

double c = Double.parseDouble("5");
 Conversion de type de données (casting)
On appelle conversion de type de données, parfois transtypage (traduction de l'anglais
casting), le fait de modifier le type d'une donnée en une autre.
conversion implicite: une conversion implicite consiste en une modification du type
de donnée effectuée automatiquement par le compilateur. Cela signifie que lorsque
l'on va stocker un type de donnée dans une variable déclarée avec un autre type, le
compilateur ne retournera pas d'erreur mais effectuera une conversion implicite de la
donnée avant de l'affecter à la variable. Par exemple la conversion d'un type primitif
vers son Wrapper est implicite.
int n = 8;
Integer m = n;
 Conversion de type de données (casting)
• Conversion explicite: une conversion explicite (appelée aussi opération de cast)
consiste en une modification du type de donnée forcée. Cela signifie que l'on utilise
un opérateur dit de cast pour spécifier la conversion. L'opérateur de cast est tout
simplement le type de donnée, dans lequel on désire convertir une variable, entre des
parenthèses précédant la variable.
double x = 8.324;
int n = (int) x;
x contiendra après affectation la valeur 8.
 Exemple
class PremierExempleIf
{
public static void main(String[] args) {

System.out.print("Entrez votre nombre:");

int n = scanner.nextInt();

if (n < 5) {
System.out.println("Votre nombre est plus petit que 5.");
} else {
System.out.println("Votre nombre est plus grand ou égale a 5.");
}
System.out.println(« Fin du programme.");
}
}
Types de données prédéfinis : chaînes de caractères
Chaînes de caractères (String)
Les chaînes de caractères ne correspondent pas à un type de données mais à
une classe, ce qui signifie qu'une chaîne de caractère est un objet possédant
des attributs et des méthodes.
Une chaîne peut donc être déclarée de la façon suivante :
String s = "Chaine de caractères";
Types de données prédéfinis : chaînes de caractères
En Java, les chaînes de caracteres sont des objets des classes String ou
StringBuffer.

La classe String : java.lang.String (1)

La classe String gère des chaînes de caractères non modifiables.

Les valeurs littérales ("abc") peuvent être transformées en String.

L'operateur + permet la concaténation de 2 String.

Types de données prédéfinis : chaînes de caractères
Exemples d'utilisation de la classe String :

 String s = "bonjour"; // s = "bonjour"

 int lg = s.length(); // lg = 7
 String s = "Java" + "Soft"; // s = "JavaSoft"
 char[] data = {'J', 'a', 'v', 'a‘};
 String name = new String(data);
 String s = String.valueOf(2 * 3.14159); // s = "6.28318"
 int i = Integer.valueOf("123"); // i = 123
 String s = "java";
 if (s == "java") {...} // Erreur
 if (s.equals("java")) {...} // Ok
Types de données prédéfinis : chaînes de caractères
La classe StringBuffer :

Il est très souvent utile de modifier des objets String.

La classe StringBuffer : java.lang.StringBuer

La classe StringBuffer gère des chaînes de caractères modifiable

(setCharAt(), append(), insert())

La méthode toString() convertie une StringBuffer en String

Types de données prédéfinis : chaînes de caractères
Exemples d'utilisation de la classe StringBuffer :

 StringBuffer sb = "abc"; // Error: can't convert String to StringBuffer

 StringBuffer sb = new StringBuffer("abc");
 sb.setCharAt(1, 'B');  // sb= "aBc"
 sb.insert(1, "1234");  // sb = "a1234Bc"
 sb.append("defg");  // sb = "a1234Bcdefg"
 String s = sb.toString();  // s = "a1234Bcdefg"
 sb.append("hij");  // sb = "a1234Bcdefghij" s = "a1234Bcdefg"
 Les tableaux
Les tableaux représentent des collections de valeurs ou d’objets. En
Java, les tableaux sont eux-mêmes des objets. Donc une variable de type
tableau peut avoir la valeur null. Une variable de type tableau se
déclare en ajoutant des crochets à la suite du type :

type [] nom ; ex : int[] tableau;

Il est également possible de placer les crochets après le nom de la

variable :

type nom [] ; ex : int tableau[];

 Les tableaux
• Initialisation :
Il est possible d’initialiser une variable de type tableau à partir d’une liste
fixe délimitée par des accolades.
int[] tableauEntier = {1, 2, 3, 4, 5};
String[] tableauChaine = {"Bonjour", "le", "monde"};

• Création avec new :

Les tableaux étant des objets, il est également possible de les créer avec le
mot-clé new.
int[] tableauEntier = new int[] {1, 2, 3, 4};
String[] tableauChaine = new String[] {"Bonjour", "le", "monde"};
 Les tableaux
• Si on ne souhaite pas donner de valeurs d’initialisation pour les
éléments du tableau, il suffit d’indiquer uniquement le nombre
d’éléments du tableau entre crochets.
int[] tableauEntier = new int[5];
String[] tableauChaine = new String[3];

• Dans ce cas, les éléments d’un tableau sont tout de même initialisés
avec une valeur par défaut (0 ou false ou null (selon type de base)).
 Les tableaux
• La taille du tableau peut être donnée par une constante, une
expression ou une variable.
int t = 6;
int[] tableau = new int[t * t * 2];
• Par contre, la taille d’un tableau est donné à sa création et ne peut plus
être modifiée. Il n’est donc pas possible d’ajouter ou d’enlever des
éléments à un tableau. Dans ce cas, il faut créer un nouveau tableau
avec la taille voulue et copier le contenu du tableau d’origine vers le
nouveau tableau. Un tableau dispose de l’attribut length permettant
de connaître sa taille. L’attribut length ne peut pas être modifié.
int t = 6;
int[] tableau = new int[t * t * 2];
System.out.println(tableau.length); // 72
 Les tableaux
Accès aux éléments d’un tableau :

L’accès aux éléments d’un tableau se fait en donnant l’indice d’un élément
entre crochets. Le premier élément d’un tableau a l’indice 0. Le dernier
élément d’un tableau a donc comme indice la taille du tableau moins un.

• int[] tableau = {1, 2, 3, 4, 5};

• int premierElement = tableau[0];
• int dernierElement = tableau[tableau.length - 1];
• System.out.println(premierElement); // 1
• System.out.println(dernierElement); // 5
 Les tableaux
il est possible de parcourir tous les éléments d’un tableau avec un for
amélioré.
int[] tableau = {1, 2, 3, 4, 5};
for (int v : tableau)
{
System.out.println(v);
}
Si le programme tente d’accéder à un indice de tableau trop
grand (ou un indice négatif), une erreur de type
java.lang.ArrayIndexOutOfBoundsException survient.
int[] tableau = {1, 2, 3, 4, 5};
int value = tableau[1000]; // ERREUR À L'EXÉCUTION
 Tableau multidimensionnel
Il est possible d’initialiser un tableau à plusieurs dimensions.

int[][] tableauDeuxDimensions = {{1, 2}, {3, 4}};

int[][][] tableauTroisDimensions = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};
System.out.println(tableauDeuxDimensions[0][1]); //2
System.out.println(tableauTroisDimensions[0][1][0]); //3

Cela signifie que dans un tableau 3D, les trois dimensions sont interprétées comme:
Le nombre de tables / tableaux: La première dimension indique le nombre de tables ou
de tableaux qu'un tableau 3D aura.
Le nombre de lignes: La deuxième dimension signifie le nombre total de lignes qu'un
tableau aura.
Le nombre de colonnes: La troisième dimension indique le nombre total de colonnes
dans le tableau 3D.
 Tableau multidimensionnel
Il est possible d’initialiser un tableau à plusieurs dimensions.

int[][] tableauDeuxDimensions = {{1, 2}, {3, 4}};

int[][][] tableauTroisDimensions = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};
System.out.println(tableauDeuxDimensions[0][1]); //2
System.out.println(tableauTroisDimensions[0][1][0]); //3

Il est également possible de créer un tableau multidimensionnel avec le

mot-clé new.
int[][] tableauDeuxDimensions = new int[2][10];
int[][][] tableauTroisDimensions = new int[2][10][5];
 Tableau multidimensionnel
Il n’existe pas réellement de type tableau multi-dimensionnel. Le
compilateur le traite comme un tableau de tableaux. Il est donc
autorisé de déclarer des tableaux sans préciser les dimensions au delà
de la première et d’affecter ensuite des tableaux à chaque valeur. Ces
tableaux peuvent d’ailleurs avoir des tailles différentes.
int[][] tableauDeuxDimensions = new int[2][];
tableauDeuxDimensions[0] = new int[10];
tableauDeuxDimensions[1] = new int[5];
Tableau - Conversion en chaîne de caractères
Si vous affichez un tableau sur la sortie standard, vous serez certainement
surpris.
int[] tableau = {1, 2, 3, 4, 5};
System.out.println(tableau);
La code précédent affichera sur la sortie standard quelque chose comme ceci :
[I@ee7d9f1
Cela peut sembler un bug mais il n’en est rien. En fait, la conversion d’un
objet en chaîne de caractères affiche par défaut son type suivi du caractère @
suivi du code de hachage de l’objet. Normalement le type d’un objet
correspond au nom de sa classe. Mais le type d’un tableau est noté [ suivi du
type des éléments du tableau (I indique le type primitif int).
Tableau - Conversion en chaîne de caractères
Pour obtenir une chaîne de caractères donnant le contenu du tableau, il faut
utiliser la classe outil java.util.Arrays qui contient des méthodes de classe
toString adaptées pour les tableaux.
int[] tableau = {1, 2, 3, 4, 5};
System.out.println(java.util.Arrays.toString(tableau));

Pour les tableaux multi-dimensionnels, vous pouvez utiliser la méthode

java.util.Arrays.deepToString(Object[]).
 Tableau - Égalité de deux tableaux
La classe outil java.util.Arrays fournit des méthodes de classe equals pour
comparer des tableaux en comparant un à un leurs éléments.

int[] tableau1 = {1, 2, 3, 4, 5};

int[] tableau2 = {1, 2, 3, 4, 5};
System.out.println(java.util.Arrays.equals(tableau1, tableau1)); // true
System.out.println(java.util.Arrays.equals(tableau1, tableau2)); // true
 Tableau - Tri & recherche
Le tri et la recherche sont des opérations courantes sur des tableaux de valeurs.
La classe outil java.util.Arrays offrent un ensemble de méthodes de classe pour
nous aider dans ces opérations.
Tout d’abord, java.util.Arrays fournit plusieurs méthodes sort. Celles prenant
un tableau de primitives en paramètre trient selon l’ordre naturel des éléments.
int[] tableau = {1, 5, 4, 3, 2};
java.util.Arrays.sort(tableau);
System.out.println(java.util.Arrays.toString(tableau));
Il est également possible de trier certains tableaux d’objets. Par exemple, il est
possible de trier des tableaux de chaînes de caractères.
String[] tableau = {"premier", "deuxième", "troisième", "quatrième"};
java.util.Arrays.sort(tableau);
System.out.println(java.util.Arrays.toString(tableau));
 Tableau - Tri & recherche
java.util.Arrays fournit des méthodes binarySearch qui implémentent
l’algorithme de recherche binaire. Ces méthodes attendent comme paramètres
un tableau et une valeur compatible avec le type des éléments du tableau. Ces
méthodes retournent l’index de la valeur trouvée. Si la valeur n’est pas dans le
tableau, alors ces méthodes retournent un nombre négatif.
• int[] tableau = {10, 20, 30, 40, 50};
• System.out.println(java.util.Arrays.binarySearch(tableau, 20)); // 1
• System.out.println(java.util.Arrays.binarySearch(tableau, 45)); // -5
 Tableau - Copie d’un tableau
Comme il n’est pas possible de modifier la taille d’un tableau, la copie peut s’avérer
une opération utile. java.util.Arrays fournit des méthodes de classe copyOf et
copyOfRange pour réaliser des copies de tableaux.
• int[] tableau = {1, 2, 3, 4, 5};

• int[] nouveauTableau = java.util.Arrays.copyOf(tableau, tableau.length - 1);

• System.out.println(java.util.Arrays.toString(nouveauTableau)); // [1, 2, 3, 4]

• nouveauTableau = java.util.Arrays.copyOf(tableau, tableau.length + 1);

• System.out.println(java.util.Arrays.toString(nouveauTableau)); // [1, 2, 3, 4, 5, 0]

• nouveauTableau = java.util.Arrays.copyOfRange(tableau, 2, tableau.length);

• System.out.println(java.util.Arrays.toString(nouveauTableau)); // [3, 4, 5]

• nouveauTableau = java.util.Arrays.copyOfRange(tableau, 2, 3);

• System.out.println(java.util.Arrays.toString(nouveauTableau)); // [3]
 Structures de contrôles
Les instructions de contrôle sont identiques a celles du C/C++ :
if (condition) {
// block of code to be executed if the condition is true
} else {
// block of code to be executed if the condition is false
}
 Structures de contrôles
• switch ( variable ) {
case const1 : { ... }
break ;
case const2 : { ... }
break ;
default : { ... }
};
 Structures de contrôles
for (statement 1; statement 2; statement 3) {
// code block to be executed
}
• Statement 1 is executed (one time) before the execution of the code block.
• Statement 2 defines the condition for executing the code block.
• Statement 3 is executed (every time) after the code block has been executed.

Il existe également une boucle "for-each", qui est utilisée exclusivement pour parcourir
les éléments d'un tableau :
for (type variableName : arrayName) {
// code block to be executed
}
 Structures de contrôles
while ( condition ) { ... };

do {
// code block to be executed
}
while (condition);