Université Sidi Mohamed Ben Abdellah

Faculté des Sciences Fès

Licence professionnelle

Langage Java

Par: LOQMAN Chakir

Année: 2016-2017
 ORGANISATION DU COURS
Organisation du cours:
• Volume horaire : 12 × 4 heures.

• Responsable : Chakir LOQMAN.

• Support pédagogique : cours magistral + TD + TP

• Méthode d’évaluation : examen final de 2 heures

Objectifs:
• Concevoir, écrire et exécuter des programmes en langage Java

• Savoir lire, manipuler, stocker et afficher des données et résultats

• Présenter les concepts de la programmation objet et leurs implémentations dans

le langage Java

• Produire une interface à l’aide du langage de programmation Java et Java FX ;

Matériel nécessaire:
• Un poste informatique sous Windows.

• Installez eclipse.

C. LOQMAN i FSDM Fès

 Contents

Organisation du cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i
Table des matières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ii
Notations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iv

1 Introduction 1
1.1 Langages informatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Langages de différents niveaux . . . . . . . . . . . . . . . . . . . 1
1.1.2 Etapes de réalisation d’un programme . . . . . . . . . . . . . . 2
1.2 Historique des langages . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 La technologie JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3.1 Environnements de développement . . . . . . . . . . . . . . . . 4
1.3.2 Etapes de développement . . . . . . . . . . . . . . . . . . . . . 5
1.3.3 La machine virtuelle Java JVM . . . . . . . . . . . . . . . . . . 5

2 Eléments du langage Java 7

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Structure d’un programme java . . . . . . . . . . . . . . . . . . 7
2.1.2 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.3 Types de données . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.4 Les enveloppeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.5 Fonctions d’entrées et sorties . . . . . . . . . . . . . . . . . . . . 12
2.2 Les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.1 Notations de la sélection simple . . . . . . . . . . . . . . . . . . 14
2.2.2 Notations de la sélection complète . . . . . . . . . . . . . . . . . 15
2.2.3 Notations de la sélection multiple . . . . . . . . . . . . . . . . . 16
2.3 Boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

C. LOQMAN ii FSDM Fès

CONTENTS

2.3.1 Boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.3.2 Boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.3.3 Boucle do ... while . . . . . . . . . . . . . . . . . . . . . . . . . 21

3 Programmation orientée Objet Java 23

3.1 Classes et objets en Java . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1.2 Les attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.3 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.4 Les constucteurs . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.1.5 Attributs et méthodes statiques . . . . . . . . . . . . . . . . . . 28
3.2 Héritage, Polymorphisme et Interfaces en Java . . . . . . . . . . . . . . 29
3.2.1 L’héritage en Java . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.2 Polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.2.3 Classes et méthodes abstraites . . . . . . . . . . . . . . . . . . . 39
3.2.4 Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.5 Choix entre classe et interface . . . . . . . . . . . . . . . . . . . 44

4 Exercices 46

5 TP1 55

6 TP2 58

7 TP3 62

8 TP4 64

Bibliographie 66

C. LOQMAN iii FSDM Fès

 Notations

Voici une liste de notations et des symboles qui seront utilisées au cours de ce cours:

POO Programmation Orienté Objet

JVM Java Virtual Machine m × n
JDK Java Development Kit

C. LOQMAN iv FSDM Fès

 Chapter 1

Introduction

1.1 Langages informatiques

Définition 1.1.1
Un langage informatique est un outil permettant de donner des ordres (instructions) à
la machine

1.1.1 Langages de différents niveaux

• Chaque processeur possède un langage propre, directement exécutable : le lan-
gage machine. Il est formé de 0 et de 1 et n’est pas portable, mais c’est le seul
que l’ordinateur comprend;

• Le langage d’assemblage est un codage alphanumérique du langage machine. Il

est plus lisible que la langage machine, mais n’est pas portable. On le traduit en
langage machine par un assembleur ;

• Les langages de haut niveau. Souvent normalisés, ils permettent le portage d’une
machine à l’autre. Ils sont traduits en langage machine par un compilateur ou
un interpréteur.

Code source Compilateur ou

Interpréteur Langage machine
en langage évolué

Définition 1.1.2 (Compilation)

La compilation est la traduction du source en langage objet. Elle comprend au moins
quatre phases (trois phases d’analyse - lexicale, syntaxique et sémantique - et une de
production de code objet). Pour générer le langage machine il faut encore une phase
particulière : l’édition de liens. Cette technique est contraignante mais offre une grande
vitesse d’exécution;

C. LOQMAN 1 FSDM Fès

 CHAPTER 1. INTRODUCTION

Définition 1.1.3 (Interprétation)

Dans la technique de l’interprétation chaque ligne du source analysé est traduite au
fur et à mesure en instructions directement exécutées. Aucun programme objet n’est
généré. C’est très souple mais l’interpréteur doit être utilisé à chaque exécution.

1.1.2 Etapes de réalisation d’un programme

Enoncé du problème
Spécification

Cahier des charges

Analyse

Algorithme
Traduction en langage de programmation

Programme source
Compilation

Programme exécutable

Version finale et résultats

Réalisation de programmes passe par la Traduction en langage de programmation

D’où l’intérêt d’un langage de programmation
Remarques 1.1.1
Historiquement, deux façons pour représenter un algorithme:

• L’Organigramme: représentation graphique avec des symboles (carrés, losanges,

etc.)

– offre une vue d’ensemble de l’algorithme

– représentation quasiment abandonnée aujourd’hui

• Le pseudo-code: représentation textuelle avec une série de conventions ressem-

blant à un langage de programmation (sans les problèmes de syntaxe)

C. LOQMAN 2 FSDM Fès

1.2. HISTORIQUE DES LANGAGES

– plus pratique pour écrire un algorithme

– représentation largement utilisée

1.2 Historique des langages

Au départ, les langages étaient de simples codes . Pendant neuf mois entre 1842 et
1843, Ada Lovelace a traduit le mémoire du mathématicien italien Luigi Menabrea sur
la machine analytique, la dernière machine proposée par Charles Babbage.

• Années 50 (approches expérimentales) : FORTRAN, LISP, COBOL...

• Années 60 (langages universels) : ALGOL, PL/1, PASCAL...

• Années 70 (génie logiciel) : C, MODULA-2, ADA...

• Années 80-90 (programmation objet) : C++, Labview, Eiffel, Matlab...

• Années 90-2000 (langages interprétés objet) : Java, Perl, tcl/Tk, Ruby, Python...

Java, de Sun Microsystem, est un langage comportant une large palette de classes
réutilisables. Il possède un ramasse-miettes. Il a eu un développement important dans
l’industrie du logiciel.

• 1990: Sun travaillait sur un projet visant à concevoir des logiciels simples et per-
formants exécutés dans des PDA (Personnal Digital Assistant). Le projet Oak de
SUN Microsystems: Langage pour la communication des appareils électroniques
de poche et domotique

• 1993: Le NCSA lance MOSAIC, le premier navigateur internet (protocole http,

langage html), le web décolle... Oak change d’orientation et s’adapte à la tech-
nologie internet

• 1995: annonce officielle de la naissance de la technologie Java (issue de Oak)

1.3 La technologie JAVA

Lors de la création du langage Java, il avait été décidé que ce langage devait répondre
à 5 objectifs:

1. Simple, orienté objet et familier ;

C. LOQMAN 3 FSDM Fès

 CHAPTER 1. INTRODUCTION

2. Robuste et sûr ;

3. Indépendant de la machine employée pour l’exécution (portable) ;

4. Très performant ;

5. Interprété, multi-tâches et dynamique.

Java est un langage full object, c’est-à-dire, qu’il respecte une approche orientée objet
de la programmation, sans qu’il ne soit possible de programmer autrement. En clair,
contrairement au C++, on ne peut faire que de la programmation orientée objet avec
Java, De plus, un programme écrit en Java sur une plate-forme peut être exécuté sans
aucune modification sur un autre système, à condition bien sûr qu’un environnement
d’exécution (i.e. une machine virtuelle) soit disponible sur ce dernier.
Un programme écrit en Java est exécuté par un interpréteur qui traduit en temps
réel les instructions Java en instructions exécutables par le système hôte. En fait, un
source écrit en langage Java n’est pas exécuté tel quel : Un source Java est transformé
en un fichier qui sera interprété par une machine virtuelle. Il convient de noter que
la portabilité de Java découle du fait qu’il soit interprété. Java est livré en standard
avec une importante API (Application Programming Interface) : threads, sockets,
entrées/sorties...

1.3.1 Environnements de développement

Plusieurs environnements existent pour le développement Java :

• De Sun : JDK, SDK, JRE

• De Microsoft : Visual Java.

• De Borland : Jbuilder.

Java Developer’s Kit (JDK):

• JDK environnement standard (Windows ou Solaris) diffusé gratuitement par Sun

([Link]

• Différentes évolutions du JDK correspondant à différentes évolutions de la plate-

forme Java:

– JDK1.02
– Java 1.1 : JDK 1.1.8

C. LOQMAN 4 FSDM Fès

1.3. LA TECHNOLOGIE JAVA

– Java 2 : décembre 1998 en fait java 1.2 (SDK 1.2.2)

– La version actuelle Java 1.3
– La version 1.4 (Merlin) début 2002

1.3.2 Etapes de développement

Pour faire un programme Java , en utilisant l’outil JDK de Sun par exemple :

1. On doit créer le fichier source (extension .java) , par exemple : [Link]

2. On compile le fichier avec l’utilitaire javac :

• On utilise la commande: javac [Link].

• Si le programme ne contient aucune erreur, un fichier .class est créé.
• Ce fichier contient un certain nombre d’instructions, appelées bytecodes ou
P-codes, qui pourront être exécutées par l’interpréteur Java (implémentation
de la Machine Virtuelle Java)

3. On lance l’exécution du fichier compilé:

• On utilise la commande: java test

c l a s s test { 0 g e t s t a t i c #2 < java / lang / System / out Ljava /

publ i c s t a t i c void main ( String [] args ) Compilation io / P r i n t S t r e a m ; >
{ 3 ldc #3 < B o n j o u r ! >
System . out . p r i n t l n( " B o n j o u r ! " ); 5 i n v o k e v i r t u a l #4 < java / io / P r i n t S t r e a m /
} javac p r i n t l n( Ljava / lang / String ;)V >
} 8 return

Code source: [Link] Byte-code: [Link]

Remarque 1.3.1
Un fichier source contenant une application java doit nécessairement avoir comme nom
le nom d’une classe existant dans le fichier.

1.3.3 La machine virtuelle Java JVM

Définition 1.3.2
La machine virtuelle Java (anglais Java virtual machine abr. JVM) est un appareil
informatique fictif qui exécute des programmes compilés sous forme de bytecode Java.

C. LOQMAN 5 FSDM Fès

 CHAPTER 1. INTRODUCTION

Source ([Link])

Compilation

Byte-code ([Link])

Interprétation via JVM

Code machine

Remarque 1.3.3
On peut donc dire que, porter Java sur une plate-forme, c’est simplement porter la
machine virtuelle Java.

C. LOQMAN 6 FSDM Fès

 Chapter 2

Eléments du langage Java

2.1 Introduction

2.1.1 Structure d’un programme java

Un programme simple se compose de plusieurs parties :

• Importation du package

• En JAVA, on travaille que avec des classes

– Sauf type numériques, booléens, caractères

– Écrire un programme JAVA, c’est définir et implémenter des classes

• Une classe peut contenir une ou plusieurs fonctions dont l’une s’appelle fonction
principale main(String [ ] args)

• Les commentaires.

Exemple 2.1.1

import [Link].* // importation du package io

// affiche deux phrases à l’écran.
//------------------------------------------------
class HelloWorld {
public static void main(String[] args) {
[Link]("Hello world!");
}
}

C. LOQMAN 7 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

2.1.2 Les commentaires

On peut insérer un commentaire de différentes façons dans un programme java :

• Le symbole // précède une ligne de commentaires.

• Les commentaires débutent par /∗ et finissent par ∗/, ils peuvent s’étendre sur
plusieurs lignes.

• La séquence @author < nom > permettent d’insérer le nom de l’auteur du

programme.

• La séquence @version < version > permettent d’insérer la version du pro-

gramme.

Exemple 2.1.2 (Commentaire sur une ligne)

[Link] ("Test"); //affiche Test à l’écran.

Exemple 2.1.3 (Commentaire multiligne)

/* Ceci est un autre commentaire

Il s’étend sur plusieurs lignes sans devoir mettre en début
de chaque ligne le double slash //
*/

2.1.3 Types de données

Définition 2.1.4
Une variable est une entité qui contient une information. Dans les langages de pro-
grammation une variable sert à stocker la valeur d’une donnée:

• Une variable possède un identifiant.

• Une variable possède une valeur (qui peut changer dans le temps).

• Une variable possède un type qui caractérise l’ensemble des valeurs que peut pren-
dre la variable

C. LOQMAN 8 FSDM Fès

2.1. INTRODUCTION

Remarques 2.1.1

• Les variables doivent être déclarées avant d’être utilisées,

• En Java , comme en C, il faut respecter la casse (distinction entre majuscule et

minuscule).

• Java permet de définir une variable à n’importe quel endroit du code.

Le choix des noms de variables est soumis à quelques règles:

• Un nom doit commencer par une lettre alphabétique

– exemple valide: A1
– exemple invalide: 1A

• Il doit être constitué uniquement de lettres, de chiffres et du soulignement −

(Eviter les caractères de ponctuation et les espaces)

– valides: SMI2005, SMI− 2005

– invalides: SMI 2005, SMI-2005, SMI;2005

• Il doit être différent des mots réservés du langage (par exemple: if, do, while,
end,...)

Remarque 2.1.5
Pour la lisibilité du code choisir des noms significatifs qui décrivent les données ma-
nipulées
Exemples: TotalVentes2004, P rix− T T C, P rix− HT

Déclaration variables:

1. Syntaxe en pseudo-code:

variable < nom− variable > : < type− variable >

2. Syntaxe en langage Java :

< type− variable > < nom− variable > ;

C. LOQMAN 9 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

Exemple 2.1.6

Syntaxe en algo Syntaxe en Java

variable X : Entier int X;
variable Y, Z : Réel float Y, Z;

Le type int en Java peut être qualifié par un modificateur.

1. byte (1 octets) : [−128...127]

2. short (2 octets) : [−32768...32767]

3. unsigned short (2 octets) : [0...65535]

4. int (4 octets) : [−2147483648...2147483647]

5. unsigned int (4 octets) : [0...4294967295]

6. long (8 octets) : [−263 ...263 − 1]

Examples 2.1.2

• int a;

• short a;

• long x;

• byte b,y;

Types de base: les réels

• simple précision:

1. Taille: 32 bits = 4 octets

2. Intervalle: [±1.4 × 10−45 ... ± 3.4 × 1038 ]
3. Type(mot réservé): float

• Double précision:

1. Taille: 64 bits= 8 octets

C. LOQMAN 10 FSDM Fès

2.1. INTRODUCTION

2. Intervalle: [±4.9 × 10−324 ... ± 1.8 × 10308 ]

3. Type(mot réservé): double

Examples 2.1.3

• doube a;

• float x,y;

• y = -9.555 e+08;

Le type booléen:

1. Taille: 1 octet = 8 bits

2. Ensemble de définition : B = {true, f alse}

3. Type(mot réservé): boolean

• Exemple : boolean a;

a NON(a)
VRAI FAUX
FAUX VRAI
• NON(a) en langage Java: !a

a b a OU b a ET b
FAUX FAUX FAUX FAUX
FAUX VRAI VRAI FAUX
VRAI FAUX VRAI FAUX
VRAI VRAI VRAI VRAI
• (a OU b) en Java: a || b
• (a ET b) en Java: a && b

Le type caractère:

1. Taille: 2 octet = 16 bits

2. Type(mot réservé): char

• Exemple : char a,b;

• a=’/’ b=’1’

C. LOQMAN 11 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

2.1.4 Les enveloppeurs

Chacun des types primitifs peut être ”enveloppé” dans un objet provenant d’une classe
prévue à cet effet et appelée Wrapper (mot anglais signifiant enveloppeur). Les en-
veloppeurs sont donc des objets représentant un type primitif.

Remarques 2.1.4

• Avantages :

– Les Wrapper peuvent être utilisés comme n’importe quel objet, ils ont donc
leurs propres méthodes.

• Inconvénients:

– L’objet enveloppant utilise plus d’espace mémoire que le type primitif. Par
exemple, un int prends 4 octets en mémoire mais un Integer utilisera 32
octets sur une machine virtuelle en 64 bits (20 octets en 32 bits).
– L’objet enveloppant est immuable, c’est à dire qu’il ne peut pas être mod-
ifié, toute modification de sa valeur nécessite de créer un nouvel objet et de
détruire l’ancien, ce qui augmente le temps de calcul.

Enveloppeur Type primitif

Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean

2.1.5 Fonctions d’entrées et sorties

Écriture formatée en Java:
• [Link]()
• [Link]()

C. LOQMAN 12 FSDM Fès

2.1. INTRODUCTION

Exemple 2.1.5

• [Link]("Entrez la valeur de X : ")

• [Link]("La valeur de X= " +X)

• [Link]("La valeur de X= "+X+ "La valeur de Y= "+Y)

Lire les entrées clavier:

• Importation du package :

//Ceci importe la classe Scanner du package [Link]

import [Link];
//Ceci importe toutes les classes du package [Link]
import [Link].*;

• La création d’objet:

Scanner sc = new Scanner([Link]);

Exemple 2.1.6

import [Link];
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner([Link]);
[Link]("Veuillez saisir un mot :");
String str = [Link]();
[Link]("Vous avez saisi : " + str);
}
}

Lire les entrées clavier:

C. LOQMAN 13 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

Scanner sc = new Scanner([Link]);

[Link]("Veuillez saisir un nombre :");
int str = [Link]();
[Link]("Vous avez saisi le nombre : " + str);
}

Exemple 2.1.7

Scanner sc = new Scanner([Link]);

int i = [Link]();
double d = [Link]();
long l = [Link]();
byte b = [Link]();
//Etc.

2.2 Les structures de contrôle

2.2.1 Notations de la sélection simple
Une condition est testée pour déterminer si l’action ou le groupe d’actions suivant doit
être exécuté.

Si (condition) Alors
bloc− instructions
Fin Si

Notation Java:

if (condition){
bloc_instructions;
}

C. LOQMAN 14 FSDM Fès

2.2. LES STRUCTURES DE CONTRÔLE

Exemple 2.2.1

x : entier;
x ← 0;
Si (x = 0) Alors
x ← 1;
Ecrire(”x=”,x);
Fin Si

Langage Java:

int x;
x=0;
if(x==0){
x=1;
[Link]("x="+x);
}

2.2.2 Notations de la sélection complète

Notation algorithmique:

Si (condition) Alors
bloc− instructions 1
Sinon
bloc− instructions 2
Fin Si

Notation Java:

if (condition){

C. LOQMAN 15 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

bloc_instructions 1;
}
else {
bloc_instructions 2;
}

Exemple 2.2.2

x : entier;
x ← 0;
Si (x = 0) Alors
x ← 1;
Ecrire(x);
Sinon
x ← 2;
Ecrire(x);
Fin Si

Langage Java:

int x;
x=0;
if (x==0){
x=1;
[Link]("x="+x);}
else {
x=2;
[Link]("x="+x);}
}

2.2.3 Notations de la sélection multiple

Définition 2.2.1
La sélection multiple permet de faire plusieurs tests de valeurs sur le contenu d’une

C. LOQMAN 16 FSDM Fès

2.2. LES STRUCTURES DE CONTRÔLE

même variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs

valeurs d’une variable

Sélection multiple : notation algorithmique

Selon que
< Condition 1 > : < Action 1 >;
< Condition 2 > : < Action 2 >;
< ................. > : < ............ >;
< Condition n > : < Action n >;
Fin Selon que

Langage Java:

switch(<nom variable>)
{
case <valeur 1> : <instructions 1> ; break ;
case <valeur 2> : <instructions 2> ; break ;
/* .... */
case <valeur n> : <instructions n> ; break ;
default : /*instructions */
}

Exemple 2.2.3
Nous voulons afficher le nom d’un mois en fonction de son numéro:

import [Link].*;
public class switch1{
public static void main(String [] args){
Scanner sc=new Scanner([Link]);
[Link]("entrez le Mois = ");
int numeroMois=[Link]();
switch(numeroMois){
case 1 : [Link]("janvier"); break;
case 2 : [Link]("fevrier"); break;
case 3 : [Link]("mars"); break;

C. LOQMAN 17 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

case 4 : [Link]("avril"); break;

case 5 : [Link]("mai") ; break;
case 6 : [Link]("juin"); break ;
case 7 : [Link]("juillet"); break;
case 8 : [Link]("aout"); break;
case 9 : [Link]("septembre"); break;
case 10 : [Link]("octobre"); break;
case 11 : [Link]("novembre"); break;
case 12 : [Link]("decembre"); break;
default : [Link]("Je connais pas ce mois ...");
} }
}

2.3 Boucle
Définition 2.3.1
C’est une technique permettant de répéter les mêmes instructions plusieurs fois.

Il y a principalement deux types de boucles

• Les boucles pour répéter une instruction un certain nombre de fois, il s’agit de la
boucle Pour

• Les boucles pour répéter une instruction jusqu’à une condition d’arret, il s’agit
de bouclesTant que

Remarque 2.3.2
Le passage dans une boucle est appelé itération

2.3.1 Boucle for

Définition 2.3.3
Les boucles permettent de répéter une instruction un nombre donné de fois.

Notation algorithmique:

C. LOQMAN 18 FSDM Fès

2.3. BOUCLE

Pour variable de valeur− initiale à valeur− f inale [de pas p] faire

instructions;
Fin Pour

Notation Java:

for(i=valeur_initiale; i<=valeur_finale; i=i+p){

instructions;
}

Exemple 2.3.1
Algorithmique:

Pour i de 0 à 10 faire
Ecrire(i);
Fin Pour

Langage Java:

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

2.3.2 Boucle while

Définition 2.3.4
Les boucles tant que permettent d’effectuer des itérations tant qu’une certaine condi-
tion est verifiée.

Notation algorithmique:

C. LOQMAN 19 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

Tant que (condition) faire

bloc− instructions;
Fait

Notation java:

while(condition){
instructions;
}

Exemple 2.3.2

x : entier;
x ← 1;
Tant que (x ≤ 5) faire
x ← x+1;
ecrire(”x= ”,x);
Fait

Langage Java:

int x;
x=1;
while(x<=5){
x=x+1;
[Link]("x= "+x);
}

C. LOQMAN 20 FSDM Fès

2.3. BOUCLE

2.3.3 Boucle do ... while

Notation algorithmique:

Répéter
bloc− instructions;
jusqu’à ce que (condition)

Notation Java:

do{
bloc_instructions;
}
while(condition);

Exemple 2.3.3

x : entier;
x ← 0;
Répéter
x ← x+1;
Ecrire(”Valeur x=”,x);
jusqu’à ce que (x < 6)

Langage java:

int x;
Scanner sc= new Scanner([Link]);
x=[Link]();
x=0;
do{
x=x+1;

C. LOQMAN 21 FSDM Fès

 CHAPTER 2. ELÉMENTS DU LANGAGE JAVA

[Link]("Valeur x= "+x);
}
while (x<6)

C. LOQMAN 22 FSDM Fès

 Chapter 3

Programmation orientée Objet Java

3.1 Classes et objets en Java

3.1.1 Introduction
Définition 3.1.1
Un objet informatique est un concept qui encapsule des attributs et des méthodes. Les
attributs représentent les caractéristiques de l’objet et les méthodes représentent les
opérations qui s’appliquent sur ces attributs.

• Objet= Attributs + Méthodes

• Un attribut est une propriété de l’objet

• Les méthodes sont les éléments d’un objet qui servent d’interface entre les données
et le programme

Objet

Attributs

Méthodes

Définition 3.1.2 (Notion d’une classe)

Une classe est un modèle de définition pour des objets ayant le même ensemble d’attributs,
et le même ensemble d’opérations. Une classe est un moule qui sert à reproduire des
objets semblables. On dit aussi que l’objet est une instance de la classe.

Remarque 3.1.3
A partir d’une classe on peut créer un ou plusieurs objets par instanciation ; chaque
objet est une instance d’une seule classe.

C. LOQMAN 23 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

La classe regroupe la définition des membres de classe, c’est-à-dire :

• des champs, les variables que l’on peut traiter;

• des méthodes, les opérations que l’on peut effectuer;

• des constructeurs, qui permettent de créer des objets;

La déclaration d’une classe se fait de la façon suivante :

class <nomClasse>{
//attributs
...
// constructeurs
...
//méthodes
...
}

Chaque classe a une visibilité :

• public: le mot class est alors précédé de public, tout utilisateur qui importe le
paquetage peut utiliser la classe.

• privé: le mot class est alors précédé de private, seules des classes définies dans
le même fichier peuvent utiliser cette classe.

• le mot class n’est pas précédé de mot particulier, toutes les classes du paquetage
peuvent utiliser la classe.

Exemple 3.1.1

public class Point {

private int x ; // un attribut
private int y ; // un autre attribut
public Point(int a, int b) // constructeur
public void deplace(int dx, int dy) // une méthode
public void affiche() // encore une méthode
}

Pour créer une instance de la classe Point, on écrira:

C. LOQMAN 24 FSDM Fès

3.1. CLASSES ET OBJETS EN JAVA

Point A, B ; // définition de la variable référence

A = new Point(-1,2) ; // création de l’instance
B = A;

3.1.2 Les attributs

Définition 3.1.4
L’état représente l’ensemble des variables qui caractérisent une classe ; on parle encore
de champs ou des attributs

class personne{
// attributs
private String prenom;
private String nom;
private int age;
}

Un attribut a une visibilité :

• private : seules les méthodes de la classe dans laquelle est définit l’attribut
peuvent y accéder et le modifier

• protected : seules les méthodes de la classe et des éventuelles classes héritées

peuvent accéder à l’attribut et le modifier

• public : tout le monde peut accéder à l’attribut en question.

• sa définition n’est pas précédé de mot particulier, l’attribut peut être utilisé dans
toute classe du même paquetage.

Remarques 3.1.2

1. En dehors de la définition de la classe Point (dans le main()):

Point p = new Point(3,1);

p.x = 0;

serait rejetée à la compilation car x est un attribut privé de la classe Point.

2. Si x était un attribut publique de la classe Point on pourrait le faire.

C. LOQMAN 25 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

3.1.3 Les méthodes

Définition 3.1.5
Les méthodes sont les opérations que l’on peut effectuer sur une classe.

Une déclaration de méthode est de la forme suivante:

<Modificateurs> <Type> <nomMéthode> (liste d’arguments)

{
corps de la méthode
}

Exemple 3.1.3

public int getCarre (int x){

return x*x;
}

Une méthode a une visibilité :

• public: sa définition est précédée de public, et elle peut être utilisée par tout
utilisateur de la classe.

• privé: sa définition est précédée de private, et elle ne peut être utilisée qu’à
l’intérieur de la classe

• protégé: sa définition est précédée de protected, et elle ne peut être utilisée qu’à
l’intérieur de la classe, ou des classes dérivées.

• paquetage: la méthode peut être utilisée dans toute classe du même paquetage.

Remarque 3.1.6

• A l’extérieur de la définition de la classe, l’accès se fait en écrivant le nom de

l’instance, un point le nom de la méthode.

• Exemple:

Point p = new Point(3,1);

[Link]();
[Link](5,2);

C. LOQMAN 26 FSDM Fès

3.1. CLASSES ET OBJETS EN JAVA

3.1.4 Les constucteurs

Définition 3.1.7
Un constructeur d’objet est une méthode particulière d’une classe qui est appelée
lors de la création d’un objet.

Son but est :

• d’allouer un emplacement mémoire pour l’objet,

• d’initialiser les attributs de l’objet avec de bonnes valeurs de départ.

Exemple 3.1.4

class Exemple{
int val ; //attribut
public Exemple(){ //constructeur
val=1 ;
}
}

Remarques 3.1.5

1. Le nom du constructeur a le même nom que la classe.

2. Si aucun constructeur n’est défini, Java fournit un constructeur sans paramètre

appelé constructeur implicite ou par défaut

3. Les constructeurs n’ont pas de type et ne retournent pas.

class Animal{
// champs
boolean vivant ;
int ^
age ;
// constructeurs
Animal() {
}
Animal(int ^
age) {
this.^
age = a
^ge ;

C. LOQMAN 27 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

vivant = true ;
}
// méthodes }

Exemple 3.1.6

public class Point {

private int x ; // attributs
private int y ;
public Point(int a, int b){ // constructeur
x = a;
y = b;}
public void deplace(int dx, int dy){ // méthodes
x += dx;
y += dy;}
public double distance(Point P){
return [Link]([Link](x-P.x,2)+[Link](y-P.y,2));}
public void affiche(){ //
[Link] (" x = " + x );
[Link] (" y = " + y );}
public static void main(String argv[]) {
Point a = new Point(5,2) ;
[Link]() ;
[Link](8, 4) ;
[Link]() ;
Point b = new Point(-1, 1) ;
[Link]() ;
[Link]("Distance = "+[Link](a));}}

3.1.5 Attributs et méthodes statiques

L’orienté objet définit deux types de propriétés dans une classe : les propriétés associées
à une instance de la classe (Objet) et les propriétés associées à une classe. Avec le
qualificatif static avant un attribut ou méthode d’une classe, on peut spécifier que
celui-ci est de classe.

Exemple 3.1.7

C. LOQMAN 28 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

Class Animal {
// champs
int ^
age ;
static int longévité = 100 ;
// méthodes
static int getLongévité() {
return longévité ;
}
}

3.2 Héritage, Polymorphisme et Interfaces en Java

3.2.1 L’héritage en Java
L’héritage est un mécanisme permettant de créer une nouvelle classe à partir d’une
classe existante en lui proférant ses propriétés et ses méthodes.L’héritage permet de
spécialiser une classe qui possédera non seulement les propriétés et méthodes de sa
mère mais également d’autres méthodes spécifiques ou redéfinies.

Remarque 3.2.1
Une classe ne peut hériter de l’implémentation que d’une seule classe (extends). Cela
supprime les problèmes de l’héritage multiple.

Exemple 3.2.1

Véhicule
Généralisation

Avion Voiture Moto

De course Décapotable
Spécialisation

Avantage de l’héritage:

• Réutiliser des classes existantes.

C. LOQMAN 29 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

• Relier des classes entre elles.

• Regrouper les champs et les méthodes communs à plusieurs classes.

• Optimisation du code

Terminologie:

• On dit que la classe Enfant hérite de la classe Parent, qu’elle éxtend cette ancienne
classe.

• Enfant est alors une sous-classe (subclassed) ou classe dérivée de la classe

Parent

• Parent est une super-classe (surclasse) ou classe de base de la classe Enfant.

Syntaxe de l’héritage:

class Dérivée extends Classe_de_base {

// définitions d’attributs
// définitions de méthodes
}

Classe Dérivée:

• Les attributs de la classe dérivée comprennent :

– les attibuts hérités de la classe de base

– les attributs propres à la classe dérivée.

• Les méthodes de la classe dérivée comprennent :

– les méthodes de sa classe de base,

– peut redéfinir (masquer) certaines méthodes,
– peut posséder de nouvelles méthodes.

Exemple 3.2.2

C. LOQMAN 30 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

Document
no
titre
affiche()

Livre Revue
auteur mois
nbPages annee

Roman
prixLitteraire

class Document {
int no ;
String titre ;
public void affiche(){
[Link]("Document");
}
}
class Livre extends Document{
String auteur ;
int nbPages ;
}
class Roman extends Livre {
int prixLitteraire ;
}
class Revue extends Document {
int mois ;
int annee ;
}
}

class Test {
public static void main(String args[]){
Document d = new Document ();
[Link] = 1 ;
Livre l = new Livre ();
[Link] = 2 ;
[Link] = "Hugo";
//[Link]="Balzac";=>ERREUR DE COMPIL!
}

C. LOQMAN 31 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

Constructeur de la classe dérivée:

• La classe dérivée doit prendre en charge la construction de la classe de base

• Pour invoquer le constructeur de la classe de base, on fera appel à l’instruction

super(...)

• Si le constructeur de la classe dérivée n’appelle pas le constructeur de la classe

de base cela est fait automatiquement (appel du constructeur sans paramètre de
la classe de base).

Classe se base:

class Document{
int no ;
String titre ;
public Document( int no,String titre){
[Link]=no;
[Link]=titre;
}
}

Classe dérivée:

class Livre extends Document {

String auteur ;
int nbPages ;
public Livre(int a,String tit, int nb){
super(a,tit);
nbPage=nb;
}
public static void main (String args[]){
Document d = new Document (1,"enfant");
Livre l = new Livre (2,"enfants",50);
}
}

C. LOQMAN 32 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

Redéfinition des méthodes:

Une méthode définie dans une classe peut être redéfinie dans une classe dérivée.

• Sans redéfinition de la méthode affiche

class B {
void affiche(){
[Link](
"méthode m de B");
}
}
class D extends B{
}

• Avec redéfinition de la méthode affiche:

class B {
void affiche(){
[Link](
"méthode m de B");
}
}

class D extends B{
void affiche(){
[Link](
"méthode m de D");
}
}

Remarques 3.2.3

• Ne pas confondre la redéfinition avec la surcharge :

– Redéfinition : même type de retour et mêmes paramètres.

– Surcharge : type de retour et paramètres différents, les paramètres au moins
doivent être différents.

• L’ opération de redéfinition d’une méthode masque inévitablement la méthode

d’origine de la super-classe Parent.

C. LOQMAN 33 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

• Contraintes sur la redéfinition:

– Signature identique
– droits d’accès

Signature identique:

class A {
public void unefonction(int x) { //etc.}
}
class B extends A {
public void unefonction(int z) { //etc.}
}

droits d’accès:

class A {
private void unefonction(int x) { //etc.}
}
class B extends A {
public void unefonction(int z) { //etc.}
}

Modificateur d’accès:

• Package P1

class C1 {
int a;
public int b;
private int c;
protected int d;
}
class C2 extends C1 {
// C2 est une sous-classe de C1
}
class C3 {
// ...
}

• Package P2

C. LOQMAN 34 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

class C4 extends C1 {
// C4 est une sous-classe de C1
// ...
}

class C5 {
// ...
}

a b c d
Accessible par C1 oui oui oui oui
Accessible par C2 oui oui non oui
Accessible par C3 oui oui non oui
Accessible par C4 non oui non oui
Accessible par C5 non oui non non

Classes finales:
Lors de la conception d’une classe, le concepteur peut empêcher que d’autres classes
héritent d’elle (classe finale).

• final public class B

Remarque 3.2.2
On peut empêcher la redéfinition d’une méthode d’instance d’une classe dans une de
ses sous-classes en la déclarant final.

Exemple 3.2.4

public class B{
final public void affiche(){}
}
public class C extends B{
// On ne peut pas redéfinir affiche();
}

C. LOQMAN 35 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

3.2.2 Polymorphisme
Définition 3.2.3 Le polymorphisme peut être vu comme la capacité de choisir dy-
namiquement la méthode qui correspond au type réel de l’objet.

Si l’on considère le diagramme de classes suivant:

Forme
x
y
toString()

Carre Cercle
cote rayon
toString() toString()
surface() surface()

• la classe Cercle ”EST-UN” classe Forme

• toute méthode m de la classe Forme peut-être invoquée sur une instance de la

classe Cercle

Si l’on implémente les classes Forme, Carre et Cercle:

public class Forme {

protected double x,y;
..................//constructeurs
public String toString(){
return (x+" "+y);
}
}
public class Carre extends Forme {
private double cote;
..................//constructeurs
public String toString(){
return ([Link]+" "+cote);
}
public double surface() {
return [Link] * [Link];
}

C. LOQMAN 36 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

}
public class Cercle extends Forme {
private double rayon;
..................//constructeurs
public String toString(){
return([Link]+" "+rayon);;
}
public float surface() {
return [Link]*[Link]*[Link];
}
}

Si l’on écrit le code suivant:

Forme Fr1=new Forme();

//un carré est une forme
Forme Fr2=new Carre();
//un cercle est une forme
Forme Fr3=new Cercle();

Quelle méthode toString() sera invoquée?

Forme
x
y
[Link]() toString()

[Link]()

Carre Cercle
cote rayon
[Link]() surface() surface()
toString() toString()

• Si Fr3 référence un Cercle, quelle méthode toString() va être invoquée ?

– La méthode toString() est définie dans Forme

– Mais elle est spécialisée dans Cercle

C. LOQMAN 37 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

• C’est la version la plus spécialisée ([Link]()) qui est invoquée car la

recherche de la méthode débute dans la classe effective de l’objet référencé par
Fr3.

Liaison dynamique:

• Le compilateur ne dispose par de l’information nécessaire pour associer le code

d’une méthode à un message.

• La recherche est menée à l’exécution et ce mécanisme est appelé la liaison dy-

namique.

• Le mécanisme de liaison-dynamique (dynamic binding, late-binding ou run-time

binding) permet de retrouver le type d’un objet et d’appeler la méthode appro-
priée.

Tableau d’objet et polymorphisme:

Grâce au polymorphisme, on peut faire un programme en n’utilisant que la classe de
base qui va automatiquement appeler les fonctions des classes dérivées.

Exemple 3.2.5

public class TableauForme{

public static void main(String [] args){
Forme [] tab = new Forme[3];
tab[0] = new Frome( );
tab[1] = new Carre( );
tab[2] = new Cercle( );
for(int i=0;i<[Link];i++)
[Link](tab[i].toString());
}
}

Intérêt du polymorphisme:

• En proposant d’utiliser un même nom de méthode pour plusieurs types d’objets

différents;

• Le polymorphisme permet une programmation beaucoup plus générique;

• Evitera des duplications de code;

C. LOQMAN 38 FSDM Fès

 3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

3.2.3 Classes et méthodes abstraites

Définition 3.2.4
Une classe abstraite est une classe dont l’implémentation n’est pas complète et qui
n’est pas instanciable. Elle sert de base à d’autres classes dérivées (héritées).

Syntaxe:

public abstract class Non_Classe{

//attribut
//Une classe abstraite ne peut pas ^
etre instanciée
//mais elle peut avoir un constructeur
// méthodes
}

Remarques 3.2.6

• Les classes abstraites doivent être déclarées public sinon pas d’héritage!

• Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.

• Une classe abstraite peut contenir des méthodes concrètes.

Exemple 3.2.7
Considérons la hiérarchie de classes suivantes :
Figure
double abscisse
double ordonnée
comment définir la méthode: surface()
toString()

Carre Cercle
double cote double rayon
surface() surface()
toString() toString()

Remarque 3.2.5 • La méthode surface() de la classe Figure =⇒ une méthode

abstraite

C. LOQMAN 39 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

• =⇒ la classe Figure est une classe abstraite

Exemple 3.2.8 (classe abstraite)

• Classe Figure:

public abstract class Figure{

private String Nom;
public Figure(String Nom){
[Link] = Nom;
}
//Méthode abstraite
public abstract double surface();
public String toString(){
return ([Link]);
}
}

• Classe Carre:

public class Carre extends Figure{

private double cote;
public Carre(String S ,double C){
super(S);
cote = C;}
public double surface( ){
return [Link]*[Link];}
public String toString(){
return ([Link]()+" "+cote);}
}

• Classe Cercle:

C. LOQMAN 40 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

public class Cercle extends Figure1{

private double rayon;
public Cercle(String S ,double R){
super(S);
rayon = R;}
public double surface(){
return [Link]*[Link]*[Link];}
public String toString(){
return ([Link]()+" "+rayon);}
}

• Classe test:

public class test{

public static void main(String[] args){
Carre car=new Carre("carre",4);
[Link]([Link]());
[Link]([Link]());
Cercle cer=new Cercle("cercle",6);
[Link]([Link]());
[Link]([Link]());
}
}

3.2.4 Les interfaces

Définition 3.2.6

• Une interface est une spécification complètement abstraite : aucune méthode n’est
implémentée.

• Une interface est une classe abstraite dont toutes les méthodes sont abstraites et
dont tous les attributs sont constants

Syntaxe en Java:

C. LOQMAN 41 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

public interface MonInterface{

[public abstract] type methode1([arguments]);
...
}

Exemple 3.2.9

public interface Vehicule {

void rouler();
void freiner();
}

Remarques 3.2.10

• Une interface n’a pas de constructeurs

• Des classes non liées hiérarchiquement peuvent implémenter la même interface.

• Une classe peut implémenter plusieurs interfaces (permettant un héritage multi-

ple).

Implémentation d’une interface:

• On dit qu’une classe implémente une interface si elle définit l’ensemble des
méthodes abstraites de cette interface.

• On utilise alors, dans l’entête de la classe, le mot-clé implements suivi du nom

de l’interface implémetée.

Interface:

interface Electrique {
void allumer();
void eteindre();
}

C. LOQMAN 42 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

Implémentation d’une interface:

class Radio implements Electrique {

// ...
void allumer() {
[Link](" bruit ");
}
void eteindre() {
[Link]("silence");
}
}

Remarque 3.2.7

• Les interfaces sont controllés par les modifieurs : public, abstract

• La classe doit implémenter toutes les méthodes de l’interface, sinon elle doit être
déclarée abstract

Exemple 3.2.11

• Interface:

interface Electrique {
void allumer();
void eteindre();
}

• Implémentation d’une interface

abstract class Radio implements Electrique {

// ...
void allumer() {
[Link](" bruit ");
}
}

C. LOQMAN 43 FSDM Fès

 CHAPTER 3. PROGRAMMATION ORIENTÉE OBJET JAVA

3.2.5 Choix entre classe et interface

Choix dicté par l’existant:

• L’héritage n’est plus possible, la classe hérite déjà d’une autre classe. Il ne reste
plus que celui l’interface.

Exemple 3.2.12
Considérons la hiérarchie de classes suivantes :

Figure
double abscisse Interface
double ordonnée Tracable
surface()
toString() dessinToit()
deplaceToi()

Carre Cercle héritage impossible

double cote double rayon
surface() surface()
toString() toString()

Choix à la conception:

• On étudie la relation entre A et B ?

– Un objet de classe B ”EST UN” A

∗ Héritage : B extends A.

– Un objet de classe B ”EST CAPABLE DE FAIRE” A

∗ Interface : B implements A.

Exemple 3.2.13
Considérons la hiérarchie de classes suivantes :

C. LOQMAN 44 FSDM Fès

3.2. HÉRITAGE, POLYMORPHISME ET INTERFACES EN JAVA

Héritage
Animal
age
^
getAge() Interface
Compagnon
toString()

etreAmical()
Et un jouer()
Chien
taille Et capable de faire
aboyer()
toString()

C. LOQMAN 45 FSDM Fès

 Chapter 4

Exercices

Exercice 4.0.1

• Qu’affiche le programme suivant? Pourquoi?

public class Test {

public static void main(String [] args){
int x=3;
int y=4;
int z=5;
if((x==3)&& !(y==5) && (z>2))
[Link]("la condition1 Vraie!" );
else
[Link]("la condition1 Faux!" );
}
}

• L’exemple suivant est-il correct ? Justifiez et Corrigez.

public class A {
private int a;
public A(int a){
this.a = a;}
}
public class B extends A{
private int b;
public B(int a,int b){
this.a = a;
this.b = b;}
}

C. LOQMAN 46 FSDM Fès

Exercice 4.0.2
On donne ici l’algorithme de résolution d’un système triangulaire supérieur. Il se fait
en remontant les équations de la dernière ligne à la première. Soit donc le système:

Ax = b

Où A = (aij )i,j=1,..,n est une matrice triangulaire supérieure et inversible:

Qn
• ∀i = 1...n (aii 6= 0) puisque Det(A) = i=1 aii 6= 0

L’algorithme de résolution est :

(
xn = abnn
n

xi = a1ii (bi − nj=i+1 aij xj ),

P
i = n − 1, ..., 1

Algorithme: resolutionSys
Variable A : tableau[n][n] de réels;
b : tableau[n] de réels;
i,j : entier;
som : réel;
Début
Pour i de n à 1 faire
som ← b[i];
Pour j de i+1 à n faire
som← som-A[i][j] ∗ b[j];
Fin Pour
som
x[i]← A[i][i] ;
Fin Pour
Fin

L’objectif va être d’écrire trois classes Matrice, Vecteur et SysLineaire qui modélisent
le problème de la résolution d’un système linéaire triangulaire supérieur. Complétez
les classes suivantes:

• La classe Matrice

public class Matrice{

C. LOQMAN 47 FSDM Fès

 CHAPTER 4. EXERCICES

private int N; // nombre de lignes

private int M; // nombre de colonnes
private double[][] A; // Tableau à deux dimensions

//constructeur1
public Matrice( int N, int M){
// A compléter
}
//constructeur2
public Matrice(double [][] A){
// A compléter
}
// renvoie le nombre des linges
public int getNombreLin(){
// A compléter;
}
// renvoie le nombre des colonnes
public int getNombrrCol(){
// A compléter;
}
// Cette méthode calcule et retourne la matrice transposé
public Matrice transpose() {
Matrice B = new Matrice(M, N);
// A compléter;
return B;
}
//renvoie l’element A[i][j]
public double A(int i,int j) {
return A[i][j];
}
// Affichage de la matrice
public void affiche() {
// A compléter;
}
}

• La classe Vecteur

C. LOQMAN 48 FSDM Fès

 public class Vecteur {
private int P; // Taille du vecteur
private double[] Tab; // Tableau à une seule dimension
// creation d’un Vecteur de taille N contient des 0
public Vecteur(int P) {
this.P = P;
Tab = new double[P];
}
// creation d’un Vecteur à partir d’un tableau
public Vecteur(double[] T){
// A compléter;
}
// renvoie la taille d’un Vecteur
public int taille(){
// A compléter;
}
// ajouter un element
public void ajouter(int i, double a){
// A compléter;
}
// renvoie la composante i
public double element(int i) {
// A compléter;
}
//affichage d’un Vecteur
public void afficheVec(){
// A compléter;
}
}

• La classe SysLineaire

public class SysLineaire{

protected Matrice M;
protected Vecteur V;
//Contructeur
public SysLineaire(Matrice M, Vecteur V){
// A compléter;

C. LOQMAN 49 FSDM Fès

 CHAPTER 4. EXERCICES

}
//la méthode de la résolution
public Vecteur resolutionSys(){
int l=[Link]();
Vecteur X=new Vecteur(l);

// A compléter;
// Voir l’algorithme resolutionSys

return X;
}
public static void main(String [] args){
double [][] A={{1,1,1},{0,1,1},{0,0,1}};
Matrice M=new Matrice(A);
[Link]();
double [] b={1,2,3};
Vecteur V=new Vecteur(b);
[Link]();
SysLineaire SysL=new SysLineaire(M,V);
Vecteur X=[Link]();
[Link]("la solution du système linéaire");
[Link]();}
}

Exercice 4.0.3
L’objectif va être d’écrire deux classes Calcule, Test.
1. Créer une classe Calcule caractérisée par: note1, note2 de type double.

Calcule
- note1 :double
- note2 :double
<<constructor>> Calcule(...)
getNote1()
getNote2()
setNote1(double a)
setNote2(double b)
getMoyenne()
getSomme()
getMax()

C. LOQMAN 50 FSDM Fès

Exercice 4.0.4
Calculez la somme des N premiers termes de la série harmonique :
1 1 1
1+ + + ... +
2 3 N
Exercice 4.0.5

1. Créer une classe Etudiant caractérisée par: nom, prenom, Age, Sexe, Adresse,
de type String.
Etudiant
- nom :String
- prenom :String
- age :String
- Sexe :String
- Adresse :String
<<constructor>> Etudiant(...)
getNom()
getPrenom()
getAge()
getSexe()
getAdresse()
toString()

Exercice 4.0.6
Définissez deux classes Vecteur et IncompatibleSizeException. La classe Vecteur
deux attributs taille et tab (tableau). Vous écrirez aussi un constructeur, les méthodes
de consultation (taille, getTab) et de modification (setElement).

Vecteur
- taille :int
- tab :double []
<<constructor>> Vecteur(int taille)
Exception
<<constructor>> Vecteur(double[] A)
<<constructor>> Vecteur(Vecteur V)
getTaille()
getElement(int i)
IncompatibleSizeException
setElement(int i, double val)
sommeVecteurs(Vecteur B)
sommeVecteurs(Vecteur A,Vecteur B)
produitScalire(Vecteur B)
affiche()

C. LOQMAN 51 FSDM Fès

 CHAPTER 4. EXERCICES

1. Ecrire une classe IncompatibleSizeException dérivée de la classe Exception:

2. Ecrire la classe Vecteur et la compiler:

• Créer un constructeur par défaut

• Créer un constructeur qui utilise la taille comme argument

• Créer un constructeur qui utilise le tableau A comme argument

• Créer une méthode getTaille qui retourne la taille;

• Créer une méthode getElement qui accède à un elément du tableau. Il faut

contrôler que les indices ne sont pas hors limite (Exception).

• Créer une méthode setElement qui modifie à un elément du [Link] faut

contrôler que les indices ne sont pas hors limite (Exception ).

• Créer une méthode appelée sommeVecteurs qui calcule la somme de deux

vecteurs. Il faut contrôler le nombres des linges et des colonnes (Exception
IncompatibleSizeException).

• Créer une méthode appelée produitScalaire qui calcule le produit scalaire

de deux vecteurs. Il faut contrôler la taille (Exception IncompatibleSizeEx-
ception).

• Créer une méthode affiche qui permet d’afficher le tableau.

3. Ecrire une classe Program qui comprend une methode Main( ) dans laquelle
on instancie plusieurs fois la classe Vecteur.

Exercice 4.0.7
L’objectif va être d’écrire cinque classes Personne, Etudiant, Note et Incompati-
bleSizeException qui modélisent le problème de la gestion des notes. Créez les classes
suivantes:

C. LOQMAN 52 FSDM Fès

 Personne
- nom :String
- prenom :String
Note
- age :String
- nom :String
- Sexe :String
- val :double
<<constructor>> Personne(...)
<<constructor>> Note(...)
getNom()
getNom()
getPrenom()
getval()
getAge()
getSexe()
toString()

Exception
Etudiant
- numIdentificat :int
- notes : [10] Note
<<constructor>> Etudiant(.....) IncompatibleSizeException
getNumIdent()
ajouterNote(Note a,int i)
getNoteIemeExam(int i)
moyenneEtudiant ()
toString()

Remarques:

1. Ecrire une classe nommée IncompatibleSizeException qui définit une excep-

tion qui sera levée si on ajoute (ou retourne) une note avec l’indice supérieur à
la taille du tableau.

Exercice 4.0.8
L’objectif va être d’écrire trois classes Personne, Professeur et Cours qui modélisent
le problème de la gestion des cours. Créez les classes suivantes:

C. LOQMAN 53 FSDM Fès

 CHAPTER 4. EXERCICES

Personne
- nom :String
Cours
- prenom :String
- nom :String
- age :String
- nbHeures :int
<<constructor>> Personne(...)
<<constructor>> Cours(...)
getNom()
getNom()
getPrenom()
getNbHeures()
getAge()
toString()

Professeur
- numIdentificat :int
- listCours :Vector<Cours>
<<constructor>> Professeur(.....)
getNumIdent()
ajouterCours(Cours a)
getNbheursCours(Cours a)
afficheNomsCours ()
toString()

C. LOQMAN 54 FSDM Fès

 Chapter 5

TP1

EXERCICE 1
Le but de cet exercice est d’être capable d’écrire un programme qui saisit des informa-
tions et les affiche.

1. Créer un fichier [Link] et écrire le contenu suivant dans le fichier Af-

[Link] :

class Affiche {
public static void main (String args[])
{
[Link]("Projet stade");
}
}

(a) Compilez cette classe à l’aide de la commande : javac [Link]

(b) Exécutez la classe Affiche à l’aide de la commande : java Affiche
(c) Que voyez-vous à l’exécution ?

2. Pour saisir des informations au clavier, Java dispose de la classe Scanner. Mais
celle-ci est compliquée pour être utilisée telle quelle. Modifier la méthode main()
comme suit :

import [Link].*;
class lire {
public static void main (String [] args)
{
[Link]("Projet stade");
Scanner sc = new Scanner([Link]);
[Link]("Veuillez saisir un mot :
");

C. LOQMAN 55 FSDM Fès

 CHAPTER 5. TP1

String str = [Link]();

[Link]("Vous avez saisi : " +
str);
}
}

(a) Maintenant vous savez faire un programme qui lit une chaı̂ne de caractères
ou un entier sur l’entrée standard et qui affiche une chaı̂ne de caractères sur
la sortie standard.

EXERCICE 2

1. Ecrire un programme qui saisit 2 entiers et affiche successivement la somme , la

différence et le produit de ces 2 entiers.

2. Ecrire un programme qui affiche le quotient et le reste de la division entière de

deux nombres entiers entrés au clavier ainsi que le quotient rationnel de ces nom-
bres.

EXERCICE 3
Ecrire un programme qui saisit deux entiers a et b et permute la valeur de ces deux
entiers.

EXERCICE 4
Ecrivez un programme qui lit la date d’un jour, exprimée sous la forme de trois nom-
bres j (jour), m (mois), a (année) et qui calcule et affiche la date du lendemain. On
supposera que la date donnée est correcte.

• j = 31, ou bien

• j = 30 et le mois est avril, juin, septembre ou novembre, ou bien

• j = 29 et le mois est février, ou bien

• j = 28, le mois est février et l’année n’est pas bissextile.

D’autre part, une année est bissextile si elle est divisible par 4 mais pas par 100. Cepen-
dant, les années multiples de 400 sont bissextiles.

C. LOQMAN 56 FSDM Fès

EXERCICE 5
La formule récurrente ci-dessous permet de calculer la racine du nombre A :
(
U0 = 1
Ui + UA
Ui+1 = 2
i

Ecrire un programme qui saisit le nombre d’itérations et A , puis calcule et affiche la

racine de A .
EXERCICE 6
Ecrire un programme qui lit deux nombres différents a et b et qui affiche leur maximum.

EXERCICE 7
Ecrire un programme qui calcule la factorielle d’un entier et indique à l’écran le résultat.
Le nombre n doit être lu sur la ligne de commande. La factorielle N! d’un entier naturel
N (
1 × 2 × 3...(N − 1) × N Si N 6= 0
N! =
1 Sinon

1. Utilisez while,

2. Utilisez for.

EXERCICE 8
Ecrivez un programme qui calcule et affiche les solutions d’une équation du second
degré
ax2 + bx + c = 0
où a, b et c sont trois nombres lus au clavier.

C. LOQMAN 57 FSDM Fès

 Chapter 6

TP2

EXERCICE 1
Définissez deux classes Compte et Banque. La classe Compte comprend trois at-
tributs solde, numero et comptes (static). Vous écrirez aussi un constructeur, les
méthodes de consultation (avoirSolde, avoirNumero) et de modification (deposer, re-
tirer).
Compte
- numero :int
- solde :float
- comptes :int
<<constructor>> Compte(int num,float sol)
avoirSolde()
avoirNumero()
retirer(float M)
toString()
deposer(float D)

1. Ecrire la classe Compte et la compiler:

• Créer un constructeur par défaut

• Créer un constructeur qui utilise le numéro et le solde comme argument
• Créer une méthode avoirSolde qui accède au solde
• Créer une méthode avoirNumero qui accède au numero
• Créer une méthode appelée retirer qui retire un montant M du solde Il faut
contrôler que le montant M doit être inférieur au solde
• Créer une méthode appeler deposer qui ajoute un montant M au solde
• Créer une variable qui permet de compter le nombre des comptes bancaires
qui sont ouverts

2. Ecrire une classe Banque qui comprend une methode main( ) dans laquelle on
instancie plusieurs fois la classe Compte. Afficher le solde et le numéro de chaque
Compte.

C. LOQMAN 58 FSDM Fès

EXERCICE 2
Définissez une classe Individu composée d’un nom, d’une adresse, et d’un numéro
de telephone. Vous écrirez aussi un constructeur, les méthodes de consultation et
modification des attributs, et une méthode toString(). Modifiez la classe Individu
pour pouvoir :

• afficher le nombre d’individus créés,

• gérer la liste des individus créés,

• afficher la liste des individus créés,

EXERCICE 3
Dans cet exercice, on considère des tableaux d’entiers.

1. Créer une classe TableauDEntier:

• Créer un constructeur par défaut.

• Créer méthode static remplirTab qui servira à créer un tableau d’entier
dont les valeurs seront lues sur la ligne de commandes.
• Créer une méthode static afficherTab qui affiche un tableau.
• Créer une méthode static maxTab qui retourne le plus grand élément du
tableau.
• Créer une méthode static appelée SommeElementTab qui retourne la
somme de tous les éléments du tableau.
• Créer une méthode static appeler nombreOccurrencesTab qui recherche
le nombre d’occurrences d’un entier dans un tableau d’entiers
• Créer une méthode static appeler testEgaliteTab qui tester l’égalité en-
tre les deux tableaux : il rend VRAI si les composants des deux tableaux
correspondent position par position, et FAUX sinon.
• Créer une méthode static appeler triSélectionTab implémentant l’algorithme
du tri par sélection
• Créer une méthode static appeler rechercheDichotomiqueTab acceptant
en paramètre un entier x et un tableau et retournant un Booléen valant true
si et seulement x est dans le tableau

2. Ecrire une classe TestTab qui comprend une methode main( ) dans laquelle on
teste la classe TableauDEntier .

C. LOQMAN 59 FSDM Fès

 CHAPTER 6. TP2

import [Link];
public class TableauDEntier{
/* Cette méthode retourne un tableau int[] de nb éléments
* les éléments sont saisies au clavier lors de l’exécution*/
public static int [] remplirTab(int nb) {
int [] tab = new int[nb];
Scanner obj=new Scanner([Link]);
// A compléter
return tab;
}
/* Cette méthode affiche tous les éléments du tableau */
public static void afficherTab(int[] tab) {
// A compléter

}
/* Cette méthode calcule et retourne le plus grand élément du
tableau*/
public static int maxTab(int[] tab) {
// A compléter
}
/* Cette méthode calcule et retourne la somme de tous
*les éléments du tableau*/
public static int SommeElementTab(int[] tab) {
// A compléter
}
/* Cette méthode calcule et retourne le nombre d’occurrences
* d’un entier dans un tableau d’entiers.*/
public static int nombreOccurrencesTab(int n,int [] tab) {
// A compléter
}
/* Cette méthode tester l’égalité entre les deux tableaux :
* il rend VRAI si les composants des deux tableaux
correspondent
* position par position, et FAUX sinon.*/
public static boolean testEgaliteTab(int [] t1,int [] t2) {
// A compléter
}
/* Cette méthode implémente l’algorithme du tri par sélection :

C. LOQMAN 60 FSDM Fès

 * il rend un tableau trie*/
public static int [] triSélectionTab(int [] Tab) {
// A compléter
}
/* Cette méthode acceptant en paramètre un entier x et
* un tableau et retournant un indice */
public static int rechercheDichotomiqueTab(int [] tableau, int
x) {
// A compléter
}
}

C. LOQMAN 61 FSDM Fès

 Chapter 7

TP3

EXERCICE 1
´ Ecrire trois classes Figure, Carre, et Rectangle, Définissez trois classes Figure, Carre
et Rectangle telles que :

1. La classe Figure:

• A des attributs abscisse et ordonnée, ainsi qu’une couleur (encodée par

un entier).
• A Un constructeur
• A un attribut privé Vector référençant toutes les instances de sa classe et
de ses sous classes.
• A une méthode statique getInstances() renvoyant ce vecteur.
• A une méthode public toString() permettant d’afficher les attribus sous
forme d’une chaine de caractères.

2. La classe Carre:

• Hérite de Figure
• A un attribut cote
• Redéfinit la méthode toString();
• Redéfinit cette méthode getInstances() de manière à ne récupérer que les
instances qui correspondent à leur type.

3. La classe Réctangle:

• Hérite de Figure
• A deux attributis cote1 et cote1.
• Redéfinit la méthode toString();
• Redéfinit cette méthode getInstances() de manière à ne récupérer que les
instances qui correspondent à leur type.

C. LOQMAN 62 FSDM Fès

 Figure
int abscisse
int ordonnée
int couleur
Vector Instances
getInstances()
toString()

Réctangle
Carre
int cote1
int cote
int cotte2
getInstances()
getInstances()
toString()
toString()
aire()
aire()

C. LOQMAN 63 FSDM Fès

 Chapter 8

TP4

EXERCICE

1. Écrire une classe Animal représentant des animaux ayant, au moins, un cri, un
age et un ageMaximum. Ajouter un constructeur, des accesseurs et les méthodes:

• crie affichant le cri de l’animal,

• seDeplace prenant en paramètre le nombre de mètres affiche une phrase

du style l’animal se déplace de X mètres,

• vieillie ajoutant soit un an, soit le nombre d’années placé en paramètre à

l’âge de l’animal, l’animal meurt s’il dépasse son ageMaximum. Pensez à
afficher l’âge et s’il est vivant encore...

• mange : affiche l’animal mange puis affichez le cri de l’animal,

• affiche : affichant la description de l’animal.

2. Écrire une classe Oiseau héritant de la classe Animal. Sachant qu’un oiseau vole
pour se déplacer et a un âge maximum de 20 ans.

3. Écrire une classe Aigle héritant de la classe Oiseau. Un aigle vit 10 ans.

4. Écrire une classe Chien héritant de la classe Animal. Un chien possède un nom,
marche pour se déplacer et a pour âge maximum 15 ans

5. Instancier un chien, un aigle et les faire manger, se déplacer et vieillir. Puis appel
affiche.

C. LOQMAN 64 FSDM Fès

 Animal
String cri
int age
int ageMaximum
Animal(String,int,int)
crie():void
seDeplace(int):void
vieillie():void
mange():void
affiche():void

Chien Oiseau
String nom

Aigle

C. LOQMAN 65 FSDM Fès

 Bibliography

[1] Ken Arnold, James Gosling et David Holmes. Le Langage Java, 2001.

[2] Jean Brondeau. Introduction à la programmation objet en Java. Dunod, Paris,

1999.

[3] Bruce Eckel. Thinking in Java. Prentice-Hall, 2002.

C. LOQMAN 66 FSDM Fès