Pr. Y.

IDRISSI KHAMLICHI
[Link]@[Link]
Année Universitaire : 2021/2022
[Link]
ENSA-Fès

Java Orienté Objet

Partie 1

1 ENSA Fès
Plan
 Java, la notion d’Objet et de Classes
 Héritage et polymorphisme
 Les collections, les exceptions, les Threads
 Les interfaces graphiques en swing
 ….

2 ENSA Fès
Introduction
 Java est fortement objet (inspiré du C++)
 Simple :
 Pas de pointeurs et pas de gestion de mémoire par le programmeur
 Robuste :
 Nombreuse vérifications sont faites à la compilation (protection des
classes, …)
 Sécurisé à la conception du langage :
 Les notions de sécurité réseau sont incluses
 Compact
 Java a été conçu pour fonctionner dans un environnement évolutif
 L’interpréteur Java n’a besoin que de 215ko
 Chargement dynamique des classes

3 ENSA Fès
 Caractéristiques
Langage Interprété
Traduit et exécuté à chaque chargement Pas de Fichier Exécutable
Développement plus simple
Dépendant du processeur et de l ’OS
Temps d’exécution plus long
Dépend de la Réalisation de la
machine virtuelle

Fichier *.java
Indépendant du processeur et
de l ’OS
dépend de la définition de la Fichier *.class
machine virtuelle
Indépendant du processeur et de
l ’OS
dépend de la définition de la
machine virtuelle

4 ENSA Fès
Principe de fonctionnement
 Source Java
 Fichier utilisé lors de la phase de programmation
 Le seul fichier réellement intelligible par le programmeur!

 Byte-Code Java
 Code objet destiné à être exécuté sur toute « Machine Virtuelle »
Java
 Provient de la compilation du code source

 Machine Virtuelle Java

 Programme interprétant le Byte-Code Java et fonctionnant sur un
système d’exploitation particulier
 Conclusion : il suffit de disposer d’une « Machine Virtuelle » Java
pour pouvoir exécuter tout programme Java même s’il a été compilé
avec un autre système d’exploitation.

5 ENSA Fès
Machines virtuelles Java

6 ENSA Fès
Java Virtual Machine

7 ENSA Fès
Version JDK

8 ENSA Fès
Compilation du programme

9 ENSA Fès
Premier programme en Java

10 ENSA Fès
 Types de base
 Langage fortement typé comme C++

 Les types de base

Type Taille Valeur
int 4 bytes -2147483648 à + 2147483647 ( 2^31)
short 2 bytes -32768 à +32767
long 8 bytes -263 .. 263-1
byte 1 byte -128 à +127
float 4 bytes +/- ( 1,4.10 - 45 à 3.4 10 + 38 )
double 8 bytes +/- ( 4,94 .10 -324 à 1,79 . 10 + 308 )
char 2 bytes 65536 caractères (internationaux)
boolean true or false

11 ENSA Fès
Les commentaires

12 ENSA Fès
Les variables
 La valeur de la variable peut être définie (initialisée), consultée,
modifiée en utilisant le nom de la variable.
 Les variables ont une visibilité et une durée de vie qui dépendent du
contexte dans lequel elles sont déclarées.
 Le type d'une variable peut être soit un type primitif, soit un type
référence (c'est-à-dire le nom d'une classe ou d'un tableau)
 Exemples :
 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)

13 ENSA Fès
Initialisation

14 ENSA Fès
Conversions de types

15 ENSA Fès
Conversions de types

16 ENSA Fès
Types de base
 Exemple de déclaration des variables

Fichier "[Link]"
public class Variables {
public static void main(String params[]){
int i=15 , j;
String chaine = "Cours Java";
// On donne une valeur à j
j = 10;
// On utilise ces variables en les affichant
[Link]("i = " + i + " et j = " + j);
[Link]("chaine = " + chaine);
}}
17 ENSA Fès
les instructions du langage
L'instruction conditionnelle if

public class Essai {

public static void main(String args[]) {
// On récupère le nombres de paramètres
// saisis sur la ligne de commande
int a =1; int b =2;
if (a>b) { [Link]("a est plus grand que
b"); [Link](-1); }
else { [Link]("a est plus petit que b");
[Link](-1); }
}}
18 ENSA Fès
Les instructions du langage
La boucle for

public class Essai {

public static void main(String args[])
{
// On veut réaliser 10 affichages

for(int i=0;i<10;i++)
[Link]("i vaut : " + i);

}}

19 ENSA Fès
 Les instructions du langage
La boucle while

public class Counter {

public static void main(String args[])
{ int somme=0, indice=1;
while(indice<=10) somme += indice++;
String str = "La somme des dix premiers entiers positifs
est : ";
[Link](str + somme);
}}

20 ENSA Fès
 Les instructions du langage

La boucle while

public class Counter {

public static void main(String args[])
{ int somme=0, indice=1;
while(indice<=10) somme += indice++;
String str = "La somme des dix premiers entiers positifs est : ";
[Link](str + somme);
}}

21 ENSA Fès
Les instructions du langages
L'instruction continue
L'instruction Continue relance une boucle à un moment donné.

public class TenCounterMinusFive {

public static void main(String args[]){
int somme=0, indice=1;
while(indice<11) {
if (indice==5) { indice++; continue; }
else somme += indice++; }
String str = "La somme des dix premiers entiers
positifs (privé de 5) est : ";
[Link](str + somme);
}}
22 ENSA Fès
Les instructions du langage
L'instruction break

Fichier "[Link]"
public class Break {
public static void main(String args[]){
int somme=0, indice=1;
while(indice<=10) {
if (indice==5) break;
somme += indice++; }
[Link]("Le résultat vaut :
"+somme); }}

23 ENSA Fès
 Les instructions du langage
L'instruction switch
Fichier "[Link]"
public class Switch {
public static void main(String args[]){
for(int i=0;i<10;i++)
switch(i){
case 9: [Link]("Neuf"); break;
case 8: [Link]("Huit"); [Link](""); break;
case 7: { [Link]("Sept"); [Link](""); } break;
case 6: [Link]("Six ");
case 5: [Link]("Cinq"); break;
case 4: case 3: [Link]("Quatre Trois ");
case 2: [Link]("Deux"); break;
case 1: [Link]("Un"); break;
default: [Link]("Zero"); } }}
Résultats
ZeroUnDeuxQuatre Trois DeuxQuatre Trois DeuxCinqSix CinqSeptHuitNeuf>

24 ENSA Fès
Opérateurs sur les types primitifs

25 ENSA Fès
Affectation, recopie et comparaison

26 ENSA Fès
Procédures

27 ENSA Fès
Procédures

28 ENSA Fès
Fonctions

29 ENSA Fès
Structures d’un programme en Java

30 ENSA Fès
Mots réservés

31 ENSA Fès
 Les classes et les objets

32 ENSA Fès
Notion d’objet
Les objets / Encapsulation :
Un objet est constitué :
d’une collection d’attributs (définissant l’état de l’objet)
et de méthodes associées (définissant son comportement)

Modularité et masquage de l’information

les méthodes constituent l’interface maVoiture
de communication
Attributs vitesse = 0 km/h
la manipulation d’un objet peut se faire
immatriculation = 432...
indépendamment de sa mise en œuvre
(structure interne) accelerer()
Méthodes
ralentir()

Les attributs sont « encapsulés » dans l’objet et

Attributs par conséquent protégeables
contre des accès non autorisés

33 ENSA Fès
Notion d’objet
❖ Les classes = des prototypes
« Une classe est un prototype (moule)
qui définit les attributs et les méthodes
communs à tous les objets d’un certain type. »

❖ Un objet = instance d’une classe

▪ Une classe permet par instanciation de construire des objets
▪exemples :
v1 et v2 sont deux instances (objets) de la classe Voiture

v1 v2
vitesse = 10 km vitesse = 50 km
immatriculation = 432... immatriculation = 124...
accelerer() accelerer()
ralentir() ralentir()

34 ENSA Fès
Classe

35 ENSA Fès
Codage de la classe « voiture »

36 ENSA Fès
 Création d’objet
❖Tout objet doit être créé : new
▪ Tous les objets sont alloués par « new » dans la mémoire
Voiture v = new Voiture() ; // appel au constructeur de la classe

❖Le nom d'un objet mémorise en fait une « référence » vers l'objet

Voiture v1; // déclaration d’une référence (~ adresse, pointeur)

// = initialisé à null si v1 est un attribut
// = non initialisé si v1 est une variable locale
Voiture v2 = new Voiture( ); // création d’un nouvel objet

v2 @

v1 @

v1 = v2; // v1 et v2 correspondent à 2 références du même objet

// « pointent ou référencent le même objet »
37 ENSA Fès
Constructeur de « Voiture »

38 ENSA Fès
Constructeur de « Voiture »

39 ENSA Fès
Exemple : la classe Point

public class Point { /** Déplacement du point selon les valeurs

private int x; * du vecteur (dx,dy) passé en paramètre */
private int y; public void deplace(int dx, int dy) {
/** Méthode d'accès : x += dx;
* abscisse du point */ y += dy;
public int x() { }
return x;
public static void main(String[ ] args) {
}
Point p1=new Point(10,10);
/** Méthode d'accès :
* ordonnée du point Point p2=new Point(20,20);
*/ [Link]("p1 : ("+p1.x()+","+p1.y()+")");
public int y() { [Link]("p2 : ("+p2.x()+","+p2.y()+")");
return y; [Link](1,1);
} [Link]("p2 apres deplacement de (1,1)
/** Constructeur de point à partir : ("+p2.x()+","+p2.y()+")");
* de coordonnées cx et cy */ }
public Point(int cx, int cy) { } p1 : (10,10)
x = cx; p2 : (20,20)
y = cy; p2 apres deplacement de (1,1) : (21,21)
}

40 ENSA Fès
 Surcharge de méthode
❖ Surcharge
▪ On surcharge une méthode en gardant le même nom et le même type de retour
mais en changeant les paramètres (type et/ou nombre <=> signature)
public class Point {
private int x;
private int y;

public int x() { return x; }

public int y() { return y; }

public void deplace(int dx, int dy) { Le compilateur choisit la méthode

en fonction de sa signature
x += dx; y += dy;
}
public void deplace(int d) { Point p1 = new Point();
x += d; y += d; [Link](10 , 15);
} [Link](10);
… }

41 ENSA Fès
 Constructeur: Exemple
class Point {
private double x; public class Ex1 {
private double y; public static void main (String[ ] arg) {
/* Constructeur : quelles sont les valeurs Point a ;
initiales d'un point */ [Link]("Creation de a");
public Point (double a, double b) { // Création du point 1,2, constructeur 1
[Link]("Constructeur 1"); a= new Point(1,2);
x = a; [Link]("Fin Création de a");
y = b; [Link]("Creation de b");
} // Création du point 0,0 constructeur 2
public Point () { Point b = new Point();
[Link]("Constructeur 2"); [Link]("Fin création de b");
x = 0; [Link]("Création de c");
y = 0; // Création de C à partir de b;
} Point c = new Point(b);
public Point (Point a) { [Link]("Fin création de c");
[Link]("Constructeur 3"); }
x = a.x; }
y = a.y;
}
Constructeur de copie
};

42 ENSA Fès
 Héritage simple

43 ENSA Fès
Héritage : Syntaxe

44 ENSA Fès
Héritage

45 ENSA Fès
Héritage : Niveaux

46 ENSA Fès
Surcharge et redéfinition

47 ENSA Fès
Accès au membre des superclasses

48 ENSA Fès
 Exemple
public class Point {
private double x,y;
public Point() { super(); }
public Point(double x, double y) { super(); this.x = x; this.y =
y; }
public double getX() { return x; }
public void setX(double x) { this.x = x; }
public double getY() { return y; }
public void setY(double y) { this.y = y; }
public void change(double x, double y) { this.x = x; this.y = y; }

@Override
public String toString() { return "Point [x=" + x + ", y=" + y +
"]";
}

49 ENSA Fès
Exemple : la classe PointCouleur
public class PointCouleur extends Point{
int couleur;
public PointCouleur() { super(); couleur = 0; }
public PointCouleur(double a, double b, int c){
super(a, b); couleur = c;
}
public int getC(){ return couleur; }
public void setC(int c){
couleur = c;
}
public void change(double a, double b, int c){
[Link](a, b); couleur = c;
}
public String toString(){
return [Link]()+" , "+couleur;
}
}

50 ENSA Fès
Exemple d’utilisation
public class programme {

public static void main(String[] args) {

PointCouleur p1 = new PointCouleur(2.0, 5.0, 9);
[Link]([Link]());

[Link](1.0, 1.0, 14);

[Link]([Link]());

[Link](3.1, 5.2);
[Link]([Link]());
}

51 ENSA Fès