Vous êtes sur la page 1sur 94

OBJECTIFS DU COURS

 Décrire les éléments-clé de la plate-forme Java

 Compiler et exécuter une application Java

 Comprendre et utiliser la documentation en ligne de Java

 Décrire la syntaxe du langage

 Comprendre le paradigme OO et utiliser Java pour le mettre en œuvre

 Comprendre et utiliser les exceptions

 Développer un programme qui utilise une interface graphique pour introduire les données à
traiter

 Comprendre la gestion des événements

 Développement des applets


JAVA COMME PLATEFORME

Plateforme = environnement hardware ou software sur


lequel le programme est exécuté.
 La « Java Platform » est constituée de :
• La « Java Virtual Machine » (JVM)
• Des interfaces de programmation d’application (Java API)

2
JAVA COMME LANGAGE DE PROGRAMMATION

Le compilateur Java génère un bytecode, c’est à dire un


format intermédiaire, neutre architecturalement, conçu pour
faire transiter efficacement le code vers des hardware
différents et/ou plateformes différentes
Le bytecode ne peut-être interprété que par le processeur de
la JVM

3
DÉPLOIEMENT D’UN PROGRAMME CLASSIQUE DE LA COMPILATION

4
DÉPLOIEMENT D’UN PROGRAMME
CHANGEMENT DE LA VISION TRADITIONNELLE DE LA COMPILATION

Chaque programme est compilé et interprété


« Write once run everywhere »

5
JAVA ET SES VERSIONS

Quelques versions de la Machine Virtuelle


• Java 2 Micro Edition (Java ME): cible les terminaux
portables.
• Java 2 Standard Edition (Java SE) : cible les postes
clients.
• Java 2 Entreprise Edition (Java EE) : définit le cadre
d’un serveur d’application.
Différentes finalités
• SDK (Software Development Kit) : fournit un
compilateur et une machine virtuelle.
• JRE (Java Runtime Environment) : fournit
uniquement une machine virtuelle. Idéal pour le
déploiement de vos applications.

6
II. PREMIÈRE APPLICATION EN
JAVA
COMMENT DÉVELOPPER UNE APPLICATION?

Deux façons d’écrire des programmes Java:


En écrivant le code dans un simple éditeur de texte
 Compilation et exécution du code en ligne de commande DOS

En utilisant un environnement de développement (IDE)


 Netbeans (http://www.netbeans.com)
 Eclipse (https://www.eclipse.org/downloads/)
 Borland JBuilder (http://www.borland.com/jbuilder)
…
UNE PREMIÈRE APPLICATION

APPLICATION VERSUS APPLET


Une application Java
 est composée d’une classe possédant une méthode main() :
public static void main (String[] args){
//code à exécuter pour initialiser l’application
}
 L’environnement d’exécution dépend de l’OS de la machine
 Pas de restriction au niveau des API

Une applet Java


 Comprend une classe publique dérivant de java.applet.Applet
 L’environnement d’exécution dépend du browser Web
 Restrictions au niveau des API
 Généralement pas autorisée à lire ou écrire sur des fichiers locaux.
 Interdiction d’ouvrir des connections réseaux vers d’autres systèmes que la machine hôte qui a chargé l’applet
 …
INSTRUCTIONS

• Les instructions Java se terminent par un ;


• Les blocs sont délimités par
{ pour le début de bloc
} pour la fin du bloc
Un bloc permet de définir un regroupement d’instructions. La définition
d’une classe ou d’une méthode se fait dans un bloc.
• Sauts de ligne, les espaces et les tabulations sont autorisés. Cela permet de
présenter un code plus lisible.
POINT D’ENTRÉE D’UN PROGRAMME JAVA

Pour pouvoir faire un programme exécutable, il faut toujours une


classe contenant une méthode particulière, la méthode « main ».

– C’est le point d’entrée dans le programme : le


microprocesseur sait qu’il va commencer à exécuter les
instructions à partir de cet endroit.

public static void main(String args[ ])


{
…/…
}
APPLICATION BONJOUR LE MONDE

Créer un fichier texte : Bonjour.java


Règle de bonne pratique : 1 classe par fichier et 1 fichier par classe

public class Bonjour La première ligne du programme doit être la


déclaration de la classe
{
public static void main (String[]args) Tout programme doit contenir une méthode
{ main qui porte la signature ci-contre
System.out.println(« Bonjour le monde"); Écrire à l’écran “Bonjour le monde”
}
}
Fermer les accolades

· Compiler le programme : javac Bonjour.java


· Le compilateur génère le bytecode dans le fichier : Bonjour.class
· Exécuter l’application : java Bonjour
· « Bonjour le monde » s’affiche à l’écran
IDENTIFICATEURS

• On a besoin de nommer les classes, les variables, les constantes, etc. ;


on parle d’identificateur.
• Les identificateurs commencent par une lettre, _ ou $
Attention : Java distingue les majuscules des minuscules .
• Conventions sur les identificateurs :
 La première lettre est majuscule pour les classes et les interfaces.
 exemples : MaClasse
 La première lettre est minuscule pour les méthodes, les
attributs et les variables.
• exemples : getLongueur(), i
 Les constantes sont entièrement en majuscules.
• exemple : HAUTEUR_MAX
COMMENTAIRES DANS LE CODE SOURCE

Java dispose de trois formes de commentaires :


 Tout texte entre « // » et la fin de la ligne
// Commentaires sur une seule ligne

 Tout texte entre « /* » et « */ »


/* Commentaires
sur un nombre très important
de lignes */

 Les textes entre « /** » et « */ » sont utilisés pour créer des commentaires que l’exécutable
JAVADOC pourra traiter afin de produire une documentation
/** Commentaires afin de produire
la documentation */
LES MOTS RÉSERVÉS DE JAVA

abstract default goto null synchronized

boolean do if package this

break double implements private throw

byte else import protected throws

case extends instanceof public transient

catch false int return true

char final interface short try

class finally long static void

continue float native super volatile

const for new switch while


TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE

Java est un langage fortement typé


Le type de données précise
 les valeurs que la variable peut contenir
 les opérations que l’on peut réaliser dessus

Deux types de données:


 Donnée primitive: contient physiquement la valeur
(caractère, nombre, booléen)
 Référence: contient l’adresse mémoire où l’information relative à l’objet,
l’interface, etc. est réellement stockée

Référence: Adresse
TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE
TYPES DE DONNÉES PRIMITIFS (1/4)

P rim itive Da ta T yp es

In teg ral F lo ating

b yte 8 bits -12 8 to 1 27 flo at 3 2b its 1 .4 E-4 5 3 .4E 38


sh ort 1 6 bits -3 27 68 to 3 27 67 d o ub le 6 4b its 4 .9 E -3 2 4 1.8 E3 08
in t 3 2 bits -2^3 1 to 2 ^31 -1
lo n g 6 4 b its -2^6 3 to 2 ^63 -1

T e xtu al L o g ical

ch ar 16 b its 0 to 6 55 35 o n e b it : tru e o r fa lse


TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE
TYPES DE DONNÉES PRIMITIFS (2/4)

Explication:
 byte : codé sur 8 bits  28 valeurs  (–27) to (27–1) = -128 à 127
 int : codé sur 32 bits  232 valeurs  (–231) to (231–1)

Déclaration et initialisation :
 int int x=12;
 short short x= 32;
 long long x= 200L; // Nombre accolé à un L
 byte byte x=12;
 double double x=23.2323;
 float float x= 23.233F; // Nombre accolé à un F
 char char c=‘a’;
 boolean boolean b=true;
TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE
TYPES DE DONNÉES PRIMITIFS (3/4)

Déclaration, Initialisation et Assignation des types primitifs

int t; Déclaration d’un entier t (t est l’identificateur)


int u = 3; Déclaration et initialisation d’un entier
t=7; Initialisation de t à la valeur 7
u=t; Assignation (affectation) de la valeur de t à u
m=9; Erreur déclaration préalable nécessaire
char c; Déclaration
c=‘a’; Initialisation
TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE
TYPES DE DONNÉES PRIMITIFS (4/4)

Exemple:

Déclaration et initialisation de 2 entiers: a et b


int a = 5;
int b = 8;
Affectation de la valeur de b à a

a=b;

Désormais, il existe deux variables en mémoire qui ont la


même valeur
a=8 b=8
TYPES PRIMITIFS ET TYPES DE RÉFÉRENCE
TYPES DE RÉFÉRENCE

Tous les types hormis les types primitifs


« Pointeur implicite » sur un objet

Référence: Adresse
PORTÉE D'UNE VARIABLE

La portée d'une variable va de la ligne de sa définition jusqu'à la fin du bloc dans


lequel elle est définie.
Exemple
{
int n=10;

{
int p=20;
float n=3.5; //erreur de compilation : définition de n invalide. …
}
System.out.println("p = " + p); //erreur de compilation : p inconnu
}
ARITHMÉTIQUE ET OPÉRATEURS
ARITHMÉTIQUE ÉLÉMENTAIRE

Quelle est la valeur de : 5+3*4+(12/4+1)


Règles de précédences sur les opérateurs:

Niveau Symbole Signification

1 () Parenthèse

* Produit
2 / Division
% Modulo

+ Addition ou concaténation
3
- Soustraction
OPÉRATEURS DE COMPARAISON

Pour comparer deux valeurs:


Opérateur Exemple Renvoie TRUE si
> v1 > v2 v1 plus grand que v2
>= v1 >= v2 Plus grand ou égal
< v1 < v2 Plus petit que
<= v1 <= v2 Plus petit ou égal à
== v1 == v2 égal
!= v1 != v2 différent

Opérateur Usage Renvoie TRUE si


Opérateurs logiques:
&& expr1 && expr2 expr1 et expr2 sont vraies
& expr1 & expr2 Idem mais évalue toujours les 2 expressions
|| expr1 || expr2 Expr1 ou expr2, ou les deux sont vraies
| expr1 | expr2 idem mais évalue toujours les 2 expressions
! ! expr1 expr1 est fausse
!= expr1 != expr2 si expr1 est différent de expr2
ARITHMÉTIQUE ET OPÉRATEURS
OPÉRATEURS D’ASSIGNATION (D’AFFECTATION)

L’opérateur de base est ‘=‘


Il existe des opérateurs d’assignation qui réalisent à la fois
 une opération arithmétique, logique, ou bit à bit
 et l’assignation proprement dite

Opérateur Exemple Équivalent à

+= expr1 += expr2 expr1 = expr1 + expr2

-= expr1 -= expr2 expr1 = expr1 – expr2

*= expr1 *= expr2 expr1 = expr1 * expr2

/= expr1 /= expr2 expr1 = expr1 / expr2

%= expr1 %= expr2 expr1 = expr1 % expr2


STRUCTURES DE CONTRÔLE

• Les structures de contrô le classiques existent en Java :

 if, else

 switch, case, default, break

 for

 while

 do, while
STRUCTURES DE CONTRÔLE

Structure if
if (expression logique) instruction;

if (expression logique)
{ instruction; instruction;
...
}
Structure if else
if (expression logique) instruction;
else instruction;

if (expression logique)
{ instruction; instruction;
...
}
else
{ instruction; instruction;
...
}
STRUCTURES DE CONTRÔLE

Boucle for

for (initialisation; condition ; incrémentation ou décrémentation)


{
instruction_1;

instruction_2;
...
instruction_n;
}

Boucle while

while (expression
booléenne)
{
instruction_1;

instruction_2;
...
instruction_n;
STRUCTURES DE CONTRÔLE

Boucle do while
do
{
instruction_1;
instruction_2;
...
instruction_n;
} while (condition);

Exemple: calcul de la somme des dix premiers entiers positifs.

public class Counter {


public static void main (String args[]){ int
somme=0, indice=1;
do{
somme += indice;
Indice++;
} while (indice<=10) ;
String str= "La somme des dix premiers entiers positifs est : ";
System.out.println(str + somme);
}}
STRUCTURES DE CONTRÔLE

L’instruction switch : sélectionne un morceau de code parmi d'autres


en se basant sur la valeur d'une expression entière

switch (variable){
case valeur1 : instructions1 ;
case valeur2 : instructions2 ;

default : instructions ;
}

Exemples:
int choix=2;
switch(choix){
case 1: System.out.println("Bonjour");
break;
case 2: System.out.println("Hello");
break;
case 3: System.out.println("Buenos
dias"); break;
default: System.out.println("Choix
incorrect"); break;
}
STRUCTURES DE CONTRÔLE

L’instruction break : Permet de terminer l’exécution d’une boucle.

Exemple :// Impression des nombres premiers entre 2 et 100.


int n = 100;
boolean premier;
for (int i = 2; i <= n; i++)
{
premier = true;
for (int j = 2; j < i; j++)
{
if (i % j == 0)
{
premier
=

f
a
l
s
e
;
STRUCTURES DE CONTRÔLE

L’instruction continue : permet l’interruption d’une itération en


cours et retourne au début de la boucle avec exécution de la partie
incrémentation.

Exemple : la somme des entiers impairs.

int somme = 0;
for (int i = 0; i < 100; i++)
{
if (i % 2 == 0) continue;
somme += i;
}
STRUCTURES DE CONTRÔLE

Quels résultats fournit le programme suivant ?


public class Test {
public static void main(String[] args) {
int n=0 ;
do {
if (n%2==0) {
System.out.println (n + " est pair") ;
n += 3 ;
continue ;
}
if (n%3==0) {
System.out.println (n + " est multiple de 3") ;
n += 5 ;
}
if (n%5==0) {
System.out.println (n + " est multiple de 5") ;
break ;
}
n += 1 ;
} while (true) ;
}
}
LECTURE D’INFORMATIONS AU CLAVIER

 Pour la saisie de données au clavier, on va utiliser la classe Scanner


(java.util.Scanner) qui regroupe plusieurs méthodes pratiques :
 nextInt(),
 nextDouble(),
 nextFloat(),
 nextLong(),
 nextLine(),
 …
Exemple:
public class AfficheEntier{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);//System.in: Entrée Standard
System.out.println("Entrer un entier:");
int a=sc.nextInt();
System.out.println(" le nombre entré est :" + a);
}}
STRUCTURES DE CONTRÔLE

En résumé

• L’affichage des données se fait par System.out.println ().

• La lecture des entrées clavier se fait via l'objet Scanner.

•Ce dernier se trouve dans le package java.util que vous devez


importer.

•Pour pouvoir récupérer ce que vous allez taper dans la console, vous
devrez initialiser l'objet Scanner avec l'entrée standard, System.in.

•Il y a une méthode de récupération de données pour chaque type :


nextLine() pour les String, nextInt() pour les int ...
EXERCICES

Quels résultats fournit ce programme ?


public class Test{
public static void main (String args[])
{
int i=10, j=5 ;

if (i<5 && j++<10) System.out.println ("&&1 vrai") ;


else System.out.println ("&&1 faux") ;
System.out.println ("i = " + i + " j = " + j) ;

if (i<5 & j++<10) System.out.println ("& vrai") ;


else System.out.println ("& faux") ;
System.out.println ("i = " + i + " j = " + j) ;

if (i<15 && j++<10) System.out.println ("&&2 vrai") ;


else System.out.println ("&&2 faux") ;
System.out.println ("i = " + i + " j = " + j) ;

if (i<15 || j++<10) System.out.println ("|| vrai") ;


else System.out.println ("|| faux") ;
System.out.println ("i = " + i + " j = " + j) ;
}
}
EXERCICES

Soit le programme suivant: import java.util.Scanner;


import java.util.Scanner; public class Test{
public class Test{ public static void main (String args[])
public static void main (String args[]) {
{
int i, n, som ; int i, n, som ;
som = 0 ;
som = 0 ;
Scanner sc=new Scanner(System.in);
Scanner sc=new Scanner(System.in); i=0;
for (i=0 ; i<4 ; i++) while (i<4)
{ {
System.out.println ("donnez un entier ") ; System.out.println ("donnez un entier ") ;
n = sc.nextInt() ; n = sc.nextInt() ;
som += n ; som += n ;
} i++;
System.out.println ("Somme : " + som) ; }
System.out.println ("Somme : " + som) ;
}
}
} }
Écrire un programme réalisant la même chose en
employant à la place de l’instruction for une instruction
while
JAVA/TABLEAUX

Un tableau est un ensemble indexé de données d'un même type. L'utilisation


d'un tableau se décompose en trois parties :

 Création du tableau 

 Remplissage du tableau 

 Lecture du tableau.
JAVA/TABLEAUX

Création d'un tableau

Un tableau se déclare et s'instancie comme une classe :


int monTableau[ ] = new int[10];
ou
int [ ] monTableau = new int[10];

L'opérateur [ ] permet d'indiquer qu'on est en train de déclarer un tableau.

Si [ ] suit le type, toutes les variables déclarées seront des tableaux, alors que si [ ] suit le nom de
la variable, seule celle-ci est un tableau :

int [] premierTableau, deuxiemeTableau;


float troisiemeTableau[], variable;

Dans ces quatre déclarations, seule variable n'est pas un tableau.


JAVA/TABLEAUX

Remplissage d'un tableau

Une fois le tableau déclaré et instancié, nous pouvons le remplir :


int [] monTableau = new int[10];
monTableau[5] = 23;

L'indexation démarre à partir de 0, ce qui veut dire que, pour un tableau de N éléments, la
numérotation va de 0 à N-1.
Dans l'exemple ci-dessus, la 6ème case contient donc la valeur 23.

Nous pouvons également créer un tableau en énumérant son contenu :

int [] monTableau = {5,8,6,0,7};

Ce tableau contient 5 éléments.


Lorsque la variable est déjà déclarée, nous pouvons lui assigner d'autres valeurs en utilisant
l'opérateur 
new :

monTableau = new int[]{11,13,17,19,23,29};


JAVA/TABLEAUX

Lecture d'un tableau


Pour lire ou écrire les valeurs d'un tableau, il faut ajouter l'indice entre crochets ([ et ]) à la suite du
nom du tableau :

int [] monTableau = {2,3,5,7,11,23,17};

int nb;

monTableau[5] = 23; // -> 2 3 5 7 11 23 17

nb = monTableau[4]; // 11

L'indice 0 désigne le premier élément du tableau.

L'attribut length d'un tableau donne sa longueur (le nombre d'éléments).

Donc pour un tableau nommé monTableau l'indice du dernier élément est monTableau.length-1.

Ceci est particulièrement utile lorsque nous voulons parcourir les éléments d'un tableau.
for (int i = 0; i < monTableau.length; i++) {

int element = monTableau[i]; // traitement


}
INTRODUCTION À LA
PROGRAMMATION
ORIENTÉE OBJET

42
DE LA PROGRAMMATION CLASSIQUE VERS LA
PROGRAMMATION ORIENTÉE OBJET

La programmation classique telle que étudiée au travers des langages C,


Pascal… définie un programme comme étant:
 un ensemble de données sur lesquelles agissent des procédures et des
fonctions.
Les données constituent la partie passive du programme. Les procédures et
les fonctions constituent la partie active;

 Programmer dans ce cas revenait à:


définir un certain nombre de variables (structures, tableaux…)
écrire des procédures pour les manipuler sans associer explicitement les
unes aux autres.

43
DE LA PROGRAMMATION CLASSIQUE VERS LA
PROGRAMMATION ORIENTÉE OBJET

Exécuter un programme se réduit alors à appeler ces procédures dans


un ordre décrit par le séquençage des instructions et en leur fournissant
les données nécessaires à l’accomplissement de leurs tâches.

44
DE LA PROGRAMMATION CLASSIQUE VERS LA
PROGRAMMATION ORIENTÉE OBJET

 Un programme est constitué d’un ensemble d’objets chacun disposant


d’une partie procédures et d’une partie données. Les objets interagissent par
envoie de messages.
Un objet peut recevoir un msg qui déclenche:
Une fonction qui modifie son état.
Une fonction qui envoie un msg à un autre objet.

45
CLASSES ET OBJETS

Classe : Une classe c’est la description d’un ensemble d’objets ayant


une structure de données commune et disposant des mêmes méthodes.
c'est un ensemble de données et de fonctions regroupées dans une
même entité

Exemple

46
CLASSES ET OBJETS

Objet : Un objet est une structure informatique caractérisée par un


état et un ensemble d'opérations exécutables par cet objet qui
caractérise son comportement.

Objet = état + comportement (opérations)

Exemple

47
CLASSES ET OBJETS

Classe Instances

-Nom : hariri
-Prenom :nabil
-Age :25
Instanciation
-Nom :ibrahimi
-Prenom :nawal
-Age :22

48
CLASSES ET OBJETS(SYNTAXE DE DÉCLARATION D’UNE
CLASSE)

La syntaxe de déclaration d'une classe est la suivante :


modificateurs class nom_de_classe [extends classe_mere] [implements interfaces] { ... }
Les modificateurs de classe (ClassModifiers) sont :
Modificateur Rôle
la classe contient une ou des méthodes abstraites, qui
n'ont pas de définition explicite. Une classe déclarée
abstract abstract ne peut pas être instanciée : il faut définir une
classe qui hérite de cette classe et qui implémente les
méthodes nécessaires pour ne plus être abstraite.

la classe ne peut pas être modifiée, sa redéfinition


final grâce à l'héritage est interdite. Les classes déclarées
final ne peuvent donc pas avoir de classes filles.
public La classe est accessible partout

49
CLASSES ET OBJETS

Syntaxe de déclaration d’une classe est :

public class Nom_de_la_classe


{
type p1; //
propriété p1 type p2; Attributs
// propriété p2

type m1(…){ // méthode
m1
… Méthodes
type m2(…){ //} méthode m2

}

}
50
CRÉATION D'UN OBJET : INSTANCIER UNE
CLASSE

Il est nécessaire de définir la déclaration d'une variable ayant le type de


l'objet désiré. La déclaration est de la forme:
nom_de_classe nom_de_variable
Exemple
MaClasse m;
String chaine;

L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable


m = new MaClasse();
Il est possible de tout réunir en une seule déclaration:

MaClasse m = new MaClasse();

51
CRÉATION D'UN OBJET : INSTANCIER UNE
CLASSE
 En Java, tous les objets sont instanciés par allocation dynamique. Dans
l'exemple, la variable m contient une référence sur l'objet instancié (contient
l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de
manipuler ou d'effectuer des opérations directement sur cette adresse comme
en C.
 Si m2 désigne un objet de type MaClasse, l'instruction m2 = m ne définit pas un
nouvel objet mais m et m2 désignent tous les deux le même objet.
 L'opérateur new est un opérateur de haute priorité qui permet d'instancier des
objets et d'appeler une méthode particulière de cet objet : le constructeur. Il fait
appel à la machine virtuelle pour obtenir l'espace mémoire nécessaire à la
représentation de l'objet puis appelle le constructeur pour initialiser l'objet dans
l'emplacement obtenu. Il renvoie une valeur qui référence l'objet instancié.
 Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire, il lève
l'exception OutOfMemoryError.

52
CRÉATION D'UN OBJET : INSTANCIER UNE
CLASSE
Remarque sur les objets de type String : un objet String est automatiquement
créé lors de l'utilisation d'une constante chaîne de caractères sauf si celle-ci
est déjà utilisée dans la classe. Ceci permet une simplification lors de la
compilation de la classe.

53
CRÉATION D'UN OBJET :
INSTANCIER UNE CLASSE
Pour obtenir une seconde instance de la chaine, il faut explicitement demander sa création en
utilisant l'opérateur new.

les tests réalisés dans ces deux exemples sont réalisés sur les références des
instances. Pour tester l'égalité de la valeur des chaînes, il faut utiliser la méthode
equals() de la classe String.
54
DURÉE DE VIE D'UN OBJET
Les objets ne sont pas des éléments statiques et leur durée de vie ne
correspond pas forcément à la durée d'exécution du programme.
La durée de vie d'un objet passe par trois étapes :
 La déclaration de l'objet et l'instanciation grâce à l'opérateur new.
 L'utilisation de l'objet en appelant ses méthodes
 La suppression de l'objet : elle est automatique en Java grâce à la machine
virtuelle. La restitution de la mémoire inutilisée est prise en charge par le
récupérateur de mémoire (garbage collector). Il n'existe pas d'instruction
delete comme en C++.

55
RÉFÉRENCES ET LA COMPARAISON D'OBJETS
Les variables de type objet que l'on déclare ne contiennent pas un objet mais une
référence vers cet objet. Lorsque l'on écrit c1 = c2 (c1 et c2 sont des objets), on copie
la référence de l'objet c2 dans c1.
c1 et c2 font référence au même objet : ils pointent sur le même objet.
L'opérateur == compare ces références.
Deux objets avec des propriétés identiques sont deux objets distincts :

Exemple :

Rectangle r1 = new Rectangle(100,50);


Rectangle r2 = new Rectangle(100,50);
if (r1 == r1) { ... } // vrai
if (r1 == r2) { ... } // faux

Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'une
méthode à cet effet : la méthode equals() héritée de Object.
Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass()
de la classe Object dont toutes les classes héritent:

(obj1.getClass().equals(obj2.getClass())
56
LES VARIABLES DE CLASSES
Elles ne sont définies qu'une seule fois quel que soit le nombre d'objets
instanciés de la classe. Leur déclaration est accompagnée du mot clé static.

Exemple :
public class MaClasse() {
static int compteur = 0;
}
L'appartenance des variables de classe à une classe entière et non à un
objet spécifique permet de remplacer le nom de la variable par le nom de
la classe.
MaClasse m = new MaClasse(); Ce type de variable est utile
int c1 = m.compteur; pour, par exemple, compter
le nombre d'instanciations
int c2 = MaClasse.compteur; de la classe.
// c1 et c2 possèdent la même valeur. 57
LA VARIABLE THIS
Cette variable sert à référencer dans une méthode l'instance de l'objet en
cours d'utilisation. this est un objet qui est égal à l'instance de l'objet dans
lequel il est utilisé.
class MaClasse() {
String chaine = " test " ;
public String getChaine() { return chaine; }
// est équivalent à public String getChaine() { return
this.chaine; }
}
Il est préférable de préfixer la variable d'instance par le mot clé this.
this.nombre = nombre;
Cette référence est habituellement implicite :
private int nombre;
public maclasse(int nombre) {
nombre = nombre;
} 58
OPÉRATEUR INSTANCEOF
L'opérateur instanceof permet de déterminer la classe de l'objet qui lui
est passé en paramètre. La syntaxe est objet instanceof classe

void testClasse(Object o) {
if (o instanceof MaClasse )
System.out.println(" o est une instance de la classe MaClasse ");
else System.out.println(" o n'est pas un objet de la classe MaClasse ");
}

59
OPÉRATEUR INSTANCEOF
même si o est une instance de MaClasse, il n'est pas permis d'appeler une
méthode de MaClasse car o est de type Objet.
void afficheChaine(Object o) {
if (o instanceof MaClasse)
System.out.println(o.getChaine());
// erreur à la compil car la méthode getChaine()
//n'est pas définie dans la classe Object
}
Pour résoudre le problème, il faut utiliser la technique du casting (conversion).
void afficheChaine(Object o) {
if (o instanceof MaClasse) {
MaClasse m = (MaClasse) o;
System.out.println(m.getChaine());
}
} 60
ENCAPSULATION

• L’encapsulation consiste à réduire la visibilité des attributs et des


méthodes d'une classe, afin de n'exposer que les fonctionnalités
réellement nécessaires pour les classes utilisatrices.

61
LES MOTS CLÉS QUI GÈRENT LA VISIBILITÉ DES ENTITÉS

Quand vous définissez des membres dans une classe, vous avez le
choix parmi quatre niveaux de visibilité. Trois de ces niveaux (public,
protected et private) sont associés à des mots clés. Le quatrième
niveau s'obtient en ne spécifiant aucune mot clé relatif à la visibilité.

62
LA VISIBILITÉ PUBLIQUE - PUBLIC

Si vous définissez un membre (attribut, méthode...) public il sera alors


accessible de n'importe ou dans le programme. La classe aura donc accès à
ce membre, mais aussi n'importe quelle autre classe.

public class Demo {


public int attribute = 10;
public void doSomething() {
System.out.println( "Do something" );
}
}

63
LA VISIBILITÉ PROTÉGÉE - PROTECTED

Un membre marqué dans une classe comme étant protégé (mot clé
protected) peut être manipulé :

1. Dans la classe qui définit ce membre,


2. Dans les classes qui dérivent de la classe considérée,
3. Et dans toutes les classes (et les types) définies dans le même
package que celle qui définit le membre protégé.

64
LA VISIBILITÉ « PACKAGE PRIVATE »
En l'absence de mot clé pour spécifier la visibilité, un membre sera considéré comme
étant « package private » (on peut simplifier en parlant de visibilité package). C'est
donc le mode de visibilité par défaut (absence de mot clé). Cela veut dire que le
membre sera accessible par tout code Java localisé dans le même package. Voici un
exemple d'utilisation.

package cours.exemple;
public class TestVisibilite {
public int attr1 = 10;
protected int attr2 = 20;
int attr3 = 30; // Visibilité package private !
private int attr4 = 40;
}

Si une autre classe du même package essaye d'utiliser la classe TestVisibility,


elle aura accès aux membres de type « package private » (mais aussi aux
membres protégés et publics). 65
LA VISIBILITÉ PRIVÉE - PRIVATE

Dans ce cas, seule la classe ayant définit le membre pourra y accéder.


package cours.exemple;
public class Demo {
private static int privateAttribute = 10;
public static void main( String [] args ) {
System.out.println( "J'ai accès à l'attribut static privé : "
+ privateAttribute );
}
}

66
EXEMPLE CLASSES ET OBJETS (1)

public class Point{


private int x ; // abscisse
Attributs
private int y ; //
ordonnee
public void initialise (int abs, int ord)
{ x = abs ;
y=
} ord ;
public void deplace (int dx, int dy)
{ x += dx ;
y += Méthodes
dy ;
}
public
void
affiche ()
}{ System. 67
EXEMPLE CLASSES ET
OBJETS (2)
Méthodes ou fonctions membres: la définition d’une méthode
se compose d’un en-tête et d’un bloc.

public void initialise (int abs, int ord) En-tête


{ x = abs ;
y= Bloc
} ord ;

Remarque : L’ordre des méthodes dans une classe n’a pas


d’importance. Par exemple dans la classe Point on peut déclarer la
méthode affiche() puis la méthode deplace(), affiche() peut être
appelée sans problème dans deplace().
EXEMPLE CLASSES ET
OBJETS (3)
Utilisation d'une classe : Pour pouvoir utiliser une classe il faut
d’abord déclarer un objet, la déclaration est réalisée de la manière
suivante :

NomDeClasse NomDeVariable ;

Point a ;

//cette déclaration ne réserve pas d’emplacement pour un objet de type Point,


//mais seulement un emplacement pour une référence à un objet de type Point.
Exemple Classes et Objets (4)
Pour créer une instance d’une classe, il faut utiliser l’opérateur new qui
se charge de créer une instance (ou objet) de la classe et de l’associer à
la variable. L’instanciation est réalisée par la façon suivante :

NomDeVariable = new NomDeClasse() ;

crée un emplacement pour un objet de type Point et


a = new Point() ;
fournit sa référence en a.
Il est possible de réunir les deux instructions en une seule :

NomDeClasse NomDeVariable = new NomDeClasse() ;

Crée une référence et un emplacement pour un


Point a = new Point() ;
objet de type Point et fournit sa référence en
La situation peut être a.
a ? x
schématisée ainsi : ?
y
EXEMPLE CLASSES ET
OBJETS (5)
On peut appliquer la méthode initialise (…) à l’objet référencié par a.
/*appelle la méthode initialise (…) de la classe Point en l’appliquant à l’objet de référence a, et en
lui transmettant les arguments 3 et 5*/
a.initialise(3, 5) ;

La situation peut a 3 x
5
être schématisée y

ainsi :

Pour employer notre classe Point, nous pouvons définir une


une méthode
méthode mainmain ouméthode
ou une une méthode
d’uned’une
autreautre classe.
classe.
EXEMPLE CLASSES ET
OBJETS (6)
Constructeur de classe : Un constructeur est une méthode particulière
dans une classe. Il porte le même nom que la classe, et permet d’allouer
la mémoire nécessaire à l'objet et d'initialiser ses attributs.
Exemple:
public class Point{
private int x ; //
abscisse private int y ; //
ordonneé public Point (int
abs, int ord)
{ x = abs ;
y=
ord ;
}
public
void
deplace
(int dx,
int dy)
{ x +=
dx ; y
EXEMPLE CLASSES ET
OBJETS (7)
Quelques règles concernant les constructeurs

 Un constructeur ne renvoie aucune valeur. Dans son en-tête,


aucun type ne doit figurer devant son nom. Même la présence
(logique) de void est une erreur.

 Une classe peut ne disposer d’aucun constructeur (c’était le cas de


notre première classe Point). On peut alors instancier des objets
comme s’il existait un constructeur par défaut sans arguments.

 Une classe peut avoir plusieurs constructeurs, qui seront


différenciés par leurs paramètres.

 Un constructeur est toujours appelé à l’aide de l’opérateur new.


EXEMPLE CLASSES ET
OBJETS (8)
Créations inutiles
• La création d'objets est coû teuse. Il faut éviter d'en créer
inutilement :
Objet2 o2 = new Objet2(); L'un des objets ne sera pas
• Objet1 o1 = new Objet1(); utilisé
if(demande == 1)
o1.initialiser();
else
o2.initialiser();

if(demande == 1){
Objet1 o1 = new Objet1();
o1.initialiser();
}
else{
Objet2 o2 = new Objet2();
o2.initialiser();
}
EXEMPLE CLASSES ET
OBJETS (9)
Réutilisation d'objets
• Il faut éviter la création d'objets à l'intérieur d'une boucle.
– Cette création peut être coû teuse en terme de consommation de
la mémoire.
– Préférer la réutilisation d'objet, qui sera instancié avant la boucle,
et modifié à l'intérieur.

for(int i=0 ; i<employes.length ; i++){


Employe emp = new Employe(); //Création d'un objet à chaque passage
emp = (Employe) employes[i];
}

Employe emp = new Employe();


for(int i=0 ; i<employes.length ; i++){
emp = (Employe)
employes[i]; //Réutilisation d'un
seul objet Employe
}
EXEMPLE CLASSES ET
OBJETS (10)
Affectation et comparaison d’objets

Point a, b ; //déclaration de deux objets de type point

a 3 x
a = new Point(3,5);
5
y
b 2 x
b= new Point(2,0) 0
y

Si maintenant nous exécutons l’instruction d’affectation a=b ;

a 3 x
5
b y
2
0 x

y
HÉRITAGE
Caractéristiques de l’héritage

• L'héritage est une propriété importante de la programmation orientée objet


Java.
• Ce concept permettant d'ajouter des nouvelles fonctionnalités à une classe à
partir de la création d’une sous-classe héritant des propriétés de la classe de
base et à laquelle s’ajoutent des nouvelles propriétés.
• La classe héritée s’appelle sous-classe (classe dérivée) de la classe mère
(super-classe).
• L'héritage permettant à une classe dérivée d'étendre les propriétés de la classe
de base tout en héritant des attributs et des méthodes de cette classe de base.
• L’héritage en Java, ne permet à une classe d’hériter que d'une seule classe de
base, on parle d’héritage simple. En effet, pas d’héritage multiple.
HÉRITAGE
• Toutes les classes Java dérivent automatiquement d'une seule et même classe:
la classe Object.
• Donc, l’héritage permet de définir une nouvelle classe à partir d’une classe
existante, à laquelle on ajoute de nouvelles données et méthodes.
HÉRITAGE

- La classe «Materiel » est la classe mère de «MaterielInfo». - La classe «MaterielInfo» est la classe mère de
«Scanner» et «Imprimante».
- La classe «MaterielInfo» est une sous-classe de «Materiel ».
- «Scanner» et «Imprimante» sont des sous-classes de «MaterielInfo» .
HÉRITAGE

Exemple 3: classe «Vehicule»


La modélisation simple de cette classe est représentée comme suit:
Vehicule
marque
couleur
vitesse
etat
demarrer()
arreter()
accelerer()
freiner()
HÉRITAGE
Définition de la classe Vehicule
public class Vehicule {
private String marque;
private String couleur;
private double vitesse; // Vitesse actuelle
private int etat; // 0:arrêt, 1:marche, ...
public Vehicule(String marque, String couleur) {
this.marque = marque;
this.couleur = couleur;
vitesse = 0.0;
etat = 0;
}
public void demarrer() { etat = 1; }
public void arreter() { if (vitesse == 0) etat = 0; }
public void accelerer() {if (etat == 1) vitesse += 5.0;}
public void freiner() {
if (vitesse >= 5.0) vitesse -= 5.0;
else vitesse = 0.0;}
}
HÉRITAGE
Classes dé rivé es de « Vehicule »
 De nouvelles classes « Voiture » et « Camion » peuvent être crées, en utilisant
l'héritage, à partir de « Vehicule ». Elles la spécialisent en y ajoutant de nouvelles
propriétés.
 Un tel diagramme, dans le langage UML, est appelé "Diagramme de classes". Il
montre les relations entre les classes d'une application.
Vehicule
marque
couleur
vitesse
etat
demarrer()
arreter()
accelerer()
freiner()

Camion Voiture
chargeMax modele
poidsChargement nbPortes
charger()
decharger()
HÉRITAGE
Classes dérivées: Camion et Voiture

 La classe Camion est une classe dérivée de Vehicule. Elle hérite tous ses
méthodes et attributs. Elle étend la classe mère Vehicule en lui ajoutant
deux nouveaux attributs chargeMax et poidsChargement, ainsi que deux
nouvelles méthodes charger() et decharger()).
 La classe Voiture est une classe dérivée de Vehicule et hérite tous les
méthodes et les attributs de Vehicule en lui ajoutant deux nouveaux attributs
modele et nbPortes.
 On peut utiliser, dans les classes dérivées Camion et Voiture, les attributs et
les méthodes héritées (par exemple couleur ou freiner()) comme si ces
membres ont été déclarés dans chacune des sous-classes (sous réserve,
naturellement, que les droits d'accès le permettent).
HÉRITAGE
Implémentation de la classe Voiture
• La déclaration d'une classe dérivée se fait en utilisant le mot clé
«extends» suivi du nom de la classe de base.
• Lorsque le mot «extends» est omis, alors la classe hérite
automatiquement de la classe « Object ».

public class Voiture extends Vehicule {


private private String modele; // Nouveau attribut
private int nbPortes; // Nouveau attribut
public Voiture(String marque, String modele, String couleur, int nbPortes)
{ super(marque, couleur); // Appel au constructeur de la classe mère
this.modele = modele;
this.nbPortes = nbPortes;
}
}
HÉRITAGE
Appel des constructeurs : un constructeur d’une classe dérivée peut appeler un
constructeur de sa classe de base. Il suffit de transmettre les paramètres du
constructeur de la sous-classe au constructeur de la super-classe. Ceci est fait par le
mot-clé super.
HÉRITAGE
Accès d’une classe dérivée aux membres de sa classe de base
 Si un champ d'une classe dérivée porte le même nom qu'un champ d'une classe de base,
alors :
 Le champ dérivé masque le champ de base.
 Un code de la classe dérivée peut lire le champ de la classe de base en utilisant le
mot-clé super.
 Le code de la classe de base n’accède pas au champ de sa classe dérivée
Exemple:
public class A {
protected String nom = "Je suis dans A" ;
public void uneMethode() {
System.out.println(nom) ; // affiche "Je suis dans A"
}}
public class B extends A {
protected String nom = "Je suis dans B" ;
public void uneAutreMethode() {
System.out.println(nom) ; // affiche "Je suis dans B"
System.out.println(super.nom) ; // affiche "Je suis dans A"
}}
HÉRITAGE
Accès d’une classe dérivée aux membres de sa classe de base
 Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa classe de
base.
Exemple : on cherche à doter dans la sous-classe PointCol, de la classe Point, la méthode
afficheCouleur qui permet d’afficher les coordonnées du point et la couleur.
Public class Point{ public class PointCol extends Point{
private int x ; // abscisse private int couleur ;
private int y ; // ordonnée
public PointCol( int x, int y, int couleur){
public Point (int x, int y) // constructeur

//par arguments super(x, y); this.couleur=couleur;} Erreur: x et y


Erreur : x et y
{ public void afficheCouleur() {
sontprivées
sont privées
this. x =x ; this.y = y ; }

System.out.println ("Je suis en " + x + " " + y);


public void deplace (int dx, int dy)
{ x += dx ; y += dy ; } System.out.println (" et ma couleur est : " +
public void affiche () couleur) ;
{ System.out.println ("Je suis un point de
}
coordonnees " + this.x + " " + this.y) ;
} public void colore (int c) { couleur = c; }
} }
HÉRITAGE
Redéfinition des méthodes
On appelle redéfinition d’une méthode, la possibilité de définir le comportement d’une
méthode selon le type d’objet l’invoquant, c.-à - d., de donner une nouvelle implémentation à

 
une méthode héritée sans changer sa signature.
Exemple 1
 

public void affiche ( )

 
{
super. affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
HÉRITAGE
 Si une méthode est redéfinie dans une sous-classe, le type de retour doit être identique à
celui de la méthode correspondante de la classe parente.
 En redéfinissant une méthode, il est possible d'étendre sa zone de visibilité (private à package
à protected à public), mais non de la restreindre.
Exemple:
public class A {
private void fonction(float v) { ……}
}
public class B extends A {
public void fonction(float v){…}//redéfinition avec extension des droits d’accès.
}
POLYMORPHISME
• Le polymorphisme est la capacité, pour un même message de correspondre à
plusieurs formes de traitements selon l'objet auquel ce message est adressé, en
se basant sur la relation d’héritage.
• La gestion du polymorphisme est assurée par la machine virtuelle
dynamiquement à l'exécution.

Il est possible d’affecter à une référence d'une classe n'importe quel objet d'une de
ses classe dérivées.
POLYMORPHISME
• Le polymorphisme est la capacité, pour un même message de correspondre à
plusieurs formes de traitements selon l'objet auquel ce message est adressé, en
se basant sur la relation d’héritage.
• La gestion du polymorphisme est assurée par la machine virtuelle
dynamiquement à l'exécution.

Il est possible d’affecter à une référence d'une classe n'importe quel objet d'une de
ses classe dérivées.
POLYMORPHISME
Exemple 1 : Graphique

Cercle Rectangle
public class Graphique {

private int x, y;
public class Cercle extends Graphique
public Graphique ( int x, int y) {
{
this.x = x ; this.y = y ;
private double r ;
}
public Cercle ( int x, int y, double r){
public void identifie () {
super(x,y) ; this.r = r ;
System.out.println ("Je suis une
}
forme géométrique ") ;
public void identifie () {
}
System.out.println ("Je suis un
public void affiche () {
cercle ") ;
this.identifie() ;
}
System.out.println ("Le centre de l’objet
public double surface (){
se trouve dans :"+ x + " et "+ y) ;
return (2* 3.14*r) ;}
}
}
public double surface () {return (0) ;}
}
POLYMORPHISME
Exemple 1 (suite):

public class Rectangle extends Graphique { public class TestPoly {


private int l, L; public static void main (String [] args) {
public Rectangle (int x, int y, int l, int L) Graphique g = new Graphique (3,7);
{ g.identifie ();
super (x,y) ; this.l= l ; this.L =L ; g= new Cercle (4,8,10) ;
} // compatibilité entre le type de la classe
public double surface () { de base et le type de la classe dé rivé e
return (l*L) ;} g.identifie() ;
public void identifie() g= new Rectangle (7,9,10,3) ;
{ // compatibilité entre le type de la classe

System.out.println("Je suis un rectangle") ; de base et le type de la classe dé rivé e

}} g.identifie() ;}}

Je suis une forme géométrique


Résultat d’exécution : Je suis un cercle
Je suis un rectangle
POLYMORPHISME
Test 2 :

public class TestPoly2 { Résultat d’exécution ???

public static void main (String [] args) { Je suis une forme géométrique
Graphique [] tab = new Graphique [6]; Le centre de l'objet se trouve dans : 3 et 2

tab[0] = new Graphique (3,2); Je suis un cercle


tab[1] = new Cercle (10,7,3) ; Le centre de l'objet se trouve dans : 10 et 7

tab [2] = new Rectangle (4,7,8,6) ; Je suis un rectangle

tab [3] = new Graphique (8,10); Le centre de l'objet se trouve dans : 4 et 7

tab[4] = new Cercle (8,5,3) ; Je suis une forme géométrique

tab[5]= new Rectangle (10,17,3,8) ; Le centre de l'objet se trouve dans : 8 et 10

for (int i=0 ; i <=5 ; i++) { Je suis un cercle

tab[i].affiche();} Le centre de l'objet se trouve dans : 8 et 5

} Je suis un rectangle

} Le centre de l'objet se trouve dans : 10 et 17

Vous aimerez peut-être aussi