Programmation orientée objets (GIMIL 507)
I- Introduction
Pour un ingénieur, l’analyse et la conception de systèmes
complexes est une tache primordiale nécessitant des
méthodes et des langages de haut niveau. L’une des
démarches de conception et d’analyse les plus utilisées
aujourd’hui est la programmation orienté objet POO.
Afin de concevoir votre système avec la démarche POO
vous devez utiliser des outils de conceptions et des
langages de programmation dédiés à ce type de
démarche. L’objectif de ce cours est de vous apprendre à
utiliser la méthode UML (pour la conception) et le
langage JAVA pour la programmation.
II- L’environnement JAVA
Vous pouvez ouvrir votre moteur de recherche préféré
(GOOGLE) et vous allez comprendre rapidement que
JAVA est largement utilisé (everywhere). Mais c’est quoi
JAVA exactement ?
En analogie avec les autres langages de programmation
que vous avez fréquentés (Langage C) vous pouvez dire
que JAVA est lui aussi un langage de programmation
cependant JAVA est une plateforme en plus.
JAVA est un langage de programmation et une
plateforme.
Remarque:
Un compilateur génère un code objet (*.o dans le cas du
langage C sous linux) qui va être exécuté par votre CPU
alors qu’un interpréteur ne génère pas ce code et exécute
votre programme (après vérification) sur votre CPU.
II.1 Le langage de programmation JAVA
Java est un langage de programmation de haut niveau:
- Simple
- Orienté objet
- Distribué
- Interprété
- Robuste
- Sécurisé
- Architecture neurale
- Portable
- Haute performance
Chapitre I : Introduction au langage JAVA
- Multithread
- Dynamique
Le langage JAVA permet de compiler et d’interpréter
votre programme JAVA. La compilation permet de
convertir le programme en un langage intermédiaire
appelé JAVA-bytecodes. L’interprétation permet de
décoder et exécuter chaque instruction du byte-code par
l’ordinateur.
Compilation et Interprétation JAVA
Ce principe de compilation et d’interprétation permet
d’écrire un programme JAVA une seule fois et de
l’exécuter n’ importe où (il suffit d’avoir l’interpréteur
installé –JVM : Java Virtual Machine).
Principe du « write once, run everywher ».
Un programme JAVA passe par cinq étapes avant d’être
exécuter :
 Etape d’Édition : Nous créons le programme sur
l'éditeur, puis on l'enregistre dans le disque avec
l’extension .java.
 Etape de Compilation javac (compilateur java) : Le
compilateur traduit le programme en bytecode et le
stocke dans le disque avec l’extension .class.
 Etape de Chargement : Le chargeur de classe lit et
met les bytecodes à partir du disque vers la RAM.
 Etape de Vérification : Vérifiez les bytecodes pour
confirmer qu’ils sont valides et n’altère pas les
restrictions JAVA.
 Etape d’Exécution : La machine virtuelle Java (JVM)
traduit les bytecodes en langage machine (que
l’ordinateur comprend) et les exécutent.
II.2 La technologie JAVA
La technologie JAVA rassemble tous les outils
nécessaires (environnement) pour réussir votre
programme JAVA. On distingue trois environnements :
©ESSAT-Tlemcen 2017 Page - 1 -
 Programmation orientée objets (GIMIL 507)
- Le JDK (JAVA DEVELOPPEMENT KIT) : c’est
l’environnement permettant de développer et
d’exécuter votre programme JAVA.
- Le JRE (JAVA RUNTIME ENVIRONNEMENT) :
C’est l’environnement permettant d’exécuter votre
programme JAVA.
- LA JVM (JAVA VIRTUAL MACHINE) : C’est
l’environnement permettant d’exécuter votre
JAVA- bytecodes.
JDK=JRE+outils de développement
JRE=JVM+library classes
II.3 La plateforme JAVA
Une plateforme est l’environnement matériel et logiciel
Sur lequel un programme va être exécuté (windows XP,
Linux, Solaris, Macos …etc.). La majorité des
plateformes peuvent être décrit comme une combinaison
de système d’exploitation et de matériel. La plateforme
JAVA diffère des autres types de plateforme du fait
qu’elle combine des logiciels seulement à savoir :
- La machine virtuelle JAVA (JVM)
La JVM est responsable du chargement et d’exécution
du JAVA-bytecodes.
Ou commence le rôle de la JVM
https://www.youtube.com/watch?v=dncpVFP1JeQ
- L’interface de programmation d’application JAVA
(JAVA API) : Un ensemble de composant logiciel qui
fournit plusieurs capacités telles que :
 Essentials : objets, chaine de caractères, nombres,
threads, entrées/sorties, structures de données,
propriétés systèmes, date et temps …etc.
 Applets : Un ensemble de convention utilisé par les
applets JAVA.
Chapitre I : Introduction au langage JAVA
 Networking : URL, TCP, UDP, Sockets, IP
adresses.
 Internationalization : Aide à écrire des
programmes qui peuvent être localisés à travers le
monde. Les programmes seront adaptés
automatiquement à une localisation spécifique et
affichés dans un langage approprié.
 Security : signatures électroniques, gestion des clés
publiques et privés, contrôle d’accès et les
certificats.
 JAVA Database Connectivity (JDBC): fournissent
un accès uniforme aux bases de données
relationnelles.
L’API JAVA et La JVM débarrasse le programme de
son dépendance du matériel.
III- Les types de programmes
Les types de programmes JAVA les plus connus sont les
Applets et les applications. Un applet est un programme
qui adhère à certaines conventions lui permettant d’être
exécuté sur un navigateur JAVA-enabled. Une
application est un programme qui va être directement
exécuté sur une plateforme JAVA.
IV- La programmation orienté objet
Si vous n’avez jamais utilisé un langage de
programmation orienté objet vous êtes obliger de
comprendre les concepts de base de l’approche orienté
objet premièrement. Vous allez devoir comprendre ce
que c’st un objet, une classe, comment les objets et les
classes sont reliés et comment les objets communiquent
entre eux en utilisant des messages.
IV.1 Les objets
Jetez un cout d’œil sur ce qui vous entoure et vous allez
voir que les objets sont n’ importe où : votre chat, votre
bureau, votre télévision, votre bicyclette … etc. Ces
objets réels partagent deux caractéristiques : ils ont tous
un état et un comportement. Par exemple, votre chat
possède un état (nom, couleur, race, nourriture) et un
comportement (miaulement, chasse, étirement). Votre
bicyclette à un état (Engrenage actuel, cadence de pédale
actuelle, deux roues, nombre d'engrenages) et un
comportement (Freinage, accélération, ralentissement,
changement de vitesse).
Par analogie, les objets de votre programme seront
modélisés comme les objets réels du fait qu’ils ont aussi
un état et un comportement. Un objet de votre
programme possède un état maintenu par une ou
plusieurs variables et un comportement implémenté par
©ESSAT-Tlemcen 2017 Page - 2 -
 Programmation orientée objets (GIMIL 507)
des méthodes (une méthode est une fonction ou sous-
programmes associée à un objet).
Un objet est un ensemble de variables et de méthodes
L’objet de votre programme modélisant votre bicyclette
va avoir des variables qui indiquent l’état actuel de votre
bicyclette (sa vitesse est de 10mph, sa cadence de pédale
est de 90 rpm et son engrenage actuel est le 5èmme).
L’objet de votre code (programme) possède aussi des
méthodes pour freiner, changer la cadence de la pédale et
changer l’engrenage.
L’objet réel bicyclette modéliser par un objet code.
Une dernière remarque concernant les objets, c’est qu’ils
peuvent exposés ou cachés leurs variables ou méthodes.
Ceci permet :
- La modularité : le code source d’un objet peut être
écrit ou modifié sans indépendamment des codes
sources des autres objets. En plus votre objet peut
être réutilisé aisément (Vous pouvez donner votre
bicyclette à une autre personne et elle marchera
toujours).
- Protection d’information : Un objet possède des
informations et des méthodes publiques lui
permettant de communiquer avec d’autres objets. Il
peut aussi maintenir d’autres variables et méthodes
comme privés et par conséquent il peut les modifiés
sans altérés les autre objets qui dépond de lui (vous
n’allez pas avoir besoin de comprendre le
mécanisme d’engrenage de votre bicyclette pour
l’utilisée).
IV.2 Les messages
Généralement, un objet seul n’est pas très utile. En
réalité, un objet ne représente qu’une partie d’un
programme ou application contenant plusieurs objets.
Grâce à l’interaction entre ces objets, les programmeurs
atteignent des fonctionnalités d’ordre supérieur et des
comportements plus complexes. Votre bicyclette
suspendue à un crochet dans le garage est juste une bande
Chapitre I : Introduction au langage JAVA
d'alliage, de titane et de caoutchouc. Seule, la bicyclette
ne peut réalisée aucune activité, elle devient utile quand
un autre objet (vous) s’interagit avec elle (la pédale).
Les objets de votre code communiquent entre eux en
envoyant des messages. Quand un objet A veut que
l’objet B performe l’une de ces méthodes (de l’objet B),
l’objet A envoie un message à l’objet B.
Interaction d’objets en utilisant des messages
Parfois, l’objet recevant le message a besoin de plus
d’informations afin de savoir exactement ce qu’il faut
faire. Par exemple, lorsque vous souhaitez changer de
vitesse sur votre bicyclette, vous devez indiquer quelle
vitesse vous voulez. Cette information est transmise avec
le message en tant que paramètres.
D’une manière générale, un message comporte trois
composants :
- L’objet auquel le message sera envoyé (bicyclette).
- Le nom de la méthode à performée (changer la
vitesse).
- Les paramètres nécessaires à la méthode (la vitesse
inferieur par exemple).
Exemple de composants d’un message.
IV.3 Les classes
Dans le monde réel, vous avez souvent beaucoup d'objets
du même genre. Par exemple, votre bicyclette est l'une
des nombreuses bicyclettes du monde. En orientée objet,
on dit que votre objet bicyclette est une instance de la
classe d'objets appelée bicyclette. Les bicyclettes ont un
état (Engrenage actuel, cadence de pédale actuelle, deux
roues, nombre d'engrenages) et un comportement
(Freinage, accélération, ralentissement, changement de
vitesse) en commun.
Lors de la fabrication d’une bicyclette, les fabricants
utilise un seul prototype (blueprint) pour réaliser
plusieurs bicyclettes (il serait inefficace de réaliser un
prototype pour chaque bicyclette).
Une classe est un prototype qui définit les variables et
les méthodes des objets de même genre. On dit qu’un
objet est une instance de la classe.
©ESSAT-Tlemcen 2017 Page - 3 -
 Programmation orientée objets (GIMIL 507)
La classe bicyclette
Après la création de la classe bicyclette, on peut créer
n’importe quel nombre d’objet bicyclette à partir de cette
classe.
Quand vous créer des objets à partir d’une classe, ils vont
posséder les mêmes variables et méthodes sauf que les
valeurs de variables changent.
Deux instances-objets- (ma et ton bicyclette) de la
même classe bicyclette.
Les variables de l’objet sont appelées variables-
instances et les variables de la classe sont appelées
variables-classes. Une variable-classe contient une
information partagée par tous les objets. Par exemple, si
toutes les bicyclettes possèdent le même nombre de
d’engrenage alors il serait logique de définir une valeur
pour la variable-classe nombre d’engrenage et par
conséquent toutes les variables-instances des objets
bicyclette vont avoir cette même valeur.
La variable-classe numberofGear (de la classe Bike)
est utilisé par la variable-instance numberofGear (de
l’objet YourBike)
Les objets offrent l'avantage de la modularité et de la
protection d'informations. Les classes offrent l'avantage
de la réutilisation. Les fabricants de bicyclettes réutilisent
le même plan encore et encore pour construire beaucoup
de bicyclettes. Les programmeurs de logiciels utilisent la
même classe, et donc le même code, encore et encore
pour créer de nombreux objets.
IV.4 L’héritage
On peut définir des classes à partir d’autre classes. Par
exemple, les bicyclettes de montagne, les bicyclettes de
Chapitre I : Introduction au langage JAVA
course et les tandems sont toutes des bicyclettes. On dit
que les bicyclettes de montagne, les bicyclettes de course
et les tandems sont des sous-classes et la classe bicyclette
est la superclasse.
Les sous-classes (moutain bike, racingBike et tandem
Bike) héritent de la superclasse Bicycle.
Chaque sous-classe hérite l’état (les variables) de la
superclasse. Les bicyclettes de montagne, les bicyclettes
de course et les tandems partagent certains états: la
cadence, la vitesse … etc. En outre, chaque sous-classe
hérite des méthodes de la superclasse. Les bicyclettes de
montagne, les bicyclettes de course et les tandems
partagent certains comportements: freinage et
changement de vitesse …etc.
En plus des variables et des méthodes héritées de la
superclasse, les sous-classes peuvent avoir d’autre
variables et méthodes. Les bicyclettes tandem ont deux
sièges et deux guidons; Certains vélos de montagne ont
un ensemble supplémentaire d’engrenage avec un rapport
d'engrenage inférieur.
Les sous-classes peuvent également remplacer
(override) les méthodes héritées et fournir des
implémentations spécifiques pour ces méthodes. Par
exemple, si vous avez une bicyclette de montagne avec
un ensemble supplémentaire d'engrenages, vous
remplacerez la méthode « changer engrenage » pour que
vous puissiez utiliser ces nouveaux engrenages.
L’héritage n’est pas limité à un seul niveau, on peut avoir
tout un arbre d’héritage.
L'héritage offre l’avantage suivant:
- Les sous-classes fournissent des comportements
spécifiques à partir des éléments communs fournis par la
superclasse. Grâce à l'utilisation de l'héritage, les
programmeurs peuvent réutiliser le code dans la
superclasse à plusieurs reprises.
IV.5 L’interface
En littérature, une interface est un dispositif permettant à
des objets non reliés de s’interagir entre eux. La
télécommande est une interface entre une personne et une
télévision, la langue est une interface entre deux
personnes ... etc. Dans la programmation orienté objet,
©ESSAT-Tlemcen 2017 Page - 4 -
 Programmation orientée objets (GIMIL 507)
l’interface est un dispositif permettant à des objets non
relié de communiquer entre eux. Les objets non reliés
sont les objets issus de classes différentes ou d’une
hiérarchie de classe différente.

Deux objets de la même classe ayant deux

comportements différents pour la même méthode
(overloading).

Le comportement Brake de la classe Bike sera

remplacé par le comportement Brake de la sous-classe
Moutains Bike (overriding).

Plusieurs objets (Bicycle, motocycle, helmet) utilisent
la même interface pour avoir un prix de détail (get
and set retail price) et un numéro de suivi (tracking
number).
L’interface n’est pas une classe. Il ne contient pas d’état
(variables). Il contient seulement des constantes et des
méthodes qui vont être implémentées par les objets non
reliés.
IV.6 Le polymorphisme
En biologie, le polymorphisme est le principe qu’un
organisme ou une espèce peut avoir de nombreuses
formes ou étapes différentes. En programmation orienté
objet, le polymorphisme est le principe que des objets
appartenant à la même classe (ou hiérarchie de classe)
aient plusieurs comportements différents (Same classe
Many behaviours).
IV.7 L’abstraction
Supposant que vous voulez inventer une nouvelle
bicyclette comportant des ailes (elle va avoir le
comportement volé en plus des comportements
classiques). Cela veut dire que vous allez déclarer ce
comportement seulement (vous ne pouvez pas
l’implémenter réellement). Dans ce cas on dit que le
comportement voler est un comportement abstrait et on
dit qu’une classe est abstraite si et seulement si elle
contient un comportement abstrait.
On ne peut en aucun cas créer un objet d’une classe
abstraite. On doit premièrement définir une sous-classe à
partir de la classe abstraite et implémenter tous les
comportements abstraits afin qu’on obtient une classe
normale (concrète) puis vous pouvez créer votre objet.

Comme exemple, à partir de la classe bicyclette on peut

avoir deux objet votre bicyclette à double freins et ma
bicyclette à un seul frein. La classe bicyclette contient la
méthode freiner, cependant le frein de votre bicyclette
nécessite d’introduire le paramètre numéro du frein (quel
frein utilisé) alors que ma bicyclette ne nécessite aucun
paramètre  Deux objets (votre et ma bicyclette) issus
de la même classe (bicyclette) mais avec deux
comportement différents (freiner avec paramètres et
freiner sans paramètres).

IV.8 L’encapsulation
Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 5 -
 Programmation orientée objets (GIMIL 507)
L’encapsulation est le principe de protéger l’état d’un En mémoire, un bloc est réservé pour l’objet bike1. Ce
objet par ces comportements (Emballer les variables par boc aura un espace pour les attributs et un autre pour les
les méthodes). Par exemple, si on veut changer la vitesse instructions des méthodes.
actuelle de la bicyclette (Current speed) on est obliger Le code de la méthode
changeCadence
d’invoquer la méthode change gear (on ne peut pas lire bike1.changeCadence
ou modifier la valeur d’une variable de l’objet qu’a speedUp …..
travers l’une de ces méthodes). L’avantage de applyBrakes
l’encapsulation est la protection de l’information. applyBrakes
bike1.cadence
V- Du principe à l’implémentation bike1.speed 4 octets
Après avoir compris le principe de la POO, vous pouvez bike1.gear
maintenant choisir votre langage de programmation
préféré et écrire des programmes orienté objet. - Le programme JAVA aura la structure suivante
(comme exemple) :
Le langage que vous allez utiliser dans ce module de // Importation des packages
POO est le langage JAVA. // import package
// Équivalent à #include
class Bicycle {
- Pour définir une classe la syntaxe suivante est
utilisée (on donne l’exemple de la bicyclette) : int cadence = 0;
class Bicycle { //visibilité int speed = 0;
int gear = 1;
public int cadence = 0;
private int speed = 0; variables (état) void changeCadence(int newValue) {
protected int gear = 1; ou attributs cadence = newValue;
}
void changeCadence(int newValue) {
cadence = newValue; void changeGear(int newValue) {
} gear = newValue;
}
void changeGear(int newValue) {
ou fonctions
Méthodes(Comportement)

gear = newValue; void speedUp(int increment) {

} speed = speed + increment;
}
void speedUp(int increment) {
speed = speed + increment; void applyBrakes(int decrement) {
} speed = speed - decrement;
}
void applyBrakes(int decrement) {
speed = speed - decrement; void printStates() {
} System.out.println("cadence:" +
cadence + " speed:" +
void printStates() {
speed + " gear:" + gear);
System.out.println("cadence:" + }
cadence + " speed:" + }
speed + " gear:" + gear);
} class BicycleDemo { // classe principale
} public static void main(String[] args) {
// private : Visible par la classe uniquement.
// protected : Visible par la classe et les sous-classes. // Create two different
// public : Visible par tous le monde. // Bicycle objects
System.out.println est l’équivalent de printf en Bicycle bike1 = new Bicycle();
langage C. Bicycle bike2 = new Bicycle();

// Invoke methods on
- Pour Créer un objet, la syntaxe suivante est utilisée
// those objects
(on donne l’exemple de la bicyclette) : bike1.changeCadence(50);
Bicycle bike1 = new Bicycle();
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();
Le nom de la classe le nom de l’objet
Donc bike1 est un objet issu (créer, générer …) de la bike2.changeCadence(50);
classe Bicycle grâce au mot clé new. bike2.speedUp(10);
Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 6 -
 Programmation orientée objets (GIMIL 507)
bike2.changeGear(2); }
bike2.changeCadence(40);
bike2.speedUp(10); void changeGear(int newValue) {
bike2.changeGear(3); gear = newValue;
bike2.printStates(); }
}
}//Le nom du programme sera BicycleDemo.java void speedUp(int increment) {
La fonction public static void main(String[] args) speed = speed + increment;
(équivalent à int main(int argc, char *argv[ ] ) en langage }
C)
void applyBrakes(int decrement) {
Le résultat d’exécution :
speed = speed - decrement;
cadence:50 speed:10 gear:2
}
cadence:40 speed:20 gear:3
void printStates() {
- Pour l’héritage : System.out.println("cadence:" +
class MountainBike extends Bicycle { cadence + " speed:" +
// new fields and methods defining speed + " gear:" + gear);
// a mountain bike would go here }
public int length; }
}
MountainBike est une sous-classe et Bicycle est une - Pour créer une classe abstraite :
superclasse. Pour créer un objet de cette classe : abstract class FlyBicycle {
MountainBike bike1 = new MountainBike ();
int cadence = 0;
Dans la mémoire, bike1 aura la représentation : int speed = 0;
int gear = 1;
Le code de la méthode
changeCadence bike1.changeCadence void changeCadence(int newValue) {
speedUp ….. cadence = newValue;
applyBrakes }
applyBrakes
bike1.cadence void changeGear(int newValue) {
gear = newValue;
bike1.speed 4 octets }
bike1.gear
bike1.length void speedUp(int increment) {
speed = speed + increment;
- Si on veut maintenant utiliser un interface : }
interface Bicycle {
void applyBrakes(int decrement) {
void changeCadence(int newValue); speed = speed - decrement;
}
void changeGear(int newValue);
void printStates() {
void speedUp(int increment); System.out.println("cadence:" +
cadence + " speed:" +
void applyBrakes(int decrement); speed + " gear:" + gear);
} }
abstract void Fly() ;
class ACMEBicycle implements Bicycle { }
FlyBicycle bike1 = new FlyBicycle();
int cadence = 0; /* on peut avoir une classe quine contient
int speed = 0; pas de méthodes abstraites mais une méthode
int gear = 1; abstraite ne peut se trouver que dans une
classe abstraite. */
// The compiler will now require that methods
// changeCadence, changeGear, speedUp, and
// applyBrakes
Si par exemple la science à révélé une nouvelle
// all be implemented. Compilation will fail bicyclette qui vole alors :
// if those class Bicycle extends FlyBicycle {
// methods are missing from this class. void Fly() {
// votre code ici
void changeCadence(int newValue) { }
cadence = newValue; }
Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 7 -
 Programmation orientée objets (GIMIL 507)
- Pour le Polymorphisme :
Comme déjà vue, il y a deux types de polymorphisme - Encapsulation :
(overriding and overloading). Cependant, on langage class Bicycle {
Java il existe un troisième type qu’on appelle
polymorphisme de constructeur. private int cadence = 0; // encapsulée
int gear = 1; // non encapsulé
 Overloading :
class Bicycle {
void changeCadence(int newValue) {
// ……………
cadence = newValue;
int speed = 0;
}
void applyBrakes() {
speed = speed - 1;
void printcadences() {
}
System.out.println("cadence:" +
cadence);
void applyBrakes(int decrement) {
}
speed = speed - decrement;
void changeGear(int newValue) {
}
gear = newValue;
}
// ……………
}
} class BicycleDemo { // classe principale
class BicycleDemo { // classe principale
public static void main(String[] args) {
public static void main(String[] args) {
Bicycle bike1 = new Bicycle();
bike1.changeCadence(50);
Bicycle bike1 = new Bicycle();
bike1.changeGear(2);
bike1.applyBrakes();
bike1.gear=3 ;
bike1.applyBrakes(3);
bike1.cadence=10 ; //protégée par private
}
bike1.printcadences() ;
} System.out.println("gear:" + bike1.gear);
Dans le premier appel on charge la première méthode alors System.out.println("cadence:" +
que dans le deuxième, la deuxième méthode sera chargée bike1.cadence); // protégé par private
 Method OverLoading. }
 Overriding }
class Bicycle { - Constructeur :
// …………… Le constructeur est un type spécial de méthode utilisé
void applyBrakes() { pour initialiser un objet. Lorsque vous créer un objet
speed = speed - 1; vous êtes obligé d’appelé le constructeur :
}
void applyBrakes(int decrement) {
Bicycle bike1 = new Bicycle();
speed = speed - decrement;
} constructeur
// …………… Le constructeur porte toujours le nom de la classe et
} ne possède pas de type retourné (ni void ni int …
class MountainBike extends Bicycle {
etc). On distingue deux types de constructeurs : les
// Cette classe hérite de la classe Bicycle
void applyBrakes() { constructeurs par défaut et les constructeurs
speed = speed - 2; paramétrés. Un constructeur par défaut est un
} constructeur définit par le système et qui ne possède
// ……………
} pas de paramètres. Un constructeur paramétré est un
constructeur définit par l’utilisateur et qui possède
class BicycleDemo { // classe principale des arguments.
public static void main(String[] args) {

MountainBike bike1 = new MountainBike ();  Constructeur par défaut

bike1.applyBrakes(); class Bicycle {
bike1.applyBrakes(3);
int cadence = 0;
} int speed = 0;
} int gear = 1;
La méthode applybrakes de la classe Bicycle à été remplacé // ……………
la méthode applybrakes de la classe MountainBike lors du void printStates() {
premier appel  Method Overriding. System.out.println("cadence:" +
Dans le deuxièmme appel  Method OverLoading. cadence + " speed:" +

Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 8 -

 Programmation orientée objets (GIMIL 507)
speed + " gear:" + gear); java va s’en chargé en utilisant un outil de
} destruction automatique.
}
class BicycleDemo { // classe principale - Polymorphisme de constructeur
public static void main(String[] args) { En java, vous pouvez créer un constructeur avec le
nombre de paramètre voulue (sans paramètre, un
Bicycle bike1 = new Bicycle(); paramètre, plusieurs paramètres). Cependant, il y a une
//Constructeur par défaut
bike1.printStates(); question majeur qui se pose : Lorsque vous créer votre
// cadence:0 speed:0 gear:0 objet quel constructeur va être utilisé ? Donc nous
// tous ce qui n’est pas nombre avons un seul nom de constructeur mais avec plusieurs
// sera initialisé par NULL.
définitions  polymorphisme de constructeur.
}
}
class Bicycle {
 Constructeur paramétré int cadence = 0;
class Bicycle { int speed = 0;
int gear = 1;
int cadence = 0; Bicycle (int c, int s, int g){
int speed = 0; cadence= c ;
int gear = 1; speed= s ;
gear= g ;
Bicycle (int c, int s, int g){ }
cadence= c ; Bicycle (){
speed= s ; cadence= 20 ; // on a définit le
gear= g ; speed= 5 ; // constructeur
} gear= 1 ; // par défaut
void printStates() { }
System.out.println("cadence:" + void printStates() {
cadence + " speed:" + System.out.println("cadence:" +
speed + " gear:" + gear); cadence + " speed:" +
} speed + " gear:" + gear);
}
void Bicycle () { }
// vous avez le droit de créer une méthode class BicycleDemo { // classe principale
// portant le même nom que le constructeur. public static void main(String[] args) {
System.out.println( " ceci n’est pas un
constructeur " ) ; Bicycle bike1 = new Bicycle();
} Bicycle bike2 = new Bicycle(50,10,2);
} bike1.printStates();
// cadence:20 speed:5 gear:1
class BicycleDemo { // classe principale Bike2.printStates();
public static void main(String[] args) { // cadence:50 speed:10 gear:2
}
Bicycle bike1 = new Bicycle(); }
Bicycle bike1 = new Bicycle(50,10,2); Il y a un polymorphisme de constructeur  pour bike1 on a utilisé
Constructeur paramétré le constructeur par défaut et pour bike2 le constructeur paramétré
bike1.printStates(); (constructor overloading).
// cadence:50 speed:10 gear:2
Bike1.Bicycle () ;
// ceci n’est pas un constructeur. Une dernière remarque : on peut avoir plusieurs constructeurs
} paramétrés pour la même classe. Par exemple :
}
Remarque : attention, on ne peut pas appeler le class Bicycle {
int cadence = 0;
constructeur par défaut si on définit un constructeur
int speed = 0;
paramétré (le constructeur par défaut doit être définit int gear = 1;
pour avoir droit à son appel). Bicycle (int c, int s, int g){
cadence= c ;
speed= s ;
- Destructeur : gear= g ;
En langage Java, on n’a pas besoin d’utiliser des }
destructeurs pour détruire (supprimer et libérer Bicycle (){
l’espace mémoire réservé pour l’objet) l’objet car cadence= 20 ;
speed= 5 ;
gear= 1 ; }
Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 9 -
 Programmation orientée objets (GIMIL 507)
Bicycle (int c, int s){
cadence= c ;
speed= s ;
}

void printStates() {
System.out.println("cadence:" +
cadence + " speed:" +
speed + " gear:" + gear);
}
}

class BicycleDemo { // classe principale

public static void main(String[] args) {

Bicycle bike1 = new Bicycle();

Bicycle bike2 = new Bicycle(50,10,2);
Bicycle bike3 = new Bicycle(63,12);
bike1.printStates();
// cadence:20 speed:5 gear:1
Bike2.printStates();
// cadence:50 speed:10 gear:2
Bike3.printStates();
// cadence:63 speed:12 gear:0

}
}
Exemples: (oublier le mot clé static pour le momement)
www.youtube.com/watch?v=BTbLO8-Ir6k

Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 10 -

 Programmation orientée objets (GIMIL 507)

Constructor overloading (polymorphisme de

constructeur).
Références :
- Au coeur de Java™ volume 1 Notions fondamentales
(Cay S. Horstmann et Gary Cornell).
- UML en action De l’analyse des besoins à la
conception en Java (Pascal Roques et Franck Vallée).

Chapitre I : Introduction au langage JAVA ©ESSAT-Tlemcen 2017 Page - 11 -