Vous êtes sur la page 1sur 262

POO EN JAVA

Pr. Abdelmajid HAJAMI


PLAN
• Concepts de la POO
• Présentation de JAVA
• Généralités
• Les types primitifs de JAVA
• Les instructions de contrôle de JAVA
• Les classes et les objets
• Les tableaux
• L’héritage
• Les chaînes de caractères et les types énumérés
• CONCEPTS DE LA POO
CONCEPTS DE L’ORIENTÉ OBJET

• En approche orientée objet, le logiciel est considéré comme une


collection d’objets qui collaborent entre eux, pour réaliser le métier
du client.
• Les objets sont identifiés, et possèdent des caractéristiques
statiques et dynamiques

CONCEPTS OO 4
CONCEPTS DE L’ORIENTÉ OBJET
Objet
• Un objet du monde réel est une chose concrète ou abstraite.
• Le monde réel n’est composé que de chose ou objets! Tout est objet!

• Un objet informatique est une représentation (un modèle) d’un objet du monde
réel. Il modélise une chose abstraite ou concrète
• Un modèle est une abstraction, c-à-d un mécanisme qui permet de ne retenir
que les caractéristiques essentielles d’un objet

CONCEPTS OO 5
CONCEPTS DE L’ORIENTÉ OBJET
Classe
• Il s’agit d’un modèle abstrait de données et de traitement
représentant un objet réel dans la nature et regroupant des
caractéristiques (attributs et méthodes) communes à des objets.
• Un objet est une simple instance de la classe

CONCEPTS OO 6
CONCEPTS DE L’ORIENTÉ OBJET
Classe
• En UML, elle est représenté par:

id id id
attributs attributs
Méthodes()

Suivant l’évolution dans l’étude

CONCEPTS OO 7
CONCEPTS DE L’ORIENTÉ OBJET
Classe
• Chasser l’intrus :
Classe véhicule

Camion Arbre

Voiture Avion

CONCEPTS OO 8
CONCEPTS DE L’ORIENTÉ OBJET
Identité
• Tout objet possède une identité , qui permet de l’identifier et de le différencier
des autres objets.
• L’id se fait par le choix d’une variable unique qui permet de spécifier l’objet dans
un système
• L’id permet de rendre l’objet persistant dans le mapping O/R ou bien avec les
annotations de l’API JPA (Java Persistant API)

id

CONCEPTS OO 9
CONCEPTS DE L’ORIENTÉ OBJET
Attributs
• Ce sont les données qui caractérisent l’objet. Ou des variables qui
indiquent l’état de l’objet dans le temps.
• Ils présentent en plus de l’identité, la partie statique d’une classe

id
attributs

CONCEPTS OO 10
CONCEPTS DE L’ORIENTÉ OBJET
Méthodes
• Elles définissent le comportement (behavior) d’un objet, c-à-d l’ensemble des
opérations que l’objet est chargé de réaliser dans un logiciel.
• Ces opérations permettent de faire réagir l’objet aux sollicitations extérieurs, ou
d’agir sur les autres objets
• Les opérations sont liées aux attributs, car leurs actions peuvent dépondre des
valeurs d’attributs ou les modifier.
• L’approche OO associe les données et les traitements au seins de la même
classe. id
attributs
méthodes

CONCEPTS OO 11
CONCEPTS DE L’ORIENTÉ OBJET
Méthode abstraite
• C’est une opération de la classe avec uniquement une signature et
sans corps.
• La signature d’une méthode abstraite décrit le nom, le type de
retour, les arguments et leurs types

CONCEPTS OO 12
CONCEPTS DE L’ORIENTÉ OBJET
Classe abstraite
• C’est une classe qui possède au moins une méthode abstraite.
• Une classe abstrait n’est pas instanciable
• elle représente un modèle de classe comme les interfaces; mais au
contraire des interfaces, les classes abstraites peuvent avoir des
attributs

CONCEPTS OO 13
CONCEPTS DE L’ORIENTÉ OBJET
Interface
• C’est un modèle de classe, permettant de rassembler les classes par
leur comportements seulement
• Les classes qui implémente une interface, définissent les méthodes
abstraite, chacune à sa façon.

CONCEPTS OO 14
CONCEPTS DE L’ORIENTÉ OBJET
Interface
Véhicule Interface
Absence des attributs
déplacer()

voiture bateau avion


attributs attributs attributs

déplacer() déplacer()
déplacer() {rouler} {voler}
{naviguer}

CONCEPTS OO 15
CONCEPTS DE L’ORIENTÉ OBJET
Encapsulation
• Elle consiste à masquer les détails de l’implémentation d’un
objet, en définissant des modifications de visibilité à ses
attributs et ses méthodes.
• Elle garantit l’intégrité et la sécurité d’accès aux données, car
elle interdit l’accès direct aux caractéristiques des objets.

CONCEPTS OO 16
CONCEPTS DE L’ORIENTÉ OBJET
Encapsulation
• Elle est assurée par les modifications de visibilité suivante:

accessibilité public private protected Package freindly

À l’intérieur de la OUI OUI OUI OUI


classe
Classes du même OUI NON OUI OUI
package
Classes dérivées OUI NON OUI NON

Classes hors du OUI NON NON NON


package

CONCEPTS OO 17
CONCEPTS DE L’ORIENTÉ OBJET
Association
• Une association normale est une connexion entre classes
• elle possède un nom
• elle est généralement navigable de manière bidirectionnelle (dans ce cas elle
a un nom dans les deux sens si nécessaire)
• elle a une multiplicité
• elle peut être dotée de rôles

Personne
possède Voiture

CONCEPTS OO 18
CONCEPTS DE L’ORIENTÉ OBJET
Cardinalité (Multiplicité)
• Elle indique le nombre d’instances (objets) d’une classe associées à
une instance de l’autre classe

Personne
1 possède 0.*
Voiture

CONCEPTS OO 19
CONCEPTS DE L’ORIENTÉ OBJET
Héritage
• C’est un concept de passage des caractéristiques de la classe mère
(ses attributs et méthodes) vers la classe fille à condition que les
contraintes d’encapsulation le permettent (public, protected).
• Une classe peut être dérivable en d’autres classes , à fin d’y ajouter des
caractéristiques spécifiques ou d’en adapter certaines (spécialisation).
• Plusieurs classes peuvent être « généralisées » en une classe qui les
factorise, à fin de regrouper leurs caractéristiques communes
(généralisation).
• L’héritage peut être simple ou multiple.
• L’héritage multiple n’est pas supporté par JAVA et il est supporté par C++

CONCEPTS OO 20
CONCEPTS DE L’ORIENTÉ OBJET
Héritage C_Mère

Attributs_C_M

Méthodes_C_M
Passage des attributs et des
méthodes de la classe mère
vers la classe fille
C_Fille

Attributs_C_F

Méthodes_C_F
CONCEPTS OO 21
CONCEPTS DE L’ORIENTÉ OBJET
Héritage : spécialisation Etre vivant

Spécialisation Animale

Chevale

CONCEPTS OO 22
CONCEPTS DE L’ORIENTÉ OBJET
Héritage : généralisation Moyen_transport

Attributs

véhicule Généralisation

Attributs

bus voiture Chevale

Attributs Attributs Attributs


CONCEPTS OO 23
CONCEPTS DE L’ORIENTÉ OBJET
Héritage multiple Animal

Attributs

A_terreste A_aquatique

Attributs Attributs

Tortue

Attributs
CONCEPTS OO 24
CONCEPTS DE L’ORIENTÉ OBJET
Polymorphisme
Grèc --> Poly : différents; morphisme : forme
• Le concept qui fournit la possibilité d’utiliser la même
méthode dans un programme, mais avec des traitements
différents, grâce à l’héritage et la redéfinition de la méthode
polymorphe dans les classes dérivées

CONCEPTS OO 25
CONCEPTS DE L’ORIENTÉ OBJET
Forme_géometrique
Polymorphisme
Attributs

Calcul_surface()

Cercle Triangle

Attributs Attributs

Calcul_surface(rayon) Calcul_surface(base, haut)

CONCEPTS OO 26
CONCEPTS DE L’ORIENTÉ OBJET
Agrégation
• Il s’agit d’une relation d’inclusion entre deux classes,
spécifiant que les objets d’une classe (agrégat) sont des
composants (agrégés)de l’autre classe composite.

Groupe Etudiant

CONCEPTS OO 27
CONCEPTS DE L’ORIENTÉ OBJET
Composition
• C’est une agrégation forte : la classe composite et les
classes composants ont la même durée de vie

Cytoplasme Cellule Noyau

CONCEPTS OO 28
• PRÉSENTATION DE JAVA
PRÉSENTATION DE JAVA
PHASES DE DEVELOPPEMENT D'UN PROGRAMME JAVA
Phase 1: Edition
- Editeur
+ vi et emacs sous UNIX
+ Bloc-notes sous WINDOWS
+ Environnements de Développement Intégrés (EDI): JBuilder de
Borland, NetBeans, Visual Cafe de Symantec, Visual J++ de
Microsoft
- Le nom de fichier d'un programme Java se termine toujours par
l'extension .java.
- Exemple: Programme.java
PRÉSENTATION JAVA 30
PRÉSENTATION DE JAVA
PHASES DE DEVELOPPEMENT D'UN PROGRAMME JAVA

Phase 2: Compilation
- La commande du compilateur Java pour compiler un programme Java et le traduire en
byte codes, est javac.
- La compilation génère un fichier possédant le même nom que la classe et contenant
les bytes codes avec l'extension .class. Le compilateur génère un fichier compilé pour
chaque classe.
Ainsi, si le fichier source contient plusieurs classes, alors plusieurs fichiers ont
l'extension .class.
- Exemple: javac Programme.java génère un fichier Programme.class
Mettre l'extension à la suite du nom en respectant la casse du nom de fichier.
Java est sensible à la casse.
PRÉSENTATION JAVA 31
PRÉSENTATION DE JAVA
PHASES DE DEVELOPPEMENT D'UN PROGRAMME JAVA
Phase 3: Chargement
- Le chargeur de classe prend le ou les fichiers .class et les transfère en mémoire centrale
- Le fichier .class peut être chargé à partir d'un disque dur de sa propre machine ou à travers un
réseau
- 2 types de fichier .class peuvent être chargés: les applications (programmes exécutés sur sa
propre machine) et les applets (programmes stockés sur une machine distante et chargés dans le
navigateur Web).

- Une application peut être chargée et exécutée par la commande de l'interpréteur Java
java
- Exemple: java Programme
Pas d'extension .class à la suite du nom.
PRÉSENTATION JAVA 32
PRÉSENTATION DE JAVA
PHASES DE DEVELOPPEMENT D'UN PROGRAMME JAVA

Phase 4: Vérification
Les byte codes dans une applet sont vérifiés par le vérificateur
de byte codes avant leur exécution par l'interpréteur Java
intégré au navigateur ou à l'appletviewer. Ce vérificateur vérifie
que les byte codes sont conformes aux restrictions de sécurité
de Java concernant les fichiers et la machine.

PRÉSENTATION JAVA 33
PRÉSENTATION DE JAVA
PHASES DE DEVELOPPEMENT D'UN PROGRAMME JAVA
Phase 5: Exécution
L'ordinateur interprète le programme byte code par byte code.
Les interpréteurs présentent des avantages sur les compilateurs
dans le monde Java. En effet, un programme interprété peut
commencer immédiatement son exécution dès qu'il a été téléchargé
sur la machine cliente, alors qu'un programme source devant subir
une compilation supplémentaire entraînerait un délai de compilation
avant de pouvoir démarrer son exécution.
Cependant, dans des applets à forte charge de calcul, l'applet doit
être compilé pour augmenter la rapidité d'exécution.
PRÉSENTATION JAVA 34
• GÉNÉRALITÉS
GÉNÉRALITÉS
PROGRAMME ECRITURE CONSOLE
• Problème: Ecriture d'un texte dans une fenêtre console
• Fichier: Ecriture.java
public class Ecriture
{
public static void main(String[] args)
{
System.out.println("Un programme Java");
}
}
PRÉSENTATION JAVA 36
GÉNÉRALITÉS
PROGRAMME ECRITURE CONSOLE
• Problème: Ecriture d'un texte dans une fenêtre console
• Fichier: Ecriture.java
public class Ecriture
{
public static void main(String[] args)
{
System.out.println("Un programme Java");
}

• Exécution:
Un programme Java
PRÉSENTATION JAVA 37
GÉNÉRALITÉS
PROGRAMME ECRITURE FENETRE
• Problème: Ecriture d'un texte dans une fenêtre graphique
• Fichier: EcritureFenêtre.java
import javax.swing.*;
public class EcritureFenêtre
{
public static void main(String[] args)
{
JOptionPane.showMessageDialog(null,"Fenêtre Java");
}
}

PRÉSENTATION JAVA 38
GÉNÉRALITÉS
PROGRAMME ECRITURE FENETRE
• Problème: Ecriture d'un texte dans une fenêtre graphique
• Fichier: EcritureFenêtre.java
import javax.swing.*;
public class EcritureFenêtre
{
public static void main(String[] args)
{
Exécution : JOptionPane.showMessageDialog(null,"Fenêtre
Java");
}
}

PRÉSENTATION JAVA 39
GÉNÉRALITÉS
PROGRAMME ECRITURE FENETRE
• Problème: Ecriture d'un texte dans une Applet
• Fichier: EcritureApplet.java
import java.awt.*;
import javax.swing.*;

public class EcritureApplet extends JApplet


{
public void paint(Graphics g)
{
g.drawString("APPLET JAVA", 100, 100);
}
}
PRÉSENTATION JAVA 40
GÉNÉRALITÉS
PROGRAMME ECRITURE FENETRE
• Problème: Ecriture d'un texte dans une Applet
• Fichier: EcritureApplet.java import java.awt.*;
import javax.swing.*;

public class EcritureApplet extends JApplet


{
• Exécution : public void paint(Graphics g)
{
g.drawString("APPLET JAVA", 100, 100);
}
}

PRÉSENTATION JAVA 41
GÉNÉRALITÉS
PROGRAMME LECTURE

• Problème: Lecture d'un texte d'une fenêtre console


• Fichier: : Lecture.java

PRÉSENTATION JAVA 42
Lecture à partir du clavier 1/4
import java.io.*;

// Méthodes de lecture au clavier


public class Lecture
{
// Lecture d'une chaîne
public static String lireString()
{
String ligne_lue = null;
{
InputStreamReader lecteur = new InputStreamReader(System.in);
BufferedReader entree = new BufferedReader(lecteur);
ligne_lue = entree.readLine();

try
}
catch (IOException err)
{
System.exit(0);
}
return ligne_lue;
}
Lecture à partir du clavier 2/4
// Lecture d'un réel double
public static double lireDouble()
{
double x = 0;
String ligne_lue = lireString();
x = Double.parseDouble(ligne_lue);
try
{
}
catch (NumberFormatException err)
{
System.out.println("Erreur de donnée");
System.exit(0) ;
}
return x;
}
Lecture à partir du clavier 3/4
// Lecture d'un entier
public static int lireInt()
{
int n = 0;

try
{
String ligne_lue = lireString();
n = Integer.parseInt(ligne_lue);
}
catch (NumberFormatException err)
{
System.out.println ("Erreur de donnée");
System.exit(0);
}
return n;
}
Lecture à partir du clavier 4/4
// Programme test de la classe Lecture
public static void main (String[] args)
{
System.out.print("Donner un double: ");
double x;
x = Lecture.lireDouble();
System.out.println("Résultat " + x);
System.out.print("Donner un entier: « )
int n;
n = Lecture.lireInt();
System.out.println("Résultat " + n);
}
}
Exécution
Donner un double: 10.01
Résultat 10.01
Donner un entier: 10
Résultat 10
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Identificateurs

Dans un langage de programmation, un identificateur est une suite de caractères


servant à désigner les différentes entités manipulées par un programme : variables,
fonctions, classes, objets...

PRÉSENTATION JAVA 47
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Identificateurs

Par convention
• Les identificateurs de classes commencent toujours par une majuscule.
• Les identificateurs de variables et de méthodes commencent toujours par une
minuscule.
• Les identificateurs formés par la concaténation de plusieurs mots, comporte une
majuscule à chaque début de mot sauf pour le 1er mot qui dépend du type
d'identificateur.
• Exemple: public class ClasseNouvelle

PRÉSENTATION JAVA 48
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Les mots clés


Certains mots-clés sont réservés par le langage à un usage bien défini et ne peuvent
pas être utilisés comme identficateurs.
En voici la liste, par ordre alphabétique :

abstract assert boolean break byte int interface long native new
case catch char class const null package private protected public
continue default do double else return short static super switch
extends final finally float for synchronized this throw throws transient
goto if implements import instanceof try void volatile while

PRÉSENTATION JAVA 49
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Les séparateurs
• Dans notre langue écrite, les mots sont séparés par un espace, un signe de
ponctuation ou une fin de ligne. Il en va quasiment de même en Java.
Ainsi, on ne pourra pas remplacer : ou, plus lisiblement :
int x,y; int n, compte, p, total, valeur ;
par voire :
intx,y; int n,
compte,
En revanche, vous pourrez écrire indifféremment : p,
int n,compte,p,total,valeur ; total,
valeur ;

PRÉSENTATION JAVA 50
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Les séparateurs : le format libre


// Calcul de racines carrees
// La classe Racines utilise la classe Clavier
public class Racines1 { public
static void main (String[] args) { final int NFOIS = 5 ; int i ; double
x ; double racx ; System.out.println ( "Bonjour" ) ; System.out.println ("Je vais vous calculer " +
NFOIS + " racines carrees") ; for (i=0 ; i < NFOIS ; i++) { System.out.print ("Donnez un nombre : ") ;
x = Clavier.lireDouble () ; if (x < 0.0) System.out.println (x + " ne possede pas de racine carree")
; else { racx = Math.sqrt(x) ; System.out.println (x + " a pour racine carree : " + racx) ; } }
System.out.println("Travail termine - Au revoir") ; }}

PRÉSENTATION JAVA 51
Les séparateurs : le format libre (écriture correcte)
// Calcul de racines carrees
// La classe Racines utilise la classe Clavier
public class Racines
{ public static void main (String[] args)
{ final int NFOIS = 5 ;
int i ;
double x ;
double racx ;
System.out.println ("Bonjour") ;
System.out.println ("Je vais vous calculer " + NFOIS + " racines carrees") ;
for (i=0 ; i<NFOIS ; i++)
{ System.out.print ("Donnez un nombre : ") ;
x = Clavier.lireDouble () ;
if (x < 0.0)
System.out.println (x + " ne possede pas de racine carree") ;
else
{ racx = Math.sqrt(x) ;
System.out.println (x + " a pour racine carree : " + racx) ;
}
}
System.out.println ("Travail termine - Au revoir") ;
} PRÉSENTATION JAVA 52
}
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Commentaires
3 formes
Commentaire usuel pouvant s'étendre sur plusieurs lignes: /* … */
Commentaire de fin de ligne s'arrêtant en fin de la ligne: //
Commentaire de documentation pouvant être extraits automatiquement par des
programmes utilitaires de création de documentation tels que Javadoc qui génère
automatiquement une documentation en format HTML: /** … */

PRÉSENTATION JAVA 53
GÉNÉRALITÉS
REGLES GENERALES D'ECRITURE

Commentaires
/* programme de calcul de racines carrees */
/* commentaire s’etendant
sur plusieurs lignes
de programme
*/
/* =============================================================== *
* UN TITRE MIS EN VALEUR *
* =============================================================== */
int i ; /* compteur de boucle */
float x; /* nombre dont on cherche la racine */
float racx ; /* pour la racine carre de x */

PRÉSENTATION JAVA 54
• LES TYPES PRIMITIFS DE JAVA
LES TYPES PRIMITIFS DE JAVA
Notion de type
• Dans tout programme, il est nécessaire de stocker, au moins
provisoirement, des valeurs, de provenances variées (données
d'entrée, résultats intermédiaires, ...)
• Le type d’une valeur permet de différencier la nature de l’information
stockée dans une variable.

x 26

PRÉSENTATION JAVA 56
LES TYPES PRIMITIFS DE JAVA
TYPE BOOLEEN
Déclaration d'une variable booléenne
boolean test ;
Une variable booléenne prend 2 valeurs: false et true.

Affectation d'une variable booléenne


test = (n < m) ;

PRÉSENTATION JAVA 57
LES TYPES PRIMITIFS DE JAVA
TYPE ENTIER
• Le type entier permet de représenter de façon exacte une partie des
nombres entiers relatifs.
Type Taille (octet) Valeur minimale Valeur maximale

byte 1 -128 127


(Byte.MIN_VALUE) (Byte.MAX_VALUE)
short 2 -32 768 32 767
(Short.MIN_VALUE) (Short.MAX_VALUE)
int 4 -2 147 483 648 2 147 483 647
(Integer.MIN_VALUE) (Integer.MAX_VALUE)
long 8 -9 223 372 036 854 775 808 9 223 372 036 854 775 807
(Long.MIN_VALUE) (Long.MAX_VALUE)

Par défaut: une constante entière est de type int.


PRÉSENTATION JAVA 58
LES TYPES PRIMITIFS DE JAVA
TYPE REEL
• Le type réel permet de représenter de façon approchée une partie des
nombres réels.

Type7 Taille (octet) Précision Valeur minimale Valeur maximale


(chiffres significatifs)
float 4 7 1.402E-45 3.402E38
Float.MIN_VALUE Float.MAX_VALUE
double 8 15 4.94E-324 1.79E308
Double.MIN_VALUE Double.MAX_VALUE

Par défaut: une constante réelle est de type double.

PRÉSENTATION JAVA 59
LES TYPES PRIMITIFS DE JAVA
TYPE REEL
• Problème: Ecriture d'une variable réelle en utilisant un formatage
• Fichier: EcritureReel.java import java.awt.*;
public class EcritureReel
{
public static void main(String[] args)
{
double x = 10.123456789;
System.out.println("x= " + x);
// au moins 1 chiffre à gauche du point décimal
// 2 chiffres exactement à droite du point décimal
Exécution DecimalFormat deuxDecimal = new DecimalFormat("0.00");
x= 10.123456789 System.out.println("x= " + deuxDecimal.format(x));
x= 10,12 }
}
PRÉSENTATION JAVA 60
LES TYPES PRIMITIFS DE JAVA
TYPE CARACTERE
Le caractère en Java est représenté en mémoire sur 2 octets en
utilisant le code Unicode.
Déclaration d'une variable caractère
char c;

Une constante caractère est notée entre apostrophe.


Exemple: 'a'

PRÉSENTATION JAVA 61
LES TYPES PRIMITIFS DE JAVA
Constantes et expressions constantes
Le mot-clé final

final int n = 20 ;
n=n+5; // erreur : n a été déclarée final
n = Clavier.lireInt() ; // idem

PRÉSENTATION JAVA 62
EXERCICES

1. Ecrire un programme qui permet de permuter deux


nombres
2. Ecrire un programme qui lit le prix HT d’un article, le
nombre d’articles et le taux de TVA, et qui fournit le
prix total TTC correspondant. Faire en sorte que des
libellés apparaissent clairement.
• LES INSTRUCTIONS DE CONTRÔLE
DE JAVA
LES INSTRUCTIONS DE CONTRÔLE DE JAVA
INSTRUCTION if
if (expression_booléenne) instruction_1
[ else instruction_2 ]

PRÉSENTATION JAVA 65
LES INSTRUCTIONS DE CONTRÔLE DE JAVA
INSTRUCTION switch
switch (expression)
{
case constante_1: [ suite_instructions_1 ]
..........................
case constante_n: [ suite_instructions_n ]
[ default: suite_instructions ]
}

PRÉSENTATION JAVA 66
LES INSTRUCTIONS DE CONTRÔLE DE JAVA
INSTRUCTION while
while (expression_booléenne) instruction

INSTRUCTION do while
do instruction while (expression_booléenne);

PRÉSENTATION JAVA 67
LES INSTRUCTIONS DE CONTRÔLE DE JAVA
INSTRUCTION for
for ([ initialisation ]; [ expression_booléenne ] ; [ incrémentations ])
instruction
public class InstructionFor
{
public static void main (String args[])
{
for (int i=1, j=1; (i <= 5); i++, j+=i)
{
System.out.println ("i= " + i + " j= " + j);
}
}
}

PRÉSENTATION JAVA 68
EXERCICES
1- Ecrire le programme qui affiche le mois correspondant à un nombre
compris entre 1 et 12 .
2- Traduire l’algorithme suivant en un programme JAVA
Algorithme DeuxChiffres ;
constante (STOP : entier)  99999 ;
variables uneVal, : entier ;
début
ecrire ("Entrer un nombre, ", STOP, " pour finir. ") ;
lire (uneVal) ;
tant que uneVal ≠ STOP faire
si uneVal ≥ 10 et uneVal < 100
alors ecrire ( uneVal, " est un nombre à deux chiffres. " ) ;
finsi
ecrire ("Entrer un autre nombre, " , STOP, " pour finir. ") ;
lire (uneVal) ;
fintantque
ecrire (" fin de l’algorithme ") ;
69
fin
EXERCICES
3- Ecrire le programme de résolution d’une équation du second ordre
dans l’ensemble C:
aX2 + bX + c = 0
a, b et c sont lus à partir du clavier.

4- Écrire un programme qui détermine le factoriel d’un entier N en utilisant


les boucles du type : Pour, Tant que et Répéter.

5- Écrire un algorithme qui calcule la somme des nombres entrés par


l'utilisateur tant que cette somme est inférieure à mille.

PRÉSENTATION JAVA 70
EXERCICES
6- Ecrire le programme qui calcule la moyenne de N notes.

7- Ecrire un programme calculant la somme des n premiers termes de la


"série harmonique", c’est-à-dire la somme :
1 + 1/2 + 1/3 + 1/4 + ..... + 1/n
La valeur de n sera lue en donnée

PRÉSENTATION JAVA 71
• LES CLASSES ET LES OBJETS
LES CLASSES ET LES OBJETS

• La notion de classe généralise la notion de type. La classe


comporte des champs (données) et des méthodes.

• La notion d'objet généralise la notion de variable.

• Un type classe donné permet de créer (d'instancier) un ou


plusieurs objets du type, chaque objet comportant son propre
jeu de données.

73
LES CLASSES ET LES OBJETS

Définition d’une classe


• Nous nous proposons de définir une classe nommée Point
,destinée à manipuler les points d’un plan.

public class Point


{

// instructions de définition des champs et des méthodes de la classe

74
LES CLASSES ET LES OBJETS

Définition des champs : attributs


• Nous supposons qu’un objet de type Point sera représenté par
deux coordonnées entières :

public class Point


{

private int x ; // abscisse


private int y ; // ordonnée

75
LES CLASSES ET LES OBJETS
Définition des méthodes
public class Point
{
public void initialise (int abs, int ord)
{ x = abs ;
y = ord ;
}
public void deplace (int dx, int dy)
{ x += dx ;
y += dy ;
}
public void affiche ()
{ System.out.println ("Je suis un point de coordonnées " + x + " " + y) ;
}

private int x ; // abscisse


private int y ; // ordonnée
} 76
LES CLASSES ET LES OBJETS
Utilisation de la classe
public class TestPoint
{
public static void main (String args[])
{ Point a ; // a est un handle (une référence sur un objet)
a = new Point() ;
a.initialise(3, 5) ; a.affiche() ;
a.deplace(2, 0) ; a.affiche() ;
Point b = new Point() ;
b.initialise (6, 8) ; b.affiche() ;
}
}
Je suis un point de coordonnées 3 5
Exécution  Je suis un point de coordonnées 5 5
Je suis un point de coordonnées 6 8 77
LES CLASSES ET LES OBJETS
Mise en œuvre d’un programme comportant plusieurs classes
Un fichier source par classe
• Chaque classe est mise dans un fichier à part dans le même dossier :
• Point.java et TestPoint.java
• Compiler les fichier Point.java  javac Point.java  point.class
• Compiler le fichier Testpoint.java  javac TestPoint.java  TestPoint.class
• Lancer le fichier TestPoint.class  java TestPoint

78
Plusieurs classes dans un seul fichier source
class Point
Accessibilité paquetage
{ public void initialise (int abs, int ord)
{ x = abs ; y = ord ;
}
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; Accessibilité JVM
}
public void affiche ()
{ System.out.println ("coordonnées " + x + " " + y) ;
}
public class TestPoint
private int x ; // abscisse {
public static void main (String args[])
private int y ; // ordonnée
{ Point a ;
} a = new Point() ;
a.initialise(3, 5) ; a.affiche() ;
a.deplace(2, 0) ; a.affiche() ;
Point b = new Point() ;
b.initialise (6, 8) ; b.affiche() ;
} 79
}
LA NOTION DE CONSTRUCTEUR
Généralités

public class Point


{
public void initialise (int abs, int ord)
{ x = abs ;
y = ord ; Il est nécessaire de recourir à la méthode initialise
} pour attribuer des valeurs aux champs d’un objet de
……………… type Point.
……………..
} La notion de constructeur permet d’automatiser
le mécanisme d’initialisation d’un objet.

• Un constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, portant le même
nom que la classe.
• Un constructeur peut disposer d’un nombre quelconque d’arguments (éventuellement
aucun).

80
LA NOTION DE CONSTRUCTEUR
Exemple de classe comportant un constructeur

public class Point


{
public Point ( int abs, int ord)
{ x = abs ;
y = ord ;
} Comment utiliser cette classe ?
……………… \\ Une instruction telle que :
…………….. Point a = new Point() ; \\ est refusée par le compilateur.
}

Ici, notre constructeur a besoin de deux arguments. Ceux-ci doivent


obligatoirement être fournis lors de la création, par exemple :
Point a = new Point(1, 3) ;

81
LA NOTION DE CONSTRUCTEUR
Exemple de classe comportant un constructeur

public class Point


{
public Point ( int abs, int ord) public class TstPnt3
{ x = abs ;
y = ord ; { public static void main (String args[ ])
} { Point a ;
………………
…………….. a = new Point(3, 5) ;
} a.affiche() ;
a.deplace(2, 0) ;
a.affiche() ;
Point b = new Point(6, 8) ;
b.affiche() ;
}
}

82
LA NOTION DE CONSTRUCTEUR
Quelques règles concernant les constructeurs

1. Un constructeur ne fournit 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
class Test
{ .....
public void Test () // erreur de compilation : void interdit ici
{ .....
}
}

2. Une classe peut ne disposer d’aucun constructeur


Point a = new Point() ; // OK si Point n’a pas de constructeur

83
LA NOTION DE CONSTRUCTEUR
Quelques règles concernant les constructeurs

4. Un constructeur ne peut pas être appelé directement depuis une autre méthode.
Par exemple, si Point dispose d’un constructeur à deux arguments de type int:

Point a = new Point (3, 5) ;


.....
a.Point(8, 3) ; // interdit

84
LA NOTION DE CONSTRUCTEUR

Construction et initialisation d’un objet

la création d’un objet entraîne toujours, par ordre chronologique, les


opérations suivantes :
• une initialisation par défaut de tous les champs de l’objet,
• une initialisation explicite lors de la déclaration du champ,
• l’exécution des instructions du corps du constructeur.

85
LA NOTION DE CONSTRUCTEUR

Construction et initialisation d’un objet


Initialisation par défaut des champs d’un objet

86
LA NOTION DE CONSTRUCTEUR

Construction et initialisation d’un objet


Initialisation explicite des champs d’un objet
class A
{ public A (...) { ..... } // constructeur de A
.....
private int n = 10 ;
private int p ;
}
L’instruction suivante :
A a = new A (...) ;
entraîne successivement :
• l’initialisation (implicite) des champs n et p de a à 0,
• l’initialisation (explicite) du champ n à la valeur figurant dans sa déclaration, soit 10,
• l’exécution des instructions du constructeur.

87
LA NOTION DE CONSTRUCTEUR
Construction et initialisation d’un objet
Appel du constructeur
public class Init
{ public static void main (String args[])
{ A a = new A() ; Donnez les valeurs affichées :
a.affiche() ;
n= 5 , p = 10 , np = 200
}
}
class A
{ public A()
{ np = n * p ;
n=5;
}
public void affiche()
{ System.out.println ("n = " + n + ", p = " + p + ", np = " + np) ;
}
private int n = 20, p = 10 ;
private int np ;
} 88
TYPOLOGIE DES MÉTHODES D’UNE CLASSE
Parmi les différentes méthodes que comporte une classe, on a souvent tendance à
distinguer :
• les constructeurs ;
• les méthodes d’accès (en anglais accessor ) qui fournissent des informations relatives
à l’état d’un objet, c’est-à-dire aux valeurs de certains de ses champs (généralement
privés), sans les modifier ;
• les méthodes d’altération (en anglais mutator ) qui modifient l’état d’un objet, donc les
valeurs de certains de ses champs.

public int getX { return x ; } // getX ou encore getAbscisse


public int getY { return y ; } // getY ou encore getOrdonnee
public void setX (int abs) { x = abs ; } // setX ou encore setAbscisse
public void setY (int ord) { x = ord ; } // setY ou encore setOrdonnee
public void setPosition (int abs, int ord) { x = abs ; y = ord ; }

89
AFFECTATION ET COMPARAISON D’OBJETS

Exemple 1
P1 1
// Soient 2 variables P1 et P2 de type point
Point P1, P2; 5
//Soit 2 objets P1 et P2 de type point
P2 2
P1 = new point(1, 5);
P2 = new point(2, 8); 8
//L'instruction
P1 = P2 ;
/* affecte à P1 la référence de P2.
Ainsi, P1 et P2 désigne le même objet point(2, 8) et non pas 2 objets de
même valeur. */ P1
2
8
P2 90
RAMASSE-MIETTES
Garbage Collector
Point A;
A = new point(8,12); // objet avec référence

(new Point(3,5)).affiche() ; // Objet sans référence candidat au ramasse-miettes


En Java, il n’existe aucun opérateur permettant de détruire un
objet dont on n’aurait plus besoin.
En fait, la démarche employée par Java est un mécanisme de gestion
automatique de la mémoire connu sous le nom de ramassse-miettes (en
anglais Garbage Collector).

On peut activer le garbage collector par l'instruction :


System.gc();

91
RÈGLES D’ÉCRITURE DES MÉTHODES

Méthodes ne fournissant aucun résultat


Méthode avec le mot clé void dans son en-tête.
Méthode appelée: objet.méthode(liste arguments).

Méthodes fonction fournissant un résultat


public class Point
{ int getX { return x ; }
int getY { return y ; }
double distance ()
{ double d ;
d = Math.sqrt (x*x* + y*y) ;
return d ;
}
private int x, y ;
…………. 92
}
RÈGLES D’ÉCRITURE DES MÉTHODES

Utilisation d’une fonction fournissant un résultat


Point a = new Point(...) ;

double u, r ;

.....

u = 2. * a.distance() ;

r = Math.sqrt( a.getX() * a.getX() + a.getY() * a.getY() );

93
RÈGLES D’ÉCRITURE DES MÉTHODES
Les arguments d’une méthode
les arguments figurant dans l’en-tête de la définition d’une méthode se nomment
arguments muets (ou encore arguments ou paramètres formels)

void f (final int n, double x)


{ .....
n = 12 ; // erreur de compilation
x = 2.5 ; // OK
.....
}
Les arguments fournis lors de l’appel de la méthode portent quant à eux le nom
d’ arguments effectifs (ou encore paramètres effectifs).
Point p = new Point(...) ;
int n1, n2 ; byte b ; long q ;
p.deplace (n1, n2) ; // OK : appel normal
p.deplace (b+3, n1) ; // OK : b+3 est déjà de type int
p.deplace (b, n1) ; // OK : b de type byte sera converti en int
p.deplace (n1, q) ; // erreur : q de type long ne peut être converti en int
94
p.deplace (n1, (int)q) ; // OK
RÈGLES D’ÉCRITURE DES MÉTHODES
Propriétés des variables locales

void F(int n)
{ float x ; // variable locale à F
float n ; // interdit en Java
.....
}
void G ()
{ double x ; // variable locale à G, indépendante de x locale à F
.....
}

95
RÈGLES D’ÉCRITURE DES MÉTHODES
CHAMPS STATIQUES (Champs de classe)

class A a1.n
{ int n ;
float y ; a1.y
}
A a1 = new A(), a2 = new A() ;
a2.n
a2.y

Les champs statiques n’existent qu’en un seul exemplaire, indépendamment de tout objet de la classe.

class B
{ static int n ; B.n
float y ; a1.n a2.n
} a1.y a2.y
B a1 = new B(), a2 = new B() ;
96
RÈGLES D’ÉCRITURE DES MÉTHODES
CHAMPS STATIQUES Exemple
class Obj {
public Obj() { System.out.print ("++ creation objet Obj ; ") ;
nb ++ ;
System.out.println ("il y en a maintenant " + nb) ;
}
private static long nb=0 ;
} Exécution
public class TstObj Main 1
{ public static void main (String args[]) ++ creation objet Obj ; il y en a maintenant 1
{ Obj a ; Main 2
System.out.println ("Main 1") ; Main 3
a = new Obj() ; ++ creation objet Obj ; il y en a maintenant 2
System.out.println ("Main 2") ; ++ creation objet Obj ; il y en a maintenant 3
Obj b ; Main 4
System.out.println ("Main 3") ;
b = new Obj() ;
Obj c = new Obj() ;
System.out.println ("Main 4") ;
}
} 97
RÈGLES D’ÉCRITURE DES MÉTHODES
METHODES STATIQUES (Méthodes de classe)
une méthode de classe ne pourra en aucun cas agir sur des champs usuels (non statiques)

class A
{ .....
private float x ; // champ usuel
private static int n ; // champ de classe
.....
public static void f() // méthode de classe
{ ..... // ici, on ne peut pas accéder à x, champ usuel,
..... // mais on peut accéder au champ de classe n
}
}
.....
Aa;
A.f() ; // appelle la méthode de classe f de la classe A
a.f() ; // reste autorisé, mais déconseillé
98
METHODES STATIQUES (Méthodes de classe) Exemple
class Obj
{ public Obj()
{ System.out.print ("++ creation objet Obj ; ") ;
nb ++ ;
System.out.println ("il y en a maintenant " + nb) ;
} Main 1 : nb objets = 0
public static long nbObj () ++ creation objet Obj ; il y en a maintenant 1
{ return nb ; } Main 2 : nb objets = 1
private static long nb=0 ; Main 3 : nb objets = 1
} ++ creation objet Obj ; il y en a maintenant 2
public class TstObj2 ++ creation objet Obj ; il y en a maintenant 3
{ public static void main (String args[]) Main 4 : nb objets = 3
{ Obj a ;
System.out.println ("Main 1 : nb objets = " + Obj.nbObj() ) ;
a = new Obj() ;
System.out.println ("Main 2 : nb objets = " + Obj.nbObj() ) ;
Obj b ;
System.out.println ("Main 3 : nb objets = " + Obj.nbObj() ) ;
b = new Obj() ;
Obj c = new Obj() ;
System.out.println ("Main 4 : nb objets = " + Obj.nbObj() ) ;
} 99
}
RÈGLES D’ÉCRITURE DES MÉTHODES
initialisation des champs statiques

class A
{ .....
public static void f() ; A a ; // aucun objet de type A n’est encore créé, les champs statiques
..... // de A sont intialisés : p (implicitement) à 0, n (explicitement) à 10
private static int n = 10 ;
private static int p ; A.f() ; // initialisation des statiques de A, si pas déjà fait
}

Bloc d’initialisation statique class A


{ private static int t[] ;
.....
static { .....
int nEl = Clavier.lireInt() ;
t = new int[nEl] ;
for (int i=0 ; i<nEl ; i++) t[i] = i ;
}
.....
} 100
SURDEFINITION DE MÉTHODES
class Point
{ public Point (int abs, int ord) // constructeur
{ x = abs ; y = ord ;
}
public void deplace (int dx, int dy) // deplace (int, int)
{ x += dx ; y += dy ;
}
public void deplace (int dx) // deplace (int)
{ x += dx ;
public class Surdef1
}
{ public static void main (String args[])
public void deplace (short dx) // deplace (short)
{ Point a = new Point (1, 2) ;
{ x += dx ;
a.deplace (1, 3) ; // appelle deplace (int, int)
}
a.deplace (2) ; // appelle deplace (int)
private int x, y ;
short p = 3 ;
}
a.deplace (p) ; // appelle deplace (short)
Rq : byte b = 2 ;
Le type de la valeur de retour d’une a.deplace (b) ; // appelle deplace (short) apres
méthode n’intervient pas dans le choix //conversion de b en short
d’une méthode surdéfinie }
101
}
SURDEFINITION DE MÉTHODES
class Point
{
CAS DU CONSTRUCTEUR
public Point () // constructeur 1 (sans argument)
{x=0; y=0;
}
public Point (int abs) // constructeur 2 (un argument)
{ x = y = abs ;
}
public Point (int abs, int ord ) // constructeur 3 (deux arguments)
{ x = abs ; y = ord ;
} public class Surdef2
public void affiche () { public static void main (String args[])
{ System.out.println ("Coordonnees : " + x + " " + y) ; { Point a = new Point () ; // appelle constructeur 1
} a.affiche() ;
private int x, y ; Point b = new Point (5) ; // appelle constructeur 2
} b.affiche() ;
Point c = new Point (3, 9) ; // appelle constructeur 3
Coordonnees : 0 0 c.affiche() ;
Coordonnees : 5 5 }
Coordonnees : 3 9 }
102
ECHANGE D’INFORMATIONS AVEC LES MÉTHODES
class Util
{ public static void Echange (int a, int b) // ne pas oublier static
{ System.out.println ("début Echange : " + a + " " + b) ;
int c ;
c=a;a=b;b=c;
System.out.println ("fin Echange : " + a + " " + b) ;
}
}
public class Echange
{ public static void main (String args[]) avant appel : 10 20
{ int n = 10, p = 20 ; début Echange : 10 20
System.out.println ("avant appel : " + n + " " + p) ; fin Echange : 20 10
Util.Echange (n, p) ; après appel : 10 20
System.out.println ("après appel : " + n + " " + p) ;
}
}

la transmission des types primitifs, se fait par valeur.


103
ECHANGE D’INFORMATIONS AVEC LES MÉTHODES
Cas des objets transmis en argument
Problème :
Ecrire un programme qui vérifie si deux points coïncident.
class Point
{ public Point(int abs, int ord)
{ x = abs ; y = ord ; }
public boolean coincide (Point pt)
{ return ((pt.x == x) && (pt.y == y)) ;
}
private int x, y ;
} a et b : false false
public class Coincide a et c : true true
{ public static void main (String args[]) On dit que l’unité d’encapsulation est la classe non l’objet
{ Point a = new Point (1, 3) ;
Point b = new Point (2, 5) ;
Point c = new Point (1,3) ;
System.out.println ("a et b : " + a.coincide(b) + " " + b.coincide(a)) ;
System.out.println ("a et c : " + a.coincide(c) + " " + c.coincide(a)) ;
}
} 104
ECHANGE D’INFORMATIONS AVEC LES MÉTHODES
Cas des objets transmis en argument
Problème :
Ecrire un programme qui vérifie si deux points coïncident.
class Point
{ public Point(int abs, int ord)
{ x = abs ; y = ord ; }
public boolean coincide (Point pt)
Bien((pt.xentendu,
{ return == x) && (pt.ylorsqu’une
== y)) ; méthode d’une classe T reçoit
}
en argument un objet de classe T’, différente de T, elle n’a
private int x, y ;
} pas accès aux champs ou méthodes a et bprivées
: false false de cet objet.
public class Coincide a et c : true true
{ public static void main (String args[]) On dit que l’unité d’encapsulation est la classe non l’objet
{ Point a = new Point (1, 3) ;
Point b = new Point (2, 5) ;
Point c = new Point (1,3) ;
System.out.println ("a et b : " + a.coincide(b) + " " + b.coincide(a)) ;
System.out.println ("a et c : " + a.coincide(c) + " " + c.coincide(a)) ;
}
} 105
ECHANGE D’INFORMATIONS AVEC LES MÉTHODES
Cas des objets transmis en argument
class Point
{ Conséquences de la transmission de la référence d’un objet
public Point(int abs, int ord)
{ x = abs ; y = ord ;
}
public void permute (Point a) // methode d’Echange les coordonnées du point courant avec
a
{ Point c = new Point(0,0) ;
c.x = a.x ; c.y = a.y ; // copie de a dans c
a.x = x ; a.y = y ; // copie du point courant dans a
x = c.x ; y = c.y ; // copie de c dans le point courant
} public class Permute
public void affiche () { public static void main (String args[])
{ System.out.println ("Coordonnées : " + x + " " + y) ; { Point a = new Point (1, 2) ;
} Point b = new Point (5, 6) ;
private int x, y ; a.affiche() ; b.affiche() ;
} a.permute (b) ;
Coordonnées : 1 2
a.affiche() ; b.affiche() ;
Coordonnées : 5 6
Coordonnées : 5 6
}
Coordonnées : 1 2 } 106
ECHANGE D’INFORMATIONS AVEC LES MÉTHODES
Cas de la valeur de retour
class Point
{
public Point(int abs, int ord) public class Sym
{ x = abs ; y = ord ; { public static void main (String args[])
} { Point a = new Point (1, 2) ;
public Point symetrique() a.affiche() ;
{ Point res ; Point b = a.symetrique() ;
res = new Point (y, x) ; b.affiche() ;
return res ; }
} }
public void affiche () Coordonnées : 1 2
{ System.out.println ("Coordonnees : " + x + " " + y) ; Coordonnées : 2 1
}
private int x, y ;
}

Dans ce cas, la fonction fournit une copie de la référence à l’objet concerné.


107
ÉCHANGE D’INFORMATIONS AVEC LES MÉTHODES
Cas de la valeur de retour
class Point
{
public Point(int abs, int ord)
{ x = abs ; y = ord ; public class Sym
} { public static void main (String args[ ])
public Point symetrique() { Point a = new Point (1, 2) ;
{ Point res ; a.affiche() ;
res = new Point (y, x) ; Point b = a.symetrique() ;
return res ; b.affiche() ;
} }
public void affiche () }
{ System.out.println ("Coordonnees : " + x + " " + y) ;
} Coordonnees : 1 2
private int x, y ; Coordonnees : 2 1
}
On reçoit toujours la copie de la valeur fournie par une méthode. Dans ce cas, elle
fournit une copie de la référence à l’objet concerné (res). 108
ÉCHANGE D’INFORMATIONS AVEC LES MÉTHODES
Autoréférence : le mot-clé this
public boolean coincide (Point pt)
{ return ((pt.x == this.x) && (pt.y == this.y)) ;
}

public Point(int x, int y) // notez les noms des arguments muets ici
{ this.x = x ; // ici x désigne le premier argument de Point
// le champ x de l’objet courant est masqué ; mais
// on peut le nommer this.x
this.y = x ;
}

109
EXERCICE 1
• Modéliser un cercle par les coordonnées de son centre et par son
rayon.
• Prévoir un constructeur sans paramètres qui initialise tous les
champs à 0.
• Prévoir un constructeur avec trois paramètres pour initialiser tous
les attributs.
• Prévoir une méthode pour afficher les valeurs des attributs.
• Prévoir une méthode pour calculer le périmètre d’un cercle.
• Prévoir une méthode pour calculer la surface d’un cercle.
• Donner des exemples d’utilisation de cercle

Proposer une modélisation d’une autre forme géométrique!


Triangle, rectangle, losange, sph 110
class Cercle {
public Cercle() {
x=0;
y=0;
r=0;
}
public Cercle(int a, int b, int c) {
x=a;
y=b;
r=c;
}
public void affiche(){
System.out.println(" Mon centre se trouve à "+x+ " , "+y+" et mon rayon est de : "+r);}

public double perimetre(){ return (2*Pi*r); }


public double superficie(){ return (Pi*r*r); }
private int x;
private int y;
private int r;
final double Pi = 3.14;
} 111
public class TestCercle {
public static void main(String args []){
Cercle C1;
C1 = new Cercle(2,6,7);
C1.affiche();
System.out.println("perimetre = "+ C1.perimetre());
System.out.println("superficie = "+ C1.superficie());

}
}

112
EXERCICE 2
• Modéliser un nombre complexe (Z=a+ ib)
• Prévoir un constructeur sans paramètres qui initialise la partie
imaginaire et la partie réelle à 0.
• Prévoir un constructeur avec un seul paramètre qui initialise la partie
imaginaire et la partie réelle à la même valeur.
• Prévoir un constructeur avec deux paramètres qui initialise la partie
imaginaire et la partie réelle.
• Prévoir les accesseurs et les mutateurs.
• Prévoir une méthode qui renvoie le module d’un nombre complexe
|Z|= 𝑎 2 + 𝑏 2
• Dans le programme principal, créer des nombres complexes, et
calculer
• La somme de deux complexes,
• Le produit de deux complexes 113
class Complexe {
public Complexe(){
a =0;
b = 0;
}
public Complexe(double m){
a =m;
b = m;
}
public Complexe(double m, double n){
a = m;
b = n;
}
public void setA(double x) { a = x; }
public void setB(double x) { b = x; }
public double getA() { return a; }
public double getB() { return b; }
public double module() { return (Math.sqrt(a*a + b*b)); }
private double a;
private double b;
} 114
public class TestComplexe {
public static void main(String args [] ){
Complexe A = new Complexe();
A.setA(2.6);
A.setB(9.21);
System.out.println("Mon module est : "+A.module());
Complexe B= new Complexe(8);
Complexe Z = new Complexe();
Z.setA(A.getA()+B.getA());
Z.setB(A.getB()+B.getB());
System.out.println("Le module de Z est : "+Z.module());
// je vous laisse le soin de faire la multiplication

}
}

115
EXERCICE 3
• Modéliser un élève qui est caractérisé par son nom, son âge
sa note max sa note min et sa moyenne.
• Prévoir un constructeur avec paramètres qui initialise les
attributs nom et âge et qui met la moyenne à 0.
• Prévoir les accesseurs et les mutateurs
• Prévoir une méthode ayant comme paramètre le nombre de
matières, la fonction demande la note de chaque matière et
initialise la note max la note min et la moyenne.
• Donner des exemples d’utilisation.

116
LA RÉCURSIVITÉ DES MÉTHODES

F1() {
La récursivité directe F1();
}

F2() { F3() {
La récursivité croisée F2();
F3();
} }

Ecrire un programme qui permet de calculer la factorielle d’un nombre


en utilisant une fonction récursive.

117
LA RÉCURSIVITÉ DES MÉTHODES
Ecrire un programme qui permet de calculer la factorielle d’un nombre
en utilisant une fonction récursive.
class Util
{ public static long fac (long n)
{ if (n>1) return (fac(n-1) * n) ;
else return 1 ;
}
}
public class TstFac
{ public static void main (String [ ] args)
{ int n ;
System.out.print ("donnez un entier positif : ") ;
n = Clavier.lireInt() ;
System.out.println ("Voici sa factorielle : " + Util.fac(n) ) ;
}
} 118
LES OBJETS MEMBRES

Soit la classe point :

class Point
{ public Point(int x, int y) // constructeur
{ this.x = x ;
this.y = y ;
}
public void affiche()
{ System.out.println ("Je suis un point de coordonnées " + x + " " + y) ;
}
private int x, y ;
}

On souhaite modéliser un cercle par son centre et son rayon !!


119
LES OBJETS MEMBRES
class Point
{ public Point(int x, int y)
{ this.x = x ;
this.y = y ;
}
public void affiche()
{ System.out.println ("Je suis un point de coordonnées " + x + " " + y) ;
}
private int x, y ; On souhaite modéliser un cercle par son centre et son rayon!!
}
class Cercle {
public Cercle (int x, int y, float r) { ..... } // constructeur
public void affiche() { ..... }
public void deplace (int dx, int dy) { ..... } // //
private Point c ; // centre du cercle
private float r ; // rayon du cercle
}
120
LES OBJETS MEMBRES
class Cercle {
public Cercle (int x, int y, float r) { ..... } // constructeur
public void affiche() { ..... }
public void deplace (int dx, int dy) { ..... }
private Point c ; // centre du cercle
private float r ; // rayon du cercle
}

public Cercle (int x, int y, float r)


{ c = new Point (x, y) ;
this.r = r ;
}
public void affiche()
{ System.out.println ("Je suis un cercle de rayon " + r ) ;
System.out.print (" et de centre ") ;
c.affiche() ;
}
121
LES OBJETS MEMBRES
class Cercle {
public Cercle (int x, int y, float r) { ..... } // constructeur
public void affiche() { ..... }
public void deplace (int dx, int dy) { ..... }
private Point c ; // centre du cercle
private float r ; // rayon du cercle
} public void affiche()
public Cercle (int x, int y, float r)
{ System.out.println ("Je suis un cercle de rayon " + r ) ;
{ c = new Point (x, y) ;
System.out.print (" et de centre ") ;
this.r = r ;
c.affiche() ;
}
}

void deplace (int dx, int dy)


{ c.x += dx ; // x n’est pas un champ public de la classe Point ;
// on ne peut donc pas accéder à c.x
c.y += dy ; // idem
}

122
LES OBJETS MEMBRES
class Cercle {
public Cercle (int x, int y, float r) { ..... } // constructeur
public void affiche() { ..... }
public void deplace (int dx, int dy) { ..... }
private Point c ; // centre du cercle
private float r ; // rayon du cercle
} public void affiche()
public Cercle (int x, int y, float r)
{ System.out.println ("Je suis un cercle de rayon " + r ) ;
{ c = new Point (x, y) ;
System.out.print (" et de centre ") ;
this.r = r ;
c.affiche() ;
}
}

void deplace (int dx, int dy)


{ c.x += dx ; // x n’est pas un champ public de la classe Point ;
// on ne peut donc pas accéder à c.x
c.y += dy ; // idem
}
Pour pouvoir réaliser deplace(), il faudrait que la classe Point dispose :
• soit d’une méthode de déplacement d’un point,
• soit de méthodes d’accès et de méthodes d’altération. (les accesseurs) 123
LES OBJETS MEMBRES – SOLUTION-
class Point
{ public Point(int x, int y)
{ this.x = x ; this.y = y ;
}
public void affiche()
{ System.out.println ("Je suis un point de coordonnees " + x + " " + y) ;
}
public int getX() { return x ; }
public int getY() { return y ; }
public void setX (int x) { this.x = x ; }
public void setY (int y) { this.y = y ; }
private int x, y ;
}

124
LES OBJETS MEMBRES – SOLUTION- SUITE
class Cercle
{ public Cercle (int x, int y, float r)
{ c = new Point (x, y) ;
this.r = r ;
}
public void affiche()
{ System.out.println ("Je suis un cercle de rayon " + r) ;
System.out.println(" et de centre de coordonnées "
+ c.getX() + " " + c.getY()) ;
}
public void deplace (int dx, int dy)
{ c.setX (c.getX() + dx) ; c.setY (c.getY() + dy) ;
}
private Point c ; // centre du cercle
private float r ; // rayon du cercle
} 125
LES OBJETS MEMBRES – SOLUTION- SUITE
public class TstCerc
{ public static void main (String args[])
{ Point p = new Point (3, 5) ; p.affiche() ;
Cercle c = new Cercle (1, 2, 5.5) ; c.affiche();
}
}
Je suis un point de coordonnées 3 5
Je suis un cercle de rayon 5.5
et de centre de coordonnées 1 2

La situation d’objet membre correspond à ce qu’on


nomme généralement la relation (appartenance).
126
LES CLASSES INTERNES
Imbrication de définitions de classe
Une classe est dite interne lorsque sa définition est située à l’intérieur
de la définition d’une autre classe.
• La notion de classe interne correspond à cette situation
class E // définition d’une classe usuelle (dite alors externe)
{ ..... // méthodes et données de la classe E
class I // définition d’une classe interne à la classe E
{ ..... // méthodes et données de la classe I
}
..... // autres méthodes et données de la classe E
}
127
LES CLASSES INTERNES
Imbrication de définitions de classe
La définition de I est utilisable au sein de la définition de E,
class E
{ public void fe() // méthode de E
{ I i = new I() ; // création d’un objet de type I ; sa
//référence est ici locale à la méthode fe
}
class I
{ ..... }
.....
private I i1, i2 ; // les champs i1 et i2 de E sont des
//références à des objets de type I
} 128
LES CLASSES INTERNES
Imbrication de définitions de classe
Lien entre objet interne et objet externe
1. Un objet d’une classe interne est toujours associé, au moment de son
instanciation, à un objet d’un classe externe dont on dit qu’il lui a donné
naissance.

2. Un objet d’une classe interne a toujours accès aux champs et méthodes


(même privés) de l’objet externe lui ayant donné naissance (attention : ici, il
s’agit bien d’un accès restreint à l’objet, et non à tous les objets de cette
classe).

3. Un objet de classe externe a toujours accès aux champs et méthodes


(même privés) d’un objet d’une classe interne auquel il a donné naissance.
129
class E Exemple
{ public void E()
{ i1 = new I() ; }
public void fe()
{ i2 = new I() ; }
public void g ()
{ ..... // ici, on peut accéder non seulement à i1 et i2, mais aussi à i1.ni ou i2.ni
}
class I
{ .....
private int ni ;
}
private I i1, i2 ; // les champs i1 et i2 de E sont des références à des objets de type I
}
.....
E e1 = new E() ; // ici, le constructeur de e1 crée un objet de type I associé à e1 et place sa
//référence dans e1.i1 (ici privé)
E e2 = new E() ; // ici, le constructeur de e2 crée un objet de type I associé à e1 et place sa
//référence dans e2.i1 (ici privé)
e1.fe() ; // la méthode fe crée un objet de type I associé à e1 et place sa référence dans130e1.i2
LES PAQUETAGES

• La notion de paquetage correspond à un regroupement


logique sous un identificateur commun d’un ensemble de
classes. Elle est proche de la notion de bibliothèque que
l’on rencontre dans d’autres langages (C ou C++).
• Elle facilite le développement et la cohabitation de logiciels
conséquents en permettant de répartir les classes
correspondantes dans différents paquetages.
• Le risque de créer deux classes de même nom se trouve
alors limité aux seules classes d’un même paquetage.

131
LES PAQUETAGES
Attribution d’une classe à un paquetage
• Un paquetage est caractérisé par un nom qui est soit un simple
identificateur, soit une suite d’identificateurs séparés par des
points, comme dans :

MesClasses

Utilitaires.Mathematiques

Utilitaires.Tris

132
LES PAQUETAGES
Attribution d’une classe à un paquetage
• L’attribution d’un nom de paquetage se fait au niveau du fichier source
; toutes les classes d’un même fichier source appartiendront donc
toujours à un même paquetage.
• Pour ce faire, on place, en début de fichier, une instruction de la forme
:
package xxxxxx ;

• La notion de paquetage est une notion " logique "


Utilitaires.Tris ≠ Utilitaires.Mathematiques ≠ Utilitaires

133
LES PAQUETAGES
Utilisation d’une classe d’un paquetage
• Lorsque, dans un programme, vous faites référence à une
classe, le compilateur la recherche dans le paquetage par
défaut.
Pour ce faire, vous pouvez :
1. • citer le nom du paquetage avec le nom de la classe,
2. • utiliser une instruction import en y citant une classe
particulière d’un paquetage,
3. • utiliser une instruction import en y citant tout un
paquetage.

134
LES PAQUETAGES
Utilisation d’une classe d’un paquetage
1. En citant le nom de la classe
Si vous avez attribué à la classe Point le nom de paquetage
MesClasses par exemple, vous pourrez l’utiliser simplement en la
nommant MesClasses.Point
Par exemple :
MesClasses.Point p = new MesClasses.Point (2, 5) ;
• .....
• p.affiche() ; // ici, le nom de paquetage n’est pas requis

135
LES PAQUETAGES
Utilisation d’une classe d’un paquetage
2. En important une classe
• L’instruction import vous permet de citer le nom (complet) d’une
ou plusieurs classes, par exemple :
• import MesClasses.Point, MesClasses.Cercle ;

136
LES PAQUETAGES
Utilisation d’une classe d’un paquetage
3. En important un paquetage
import MesClasses.* ;

De cette façon on peut utiliser toutes les classes du paquetage.

137
LES PAQUETAGES STANDARD

Les nombreuses classes standard avec lesquelles Java est fourni


sont structurées en paquetages.
par exemple
java.awt, java.awt.event, javax.swing...
Par ailleurs, il existe un paquetage particulier nommé java.lang qui
est automatiquement importé par le compilateur. C’est ce qui permet
d’utiliser des classes standard telles que
Math, System, Float ou Integer, sans avoir à introduire d’instruction
import.
.

138
PAQUETAGES ET DROITS D’ACCÈS
Droits d’accès aux classes
• Chaque classe dispose de ce qu’on nomme un droit d’accès
(on dit aussi un modificateur d’accès). Il permet de décider
quelles sont les autres classes qui peuvent l’utiliser.
• Il est simplement défini par la présence ou l’absence du mot-
clé public
• avec le mot-clé public, la classe est accessible à toutes
les autres classes (moyennant éventuellement le recours
à une instruction import) ;
• sans le mot-clé public, la classe n’est accessible qu’aux
classes du même paquetage.
139
PAQUETAGES ET DROITS D’ACCÈS
Droits d’accès aux membres d’une classe
• Pour un membre on peut utiliser (champ ou méthode) l’un
des attributs public ou private.
• Avec public, le membre est accessible depuis l’extérieur de
la classe ; avec private, il n’est accessible qu’aux méthodes
de la classe.
• En fait, il existe une troisième possibilité, à savoir l’absence
de mot-clé (private ou public). Dans ce cas, l’accès au
membre est limité aux classes du même paquetage (on parle
d’accès de paquetage).

140
• LES TABLEAUX
LES TABLEAUX
Les tableaux sont considérés comme des objets
Ils fournissent des collections ordonnées d’éléments
Les éléments d’un tableau peuvent être
- Des variables d’un type primitif (int, boolean, double, char, …)
- Des références sur des objets

Création d’un tableau :


1 Déclaration = déterminer le type du tableau
2 Dimensionnement = déterminer la taille du tableau
3 Initialisation = initialiser chaque case du tableau
142
LES TABLEAUX
1) Déclaration
La déclaration précise simplement le type des éléments du tableau
int[] monTableau;
/*Peut s’écrire également*/ int monTableau[];
On déclare une variable pour un tableau de type int. Cette variable est une
télécommande pour un objet tableau.
Pour le moment, la variable monTableau ne référence aucun objet, elle est
donc null.

Attention : une déclaration de tableau ne doit pas préciser de


dimensions
int monTableau[5]; // Erreur
143
LES TABLEAUX
2) Dimensionnement
Le nombre d’éléments du tableau sera déterminé quand l’objet tableau
sera effectivement créé en utilisant le mot clé new
La taille déterminée à la création du tableau est fixe, elle ne pourra plus
être modifiée par la suite
La création d’un tableau par new :
- Alloue la mémoire en fonction du type de tableau et de la taille
- Initialise le contenu du tableau à 0 pour les types simples
int[] monTableau; // Déclaration
monTableau = new int[3]; // Dimensionnement
On crée un nouveau tableau d’entiers de 3 éléments et on l’affecte à la
variable monTableau.
144
LES TABLEAUX
3) Initialisation
L’accès à un élément d’un tableau s’effectue suivant
cette forme :
monTableau[varInt]; // 0 <= varInt <monTableau.length

• monTableau.length nous donne la taille du tableau, dans


notre cas 3.
• Le premier élément du tableau commence toujours à
l’indice 0, et le dernier élément du tableau correspond à
l’indice tailleDuTableau – 1
• Java vérifie automatiquement l’indice lors de l’accès
(pendant l’exécution du programme et non lors de la
compilation )

145
EXERCICES
Exercice 1
Ecrire un programme qui permet de gérer un tableau; votre programme doit
prévoir entre autre des fonctions qui permettent de :
• Lire le nombre d’éléments d ’un tableau
• Saisir les éléments du tableau
• Trier le tableau par l’ordre indiqué par l’utilisateur
• Retourner la plus grande valeur et la plus petite valeur du tableau
• Retourner l’indice d’une valeur indiquée par l’utilisateur
• Retourner le nombre d’occurrences d’une valeur indiquée par l’utilisateur
EXERCICES
Exercice 2
Ecrire un programme qui permet de modéliser une pile d’entier par une classe. Les
éléments de la pile seront conservés dans un tableau. La classe comportera les
fonctions membres suivantes:
• Un constructeur sans paramètre allouant un emplacement pour 20 entiers
• Un constructeur avec un seul paramètre allouant n emplacements
• Une fonction pour empiler un entier dans la pile [ void empile(int ); ]
• Une fonction pour dépiler un entier de la pile [ int depile( ); ] . Cette fonction
retourne la valeur de l’élément situé en haut de la pile en le supprimant de la pile.
• Une fonction [ boolean pleine( ); ] qui retourne true si la pile est pleine et false
sinon.
• Une fonction [ boolean vide( ); ] qui retourne true si la pile est vide et false sinon.
Donner un exemple d’instanciation et de manipulation de pile.
EXERCICES
Exercice 2

public class Pile {


public pile() { ….. .}
public pile (int n) {…….}
public void empile (int e) {…….}
public int depile () {………}
public boolean pleine() {………}
public boolean vide() {………}

private int nbr_elem;


…….
}
EXERCICES
Exercice 3
Reprendre l’exercice 2 avec une pile de points:
• Un constructeur sans paramètre allouant un emplacement pour 20 points
• Un constructeur avec un seul paramètre allouant n emplacements
• Une fonction pour empiler un point dans la pile [ void empile(point ); ]
• Une fonction pour dépiler un point de la pile [ point depile( ); ] . Cette fonction
retourne la valeur de l’élément situé en haut de la pile en le supprimant de la pile.
• Une fonction [ boolean pleine( ); ] qui retourne true si la pile est pleine et false
sinon.
• Une fonction [ boolean vide( ); ] qui retourne true si la pile est vide et false sinon.
Donner un exemple d’instanciation et de manipulation de pile de points.
EXERCICES
Exercice 3

public class Pile {


public pile() { ….. .}
public pile (int n) {…….}
public void empile (point p) {…….}
public point depile () {………}
public boolean pleine() {………}
public boolean vide() {………}

private int nbr_elem;


…….
}
HÉRITAGE
Héritage

NOTION D’HÉRITAGE

Imaginons le schéma suivant

Point
int abs
PointCol
int ord
void afficher(); int couleur;
void intialise (int x, int y);
void deplacer (int x, int dy);

152
Héritage
Point
int abs

NOTION D’HÉRITAGE
PointCol
int ord
void afficher(); int couleur;
void intialise (int x, int y);
void deplacer (int x, int dy);

En Java
// classe de base
class Point
{ public void initialise (int abs, int ord)
{ x = abs ; y = ord ; }
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; }
public void affiche ()
{ System.out.println ("Je suis en " + x + " " + y) ; }
private int x, y ; // classe derivée de Point
} class Pointcol extends Point
{ public void colore (byte couleur)
{ this.couleur = couleur ; }
private byte couleur ;
} 153
Héritage
Point
int abs

NOTION D’HÉRITAGE
PointCol
int ord
void afficher(); int couleur;
void intialise (int x, int y);
void deplacer (int x, int dy);

Utilisation des deux classes

// classe utilisant Pointcol


public class TstPcol1
{ public static void main (String args[])
{ Pointcol pc = new Pointcol() ;
pc.affiche() ; un objet d’une classe dérivée accède aux
pc.initialise (3, 5) ; membres publics de sa classe de base,
pc.colore ((byte)3) ;
pc.affiche() ;
pc.deplace (2, -1) ; Je suis en 0 0
pc.affiche() ; Je suis en 3 5
Point p = new Point() ; p.initialise (6, 9) ; Je suis en 5 4
p.affiche() ; Je suis en 6 9
}
}
154
Héritage
Point
int abs
PointCol

NOTION D’HÉRITAGE
int ord
void afficher(); int couleur;
void intialise (int x, int y);
void deplacer (int x, int dy);

• Accès d’une classe dérivée aux membres de sa classe de base


Une classe dérivée n’accède pas aux membres privés
void affichec() // méthode affichant les coordonnees et la couleur
{ System.out.println ("Je suis en " + x + " " + y) ; // NON : x et y sont privés
System.out.println (" et ma couleur est : " + couleur) ;
}
Elle accède aux membres publics

public void affichec ()


{ affiche() ; // this.affiche();
System.out.println (" et ma couleur est : " + couleur) ;
}
public void initialisec (int x, int y, byte couleur)
{ initialise (x, y) ;
this.couleur = couleur ;
155
}
Héritage
Point

NOTION D’HÉRITAGE
int abs
PointCol
int ord

int couleur;
void afficher();
void intialise (int x, int y);
void deplacer (int x, int dy);

Construction et initialisation des objets dérivés

En Java, le constructeur de la classe dérivée doit prendre en charge


l’intégralité de la construction de l’objet.
Si un constructeur d’une classe dérivée appelle un constructeur d’une classe de base,
il doit obligatoirement s’agir de la première instruction du constructeur et ce dernier est
désigné par le mot-clé super.

156
Héritage
Point

NOTION D’HÉRITAGE
int abs
PointCol
int ord

int couleur;
void afficher();
void intialise (int x, int y);
void deplacer (int x, int dy);

Construction et initialisation des objets dérivés


class Point
{ public Point (int x, int y)
{ this.x = x ; this.y = y ;
}
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; class Pointcol extends Point
} { public Pointcol (int x, int y, byte couleur)
public void affiche () { super (x, y) ; // obligatoirement comme première instruction
{ System.out.println ("Je suis en " + xthis.couleur
+ " " + y) ; = couleur ;
} }
private int x, y ; public void affichec ()
} { affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
private byte couleur ;
} 157
Héritage
Point

NOTION D’HÉRITAGE
int abs
PointCol
int ord

int couleur;
void afficher();
void intialise (int x, int y);
void deplacer (int x, int dy);

Construction et initialisation des objets dérivés

public class TstPcol3


{ public static void main (String args[])
{ Pointcol pc1 = new Pointcol(3, 5, (byte)3) ;
pc1.affiche() ; // attention, ici affiche
pc1.affichec() ; // et ici affichec
Pointcol pc2 = new Pointcol(5, 8, (byte)2) ; Je suis en 3 5
pc2.affichec() ; Je suis en 3 5
pc2.deplace (1, -3) ; et ma couleur est : 3
pc2.affichec() ; Je suis en 5 8
} et ma couleur est : 2
} Je suis en 6 5
et ma couleur est : 2
158
Héritage

NOTION D’HÉRITAGE
A
Dérivations successives

B C

D E F G

• d’une même classe peuvent être dérivées plusieurs classes différentes,


• les notions de classe de base et de classe dérivée sont relatives puisqu’une classe dérivée
peut, à son tour, servir de classe de base pour une autre.

159
NOTION D’HÉRITAGE Héritage

Redéfinition et surdéfinition de membres


class Point La notion de redéfinition de méthode
{ public Point (int x, int y)
{ this.x = x ; this.y = y ;
}
public void deplace (int dx, int dy)
{ x += dx ; y += dy ; }
public void affiche ()
{ System.out.println ("Je suis en " + x + " " + y) ;
}
private int x, y ;
class Pointcol extends Point
}
{ public Pointcol (int x, int y, byte couleur)
{ super (x, y) ; // obligatoirement comme première instruction
this.couleur = couleur ;
}
public void affiche () // ici redéfinition de la méthode affiche()
{ super.affiche() ; // appel de affiche() de la classe de base
System.out.println (" et ma couleur est : " + couleur) ;
}
private byte couleur ;
} 160
NOTION D’HÉRITAGE Héritage

Redéfinition et surdéfinition de membres


La notion de redéfinition de méthode

public class TstPcol4


{ public static void main (String args[])
{ Pointcol pc = new Pointcol(3, 5, (byte)3) ;
pc.affiche() ; // ici, il s’agit de affiche de Pointcol
pc.deplace (1, -3) ;
pc.affiche() ;
} Je suis en 3 5
} et ma couleur est : 3
Je suis en 4 2
et ma couleur est : 3

161
NOTION D’HÉRITAGE Héritage

Redéfinition et surdéfinition de membres


class A Surdéfinition et héritage
{ .....
public void f (int n) { ..... }
public void f (float x) { ..... }
// Surdéfinition et redéfinition peuvent cohabiter.
}
class B extends A
{ .....
public void f (int n) { ..... } // redéfinition de f(int) de A
public void f (double y) { ..... } // surdéfinition de f (de A et de B)
}
Aa;Bb;
int n ; float x ; double y ;
.....
a.f(n) ; // appel de f(int) de A (mise en jeu de surdéfinition dans A)
a.f(x) ; // appel de f(float) de A (mise en jeu de surdéfinition dans A)
a.f(y) ; // erreur de compilation
b.f(n) ; // appel de f(int) de B (mise en jeu de redéfinition)
b.f(x) ; // appel de f(float) de A (mise en jeu de surdéfinition dans A et B)
b.f(y) ; // appel de f(double) de B (mise en jeu de surdéfinition dans A et B) 162
NOTION D’HÉRITAGE Héritage

Redéfinition et surdéfinition de membres


Contraintes portant sur la redéfinition
Lorsqu’on surdéfinit une méthode, on n’est pas obligé de respecter le type
de la valeur de retour. class A
{ .....
public int f(int n) { .....}
}
class B extends A
{ .....
public float f(float x) { ..... }
}
En revanche, en cas de redéfinition, Java impose non seulement l’identité
des signatures, mais aussi celle du type de la valeur de retour
class A
{ public int f (int n) { ..... }
}
class B extends A
{ public float f (int n) { ..... } // erreur
163
}
NOTION D’HÉRITAGE Héritage

Redéfinition et surdéfinition de membres


Les droits d’accès
La redéfinition d’une méthode ne doit pas diminuer les droits d’accès à
cette méthode. class A
{ public void f (int n) { ..... }
}
class B extends A
{ private void f (int n) { ..... } // tentative de
redéfinition de f de A
}
La redéfinition d’une méthode peut augmenter les droits d’accès à cette
méthode.
class A
{ private void f (int n) { ..... }
}
class B extends A
{ public void f (int n) { ..... } // redéfinition de f avec extension des droits d’accès

} 164
NOTION D’HÉRITAGE Héritage

Duplication de champs
class A
{ public int n ;
.....
}
class B extends A
{ public float n ;
public void f()
{ n = 5.25f ; // n désigne le champ n (float) de B
super.n = 3 ; // tandis que super.n désigne le champ n (int) de la super-classe de B
}
}
Aa;Bb;
a.n = 5 ; // a.n désigne ici le champ n(int) de la classe A
b.n = 3.5f ; // b.n désigne ici le champ n(float) de la classe B

165
Héritage
LE POLYMORPHISME
class Point
{ public Point (int x, int y) { ..... }
public void affiche () { ..... }
}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
public void affiche () { ..... }
}
Point p ;
p = new Point (3, 5) ;

p = new Pointcol (4, 8, (byte)2) ; // p de type Point contient la référence


// à un objet de type Pointcol

166
Héritage
LE POLYMORPHISME
class Point
{ public Point (int x, int y) Exemple complet 1/2
{ this.x = x ; this.y = y ;
}
public void affiche ()
{ System.out.println ("Je suis en " + x + " " + y) ;
}
private int x, y ;
}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
{ super (x, y) ; // obligatoirement comme première instruction
this.couleur = couleur ;
}
public void affiche ()
{ super.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
private byte couleur ;
} 167
Héritage
LE POLYMORPHISME
Exemple complet 2/2
public class TabHeter
{ public static void main (String args[])
{ Point [] tabPts = new Point [4] ;
tabPts [0] = new Point (0, 2) ;
tabPts [1] = new Pointcol (1, 5, (byte)3) ;
tabPts [2] = new Pointcol (2, 8, (byte)9) ;
tabPts [3] = new Point (1, 2) ;
for (int i=0 ; i< tabPts.length ; i++) tabPts[i].affiche() ;
} Je suis en 0 2
} Je suis en 1 5
et ma couleur est : 3
Je suis en 2 8
et ma couleur est : 9
Je suis en 1 2 168
Héritage
LE POLYMORPHISME
Généralisation à plusieurs classes
A*
Seules les classes marquées d’un astérisque
définissent ou redéfinissent une méthode f
B C*

//Avec ces déclarations : D* E F G


Aa;Bb;Cc;Dd;Ee;Ff;
//les affectations suivantes sont légales :
a = b ; a = c ; a = d ; a = e ; a =f ;
b=d;b=e;
//En revanche, celles-ci ne sont pas légales :
b = a ; // erreur : A ne descend pas de B
d = c ; // erreur : C ne descend pas de D
c = d ; // erreur : D ne descend pas de C
169
Héritage
LE POLYMORPHISME
Généralisation à plusieurs classes
A*

Appel de f B C*

D* E F G

a référence un objet de type A : méthode f de A


a référence un objet de type B : méthode f de A
a référence un objet de type C : méthode f de C
a référence un objet de type D : méthode f de D
a référence un objet de type E : méthode f de A
a référence un objet de type G : méthode f de C.
170
Héritage
LA SUPER-CLASSE OBJECT
En JAVA, il existe une classe nommée Object dont dérive
implicitement toute classe simple.
Ainsi, lorsque l’on définisse une classe Point de cette manière :

class Point
{ .....
}

tout se passe en fait comme si l’on avait écrit (On peut d’ailleurs
le faire) :

class Point extends Object


{ .....
} 171
Héritage
LA SUPER-CLASSE OBJECT
Utilisation d’une référence de type Object

Une variable de type Object peut être utilisée pour référencer un


objet de type quelconque :

Point p = new Point (...) ;


Pointcol pc = new Pointcol (...) ;
Fleur f = new Fleur (...) ;
Object o ;
.....
o = p ; // OK
o = pc ; // OK
o = f ; // OK
172
Héritage
LA SUPER-CLASSE OBJECT
Utilisation d’une référence de type Object

Point p = new Point (...) ;


Object o ;
.....
o=p;
o.deplace() ; // erreur de compilation (Object ne contient pas deplace())
((Point)o).deplace() ; // OK en compilation (attention aux parenthèses)
Point p1 = (Point) o ; // OK : idem ci-dessus, avec création d’une référence
p1.deplace() ; // intermédiaire dans p1

173
Héritage
LA SUPER-CLASSE OBJECT
Utilisation de méthodes de la classe Object

La classe Object dispose de quelques méthodes qu’on


peut soit utiliser telles quelles, soit redéfinir. Les plus
importantes sont toString et equals.

174
Héritage
LA SUPER-CLASSE OBJECT
Utilisation de méthodes de la classe Object
La méthode toString
La méthode toString de la classe Object fournit une chaîne contenant :
• le nom de la classe concernée,
• l’adresse de l’objet en hexadécimal (précédée de @).
class Point
{ public Point(int abs, int ord) public class ToString1
{ x = abs ; y = ord ; { public static void main (String args[])
} { Point a = new Point (1, 2) ;
private int x, y ; Point b = new Point (5, 6) ;
} System.out.println ("a = " + a.toString() ) ;
System.out.println ("b = " + b.toString() ) ;
}
a = Point@fc17aedf }
b = Point@fc1baedf 175
Héritage
LA SUPER-CLASSE OBJECT
Utilisation de méthodes de la classe Object
La méthode equals

La méthode equals définie dans la classe Object se contente de


comparer les adresses des deux objets concernés. Ainsi, avec :
Object o1 = new Point (1, 2) ;
Object o2 = new Point (1, 2) ;

L’expression o1.equals(o2) a pour valeur false.


On peut bien sûr redéfinir cette méthode à sa guise dans n’importe
quelle classe. Toutefois, il faudra tenir compte des limitations du
polymorphisme.

176
Héritage
LA SUPER-CLASSE OBJECT
Utilisation de méthodes de la classe Object
La méthode equals
class Point
{ .....
boolean equals (Point p) { return ((p.x==x) && (p.y==y)) ; } // redéfinition
}
Point a = new Point (1, 2) ;
Point b = new Point (1, 2) ;

// l’expression a.equals(b) aura bien sûr la valeur true. En revanche, avec :


Object o1 = new Point (1, 2) ;
Object o2 = new Point (1, 2) ;
/* l’expression o1.equals(o2) aura la valeur false car on aura utilisé la
méthode equals de Object et non celle de Point. */
177
Héritage

LES MEMBRES PROTÉGÉS


Les différents droits d’accès aux membres d’une classe :
public (mot-clé public), privé (mot-clé private), de paquetage (aucune
mention).

Il existe un quatrième droit d’accès dit protégé (mot-clé protected).

Mais, Java le fait intervenir à deux niveaux totalement différents :


• le paquetage de la classe d’une part,
• ses classes dérivées d’autre part.

En effet, un membre déclaré protected est accessible à des classes


du même paquetage, ainsi qu’à ses classes dérivées (qu’elles
appartiennent ou non au même paquetage).
178
Héritage

LES MEMBRES PROTÉGÉS

A
class A
{ .....
protected int n ; B C
}
D

B accède à n de A
D accède à n de B ou de A
C accède à n de A mais pas à n de B ou D

179
Héritage

CAS PARTICULIER DES TABLEAUX


Jusqu’ici, nous avons considéré les tableaux comme des objets.
Cependant, il n’est pas possible de définir exactement leur classe.
En fait les tableaux ne jouissent que d’une partie des propriétés des objets.

1. Un tableau peut être considéré comme appartenant à une classe


dérivée de Object

Object o ;
o = new int [5] ; // correct
.....
o = new float [3] ; // OK

180
Héritage

CAS PARTICULIER DES TABLEAUX


2. Le polymorphisme peut s’appliquer à des tableaux d’objets. Plus
précisément, si B dérive de A , un tableau de B est compatible avec un
tableau de A
class B extends A {……….}
A ta[] ;
B tb[] ;
.....
ta = tb ; // OK car B dérive de A
tb = ta ; // erreur

Malheureusement, cette propriété ne peut pas s’appliquer aux types


primitifs :int ti[] ; float tf[] ;
.....
ti = tf ; // erreur (on s’y attend car float n’est pas compatible avec int)
tf = ti ; // erreur bien que int soit compatible avec float 181
Héritage

CAS PARTICULIER DES TABLEAUX

3. Il n’est pas possible de dériver une classe d’une hypothétique classe


tableau :

class Bizarre extends int [] // erreur

182
Héritage

CLASSES ET MÉTHODES FINALES

Le mot-clé final peut s’appliquer à des variables locales ou à des


champs d’une classe et Il interdit la modification de leur valeur.
Ce mot-clé peut aussi s’appliquer à une méthode ou à une classe,
mais avec une signification totalement différente.

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

Le comportement d’une méthode finale est donc complètement défini


et il ne peut plus être remis en cause, sauf si la méthode appelle elle-
même une méthode qui n’est pas déclarée final.

183
Héritage

CLASSES ET MÉTHODES FINALES

Une classe déclarée final ne peut plus être dérivée.


On pourrait croire qu’une classe finale est équivalente à une classe non
finale dont toutes les méthodes seraient finales.

En fait, ce n’est pas vrai car :


• ne pouvant plus être dérivée, une classe finale ne pourra pas se voir
ajouter de nouvelles fonctionnalités,
• une classe non finale dont toutes les méthodes sont finales pourra
toujours être dérivée, donc se voir ajouter de nouvelles fonctionnalités.

184
Héritage

LES CLASSES ABSTRAITES


1 - Présentation
Une classe abstraite est une classe qui ne permet pas d’instancier des objets. Elle
ne peut servir que de classe de base pour une dérivation. Elle se déclare ainsi :

abstract class A
{ public void f() { ..... } // f est définie dans A
public abstract void g(int n) ; // g n’est pas définie dans A ; on n’en
// a fourni que l’en-tête
}

A a ; // OK : a n’est qu’une référence sur un objet de type A ou dérivé


a = new A(...) ; // erreur : pas d’instanciation d’objets d’une classe abstraite

185
Héritage

LES CLASSES ABSTRAITES


1 - Présentation
abstract class A
{ public void f() { ..... } // f est définie dans A
public abstract void g(int n) ; // g n’est pas définie dans A ; on n’en
// a fourni que l’en-tête
}

class B extends A
{ public void g(int n) { ..... } // ici, on définit g
.....
}

A a = new B(...) ; // OK

186
Héritage

LES CLASSES ABSTRAITES


2 - Quelques règles
R1 Dès qu’une classe comporte une ou plusieurs méthodes abstraites, elle
est abstraite, et ce même si l’on n’indique pas le mot-clé abstract
devant sa déclaration (ce qui reste quand même vivement conseillé).
Ceci est correct :
class A
{ public abstract void f() ; // OK
.....
}
Malgré tout, A est considérée comme abstraite et une expression telle
que new A(...) sera rejetée.

187
Héritage

LES CLASSES ABSTRAITES


2 - Quelques règles
R2 Une méthode abstraite doit obligatoirement être déclarée public, ce
qui est logique puisque sa vocation est d’être redéfinie dans une
classe dérivée.
R3
Dans l’en-tête d’une méthode déclarée abstraite, les noms
d’arguments muets doivent figurer (bien qu’ils ne servent à rien) :

abstract class A
{ public abstract void g(int) ; // erreur : nom d’argument (fictif) obligatoire
}

188
Héritage

LES CLASSES ABSTRAITES


2 - Quelques règles
R4
Une classe dérivée d’une classe abstraite n’est pas obligée de (re)définir
toutes les méthodes abstraites de sa classe de base (elle peut même
n’en redéfinir aucune). Dans ce cas, elle reste simplement abstraite (il est
quant même nécessaire de mentionner abstract dans sa déclaration) :
abstract class A
{ public abstract void f1() ;
public abstract void f2 (char c) ;
.....
}
abstract class B extends A // abstract obligatoire ici
{ public void f1(){………….}; // définition de f1
………. // pas de définition de f2
} 189
Héritage

LES CLASSES ABSTRAITES


2 - Quelques règles
R5

Une classe dérivée d’une classe non abstraite peut être déclarée
abstraite et/ou contenir des méthodes abstraites. Notez que, toutes
les classes dérivant de Object, nous avons utilisé implicitement
cette règle dans tous les exemples précédents.

190
Héritage
Exercice

Forme_Geometrique
Losange - float Surface ;
- float Perim ;
Point s1, s2, s3, s4; + absract void afficher();
+ abstract float Calcul_Surface();
+ abstract float Calcul_perimetre();

Triangle Cercle Rectangle


float base;
int rayon;
float hauteur; Point s1, s2, s3, s4;
Point centre;
Point s1, s2, s3;

191
Héritage

LES INTERFACES

Si l’on considère une classe abstraite n’implantant aucune


méthode et aucun champ (hormis des constantes), on aboutit
à la notion d’interface.
En effet, une interface définit les en-têtes d’un certain nombre
de méthodes, ainsi que des constantes.

192
Héritage

LES INTERFACES
1 - Mise en œuvre d’une interface
1 – 1 Définition d’une interface
On utilise simplement le mot-clé interface à la place de class :
public interface I
{
void f(int n) ; // en-tête d’une méthode f (public abstract facultatifs)
void g() ; // en-tête d’une méthode g (public abstract facultatifs)
}
Dans la définition d’une interface, on ne peut trouver que des en-têtes
de méthodes ou des constantes.
Par essence, les méthodes d’une interface sont abstraites (puisqu’on
n’en fournit pas de définition) et publiques (puisqu’elles devront être
redéfinies plus tard).
193
Héritage

LES INTERFACES
1 - Mise en œuvre d’une interface
1 – 2 Implémentation d’une interface

Lorsqu’on définit une classe, on peut préciser qu’elle implémente une


interface donnée en utilisant le mot-clé implements, comme dans :

class A implements I
{
// A doit (re)définir les méthodes f et g prévues dans l’interface I
}
Ici, on indique que A doit définir les méthodes prévues dans
l’interface I, c’est-à-dire f et g.
194
Héritage

LES INTERFACES
1 - Mise en œuvre d’une interface
1 – 2 Implémentation d’une interface
Une même classe peut implémenter plusieurs interfaces :
public interface I1
{ void f() ;
}
public interface I2
{ int h() ;
}
class A implements I1, I2
{ // A doit obligatoirement définir les méthodes f et h prévues dans
//I1 et I2
} 195
Héritage

LES INTERFACES
2 - Variables de type interface et polymorphisme

public interface I { .....}


.....
I i ; // i est une référence à un objet d’une classe implémentant l’interface I

class A implements I { ..... } // pas de relalion d’héritage


.....
I i = new A(...) ; // OK

196
LES INTERFACES Exemple
Héritage
interface Affichable
{ void affiche() ;
}
class Entier implements Affichable
{ public Entier (int n)
{ valeur = n ;
}
public void affiche()
{ System.out.println ("Je suis un entier de valeur " + valeur) ;
}
class Flottant implements Affichable
private int valeur ;
{ public Flottant (float x)
}
{ valeur = x ;
}
public void affiche()
{ System.out.println ("Je suis un flottant de valeur " + valeur) ;
}
private float valeur ;
} 197
LES INTERFACES Exemple
Héritage

public class Tabhet4


{ public static void main (String[] args)
{ Affichable [] tab ;
tab = new Affichable [3] ;
tab [0] = new Entier (25) ;
tab [1] = new Flottant (1.25f) ;
tab [2] = new Entier (42) ;
int i ;
for (i=0 ; i<3 ; i++)
Je suis un entier de valeur 25
tab[i].affiche() ;
Je suis un flottant de valeur 1.25
}
Je suis un entier de valeur 42
}

Remarque :
les droits d’accès des interfaces sont régis par les mêmes règles
que ceux des classes. 198
Héritage

LES INTERFACES
3 - Interface et classe dérivée
La clause implements est une garantie qu’offre une classe
d’implémenter les fonctionnalités proposées dans une interface. Elle
est totalement indépendante de l’héritage ; autrement dit, une classe
dérivée peut implémenter une interface (ou plusieurs) :
interface I
{ void f(int n) ;
void g() ;
}
class A { ..... }
class B extends A implements I
{ // les méthodes f et g doivent soit être déjà définies dans A,
// soit définies dans B
} 199
Héritage

LES INTERFACES
3 - Interface et classe dérivée

On peut même rencontrer cette situation :

interface I1 { ..... }

interface I2 { ..... }

class A implements I1 { ..... }

class B extends A implements I2 { ..... }

200
Héritage

LES INTERFACES
4 - Interfaces et constantes
une interface peut aussi renfermer des constantes symboliques
qui seront alors accessibles à toutes les classes implémentant
l’interface :
interface I
{ void f(int n) ;
void g() ;
static final int MAXI = 100 ;
}
class A implements I
{ // doit définir f et g
// dans toutes les méthodes de A, on a accès au symbole MAXI :
// par exemple : if (i < MAXI) .....
} 201
Héritage

LES INTERFACES
4 - Interfaces et constantes
une interface peut aussi renfermer des constantes symboliques qui seront alors accessibles à toutes les
classes implémentant l’interface :
interface I
{ void f(int n) ;
void g() ;
static final int MAXI = 100 ;
}
class A implements I
{ // doit définir f et g
// dans toutes les méthodes de A, on a accès au symbole MAXI :
// par exemple : if (i < MAXI) .....
}

Les constantes sont accessibles en dehors d’une classe


implémentant l’interface. Par exemple, la constante MAXI de
l’interface I se notera simplement I.MAXI.

202
Héritage

LES INTERFACES
5 - Dérivation d’une interface

interface I1
La définition de I2 est totalement
{ void f(int n) ; équivalente à :
static final int MAXI = 100 ;
} interface I2
{ void f(int n) ;
interface I2 extends I1 void g() ;
{ void g() ; static final int MAXI = 100 ;
static final int MINI = 20 ; static final int MINI = 20 ;
} }

203
LES CHAÎNES DE CARACTÈRES
ET LES TYPES ÉNUMÉRÉS
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
1 Introduction
Java dispose d’une classe standard nommée String,
permettant de manipuler des chaînes de caractères, c’est-à-
dire des suites de caractères.

String ch ; // ch est une référence sur un objet de type String


ch = "bonjour" ;
bonjour

ch réf

205
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
1 Introduction
La classe String dispose de deux constructeurs, l’un sans argument
créant une chaîne vide, l’autre avec un argument de type String qui en
crée une copie :

String ch1 = new String () ; // ch1 contient la référence à une chaîne vide
String ch2 = new String("hello") ; // ch2 contient la référence à une chaîne
// contenant la suite "hello"
String ch3 = new String(ch2) ; // ch3 contient la référence à une chaîne
// copie de ch2, donc contenant "hello"
hello
ch2 réf
hello
ch3 réf 206
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
2 Un objet de type String n’est pas modifiable

String ch1, ch2, ch ; Ahmad


ch1 = “Ahmad" ; réf
ch1
ch2 = “Khalid" ;
Khalid
ch2 réf

Ahmad
ch = ch1 ; ch1 réf
ch1 = ch2 ; Khalid
ch2 = ch ; ch2 réf

207
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
3 Longueur d’une chaîne : length

String ch = "bonjour" ;
int n = ch.length() ; // n contient 7
ch = "hello" ; n = ch.length () ; // n contient 5
ch = "" ; n = ch.length () ; // n contient 0

Remarque
Contrairement à ce qui se passait pour les tableaux où length désignait
un champ, nous avons bien affaire ici à une méthode.
Les parenthèses à la suite de son nom sont donc indispensables.

208
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
4 Accès aux caractères d’une chaîne : charAt

La méthode charAt de la classe String permet d’accéder à un


caractère de rang donné d’une chaîne (le premier caractère porte
le rang 0).
Ainsi, avec :
String ch = "bonjour" ;
ch.charAt(0) correspond au caractère ’b’,
ch.charAt(2) correspond au caractère ’n’.

209
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
4 Accès aux caractères d’une chaîne : charAt
public class MotCol
{ public static void main (String args[])
{ String mot ;
System.out.print ("donnez un mot : ") ;
mot = Clavier.lireString() ;
System.out.println ("voici votre mot en colonne :") ;
for (int i=0 ; i<mot.length() ; i++) // ou (JDK 5.0) : for (char c : mot)
System.out.println (mot.charAt(i)) ; // System.out.println (c) ;
}
} donnez un mot : Ali
voici votre mot en colonne :
A
l
i 210
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
5 Concaténation de chaînes

String ch1 = "Le langage " ;


String ch2 = " Java" ;
String ch = ch1 + ch2 ;
Le langage
ch1 réf
Java
ch2 réf

le langage Java
ch réf

211
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
5 Concaténation de chaînes
Les instructions suivantes sont aussi autorisées
System.out.println (ch1 + ch2) ;
ch = ch1 + "C++" ;
ch = ch1 + " le plus puissant est : " + ch2 ;

int n = 26 ;
String titre = new String ("résultat : ") ;
String monnaie = "$"
String resul = titre + n + " " + monnaie ;
System.out.println (resul) ; // affichera : résultat : 26 $

212
Chaine de caractères
FONCTIONNALITÉS DE BASE DE LA CLASSE STRING
5 Concaténation de chaînes
Les instructions suivantes sont aussi autorisées

String ch = "bonjour" ;
ch += " monsieur" ; // ch désigne la chaîne "bonjour monsieur"

6 Écriture des constantes chaînes


String ch = "bonjour\nmonsieur" ;
System.out.println (ch) ;
// On aura en exécution
bonjour
monsieur
213
Chaine de caractères
RECHERCHE DANS UNE CHAÎNE

La méthode indexOf surdéfinie dans la classe String permet de


rechercher, à partir du début ne chaîne ou d’une position donnée :
• la première occurrence d’un caractère donné,
• la première occurrence d’une autre chaîne.

Dans tous les cas, elle fournit :


• la position du caractère (ou du début de la chaîne recherchée) si une
correspondance a effectivement été trouvée,
• la valeur -1 sinon.

Il existe également une méthode lastIndexOf, surdéffinie pour effectuer


les mêmes recherches que indexOf, mais en examinant la chaîne
depuis sa fin.
214
Chaine de caractères
RECHERCHE DANS UNE CHAÎNE

Exemple

String mot = "anticonstitutionnellement" ;


int n ;
n = mot.indexOf (’t’) ; // n vaut 2
n = mot.lastIndexOf (’t’) ; // n vaut 24
n = mot.indexOf ("ti") ; // n vaut 2
n = mot.lastIndexOf ("ti") ; // n vaut 12
n = mot.indexOf (’x’) ; // n vaut -1

215
Chaine de caractères
COMPARAISONS DE CHAÎNES

La méthode equals
La classe String dispose d’une méthode quals qui compare
le contenu de deux chaînes

String ch1 = "hello" ;


String ch2 = "bonjour" ;
.....
ch1.equals(ch2) // cette expression est fausse
ch1.equals("hello") // cette expression est vraie

216
Chaine de caractères
COMPARAISONS DE CHAÎNES

La méthode equalsIgnoreCase
La méthode equalsIgnoreCase effectue la même comparaison,
mais sans distinguer les majuscules des minuscules :

String ch1 = "HeLlo" ;


String ch2 = "hello" ;
.....
ch1.equalsIgnoreCase(ch2) // cette expression est vraie
ch1.equalsIgnoreCase("hello") // cette expression est vraie

217
Chaine de caractères
COMPARAISONS DE CHAÎNES

La méthode compareTo

La méthode compareTo s’utilise ainsi :


chaîne1.compareTo(chaîne2)
Elle fournit :
• un entier négatif si chaîne1 arrive avant chaîne2,
• un entier nul si chaîne1 et chaîne2 sont égales
(on a alors chaîne1.equals(chaîne2)),
• un entier positif si chaîne1 arrive après chaîne2.

218
Chaine de caractères
MODIFICATION DE CHAÎNES

Remplacement de caractères
La méthode replace crée une chaîne en remplaçant toutes les occurrences d’un caractère
donné par un autre.
Par exemple :
String ch = "bonjour" ;
String ch1 = ch.replace(’o’, ’a’) ; // ch n’est pas modifiée
// ch1 contient "banjaur"
Passage en majuscules ou en minuscules
La méthode toLowerCase crée une nouvelle chaîne en remplaçant toutes les majuscules par leur
équivalent en minuscules (lorsque celui-ci existe. La méthode toUpperCase crée une nouvelle
chaîne en remplaçant toutes les minuscules par leur équivalent en majuscules.
String ch = "LanGaGE_3" ;
String ch1 = ch.toLowerCase() ; // ch est inchangée
// ch1 contient "langage_3"
String ch2 = ch.toUpperCase() ; // ch n’est pas modifiée
// ch2 contient "LANGAGE_3"

219
Chaine de caractères
MODIFICATION DE CHAÎNES

Extraction de sous-chaîne

La méthode substring permet de créer une nouvelle chaîne en extrayant de la


chaîne courante :
• soit tous les caractères depuis une position donnée,
String ch = "anticonstitutionnellement" ;
String ch1 = ch.substring (5) ; // ch n’est pas modifiée
// ch1 contient "onstitutionnellement"
• soit tous les caractères compris entre deux positions données (la première
incluse, la seconde exclue) :
String ch = "anticonstitutionnellement" ;
String ch1 = ch.substring (4, 16) ; // ch n’est pas modifiée
// ch1 contient "constitution"

220
Chaine de caractères
TABLEAUX DE CHAÎNES
On peut former des tableaux avec des éléments de n’importe quel type, y
compris de type classe, donc en particulier des tableaux de chaînes.
public class TriCh
{ public static void main (String args[])
{ String tabCh [] = {"java", "c", "pascal", "c++", "ada", "basic", "fortran" } ;
String temp ; // pour l’Echange de deux references
int i, j ; chaines triees :
int nbCh = tabCh.length ; ada
for (i=0 ; i<nbCh-1 ; i++)
for (j=i ; j<nbCh ; j++)
basic
if ( (tabCh[i].compareTo(tabCh[j])) > 0) c
{ temp = tabCh [i] ; c++
tabCh [i] = tabCh [j] ; fortran
tabCh [j] = temp ; java
}
System.out.println ("chaines triees : ");
pascal
for (i=0 ; i<nbCh ; i++) System.out.println (tabCh[i]) ;
}
} 221
Chaine de caractères
CONVERSIONS ENTRE CHAÎNES ET TYPES PRIMITIFS
1 Conversion d’un type primitif en une chaîne
int n = 427 ;
String ch = String.valueOf(n) ; // fournit une chaîne obtenue par formatage
// de la valeur contenue dans n, soit ici "427"

double x = 3.5 ;
String ch = String.valueOf(x) ; // fournit une chaîne obtenue par formatage
// de la valeur contenue dans x, soit ici "3.5"

La méthode valueOf peut recevoir un argument de type


quelconque, y compris objet.

222
Chaine de caractères
CONVERSIONS ENTRE CHAÎNES ET TYPES PRIMITIFS
2 Les conversions d’une chaîne en un type primitif

String ch = "3587" ;
int n = Integer.parseInt(ch) ;

D’une manière générale, on dispose des méthodes suivantes :


• Byte.parseByte,
• Short.parseShort,
• Integer.parseInt, Remarque :
• Long.parseLong, "3." convient pour un float, pas pour un int,
"34é3" conduira toujours à une erreur,
• Float.parseFloat,
• Double.parseDouble.
223
Chaine de caractères
CONVERSIONS ENTRE CHAÎNES ET TABLEAUX DE CARACTÈRES

char mot [] = {’b’, ’o’, ’n’, ’j’, ’o’, ’u’, ’r’} ; // tableau de 7 caractères
String ch = new String (mot) ; // ch est construite à partir du tableau mot
// et contient maintenant la chaîne "bonjour"
char mot [] = {’a’, ’l’, ’i’, ’b’, ’a’, ’b’, ’a’} ; // tableau de 7 caractères
String ch = new String (mot, 2, 4) ; // ch est construite en prélevant 4 carac
// du tableau mot, à partir de celui de rang 2 ; ch contient la chaîne "liba"
De façon symétrique, on peut transformer un objet chaîne en un tableau de
caractères, grâce à la méthode toCharArray :
String ch = "bonjour" ;
char mot [] ;
mot = ch.toCharArray() ; // mot référence un tableau de 7 éléments
// (les 7 caractères de bonjour)
224
LA GESTION DES EXCEPTIONS
Gestion des exceptions

INTRODUCTION
int puissance (int a, int b,){ // calcul de ab
int S =1;
for (int i =0; i<b; i++)
S*=a;
return S; Si b n’est pas un entier ?!!!
}
Il faut donc gérer cette exception,

226
Gestion des exceptions

PREMIER EXEMPLE D’EXCEPTION


1- Comment déclencher une exception avec throw
Considérons une classe Point, munie d’un constructeur à deux arguments et d’une
méthode affiche. Supposons que l’on ne souhaite manipuler que des points ayant des
coordonnées non négatives.
class Point
{ public Point(int x, int y) throws ErrConst // peut provoquer une exception
{ if ( (x<0) || (y<0)) throw new ErrConst() ; // pour déclencher l’exception
this.x = x ; this.y = y ;
}
public void affiche()
{ System.out.println ("coordonnees : " + x + " " + y) ;
}
private int x, y ;
}
class ErrConst extends Exception // pour l’objet fourni à throw
{} 227
Gestion des exceptions

PREMIER EXEMPLE D’EXCEPTION


2-Utilisation d’un gestionnaire d’exception
class Point
public class Except1 { public Point(int x, int y) throws ErrConst
{ if ( (x<0) || (y<0)) throw new ErrConst() ;

{ public static void main (String args[]) this.x = x ; this.y = y ;


}
public void affiche()
{ try { System.out.println ("coordonnees : " + x + " " + y) ;
}
{ Point a = new Point (1, 4) ; }
private int x, y ;

a.affiche() ; class ErrConst extends Exception { }

a = new Point (-3, 5) ;


a.affiche() ; coordonnees : 1 4
} Erreur construction
catch (ErrConst e)
{ System.out.println ("Erreur construction ") ;
System.exit (-1) ;
}
}
} 228
Gestion des exceptions
GESTION DE PLUSIEURS EXCEPTIONS 1/2
On ajoute à notre classe Point une méthode deplace qui s’assure que le déplacement ne
conduit pas à une coordonnée négative ; si tel est le cas, elle déclenche une exception
ErrDepl (on crée donc, ici encore, une classe ErrDepl) :
class Point
{ public Point(int x, int y) throws ErrConst
{ if ( (x<0) || (y<0)) throw new ErrConst() ;
this.x = x ; this.y = y ;
}
public void deplace (int dx, int dy) throws ErrDepl
{ if ( ((x+dx)<0) || ((y+dy)<0)) throw new ErrDepl() ;
x += dx ; y += dy ;
}
public void affiche()
{ System.out.println ("coordonnees : " + x + " " + y) ;
} class ErrConst extends Exception
private int x, y ; {}
} class ErrDepl extends Exception
229
{}
Gestion des exceptions
GESTION DE PLUSIEURS EXCEPTIONS 2/2
public class Except2
{ public static void main (String args[])
{ try
{ Point a = new Point (1, 4) ;
a.affiche() ;
a.deplace (-3, 5) ;
a = new Point (-3, 5) ;
a.affiche() ;
}
catch (ErrConst e)
{ System.out.println ("Erreur construction ") ;
System.exit (-1) ; coordonnees : 1 4
} Erreur deplacement
catch (ErrDepl e)
{ System.out.println ("Erreur deplacement ") ;
System.exit (-1) ; 230
}}}
Gestion des exceptions

TRANSMISSION D’INFORMATION AU GESTIONNAIRE D’EXCEPTION

1/2 Par l’objet fourni à l’instruction throw


class Point
{ public Point(int x, int y) throws ErrConst
{ if ( (x<0) || (y<0)) throw new ErrConst(x, y) ;
this.x = x ; this.y = y ;
}
public void affiche()
{ System.out.println ("coordonnees : " + x + " " +
y) ;
class ErrConst extends Exception
}
{ ErrConst (int a, int b)
private int x, y ;
{ this.a = a ; this.b = b ;
}
}
public int a, b ;
231
}
Gestion des exceptions

TRANSMISSION D’INFORMATION AU GESTIONNAIRE D’EXCEPTION


1/2 Par l’objet fourni à l’instruction throw
public class Exinfo1
{ public static void main (String args[])
{ try
{ Point a = new Point (1, 4) ;
a.affiche() ;
a = new Point (-3, 5) ;
a.affiche() ;
}
catch (ErrConst e)
{ System.out.println ("Erreur construction Point") ;
System.out.println (" coordonnees fournies : " + e.a + " " + e.b) ;
System.exit (-1) ; coordonnees : 1 4
} Erreur construction Point
} coordonnees fournies :232-3 5
}
Gestion des exceptions

TRANSMISSION D’INFORMATION AU GESTIONNAIRE D’EXCEPTION


2/2 Par le constructeur de la classe exception

class Point
{ public Point(int x, int y) throws ErrConst
{ if ( (x<0) || (y<0))
throw new ErrConst("Erreur construction avec coordonnees " + x + " " + y) ;
this.x = x ; this.y = y ;
}
public void affiche()
{ System.out.println ("coordonnees : " + x + " " + y) ;
}
private int x, y ; class ErrConst extends Exception
} { ErrConst (String mes)
{ super(mes) ;
}
} 233
233
Gestion des exceptions

TRANSMISSION D’INFORMATION AU GESTIONNAIRE D’EXCEPTION


2/2 Par le constructeur de la classe exception
public class Exinfo2
{ public static void main (String args[])
{ try
{ Point a = new Point (1, 4) ;
a.affiche() ;
a = new Point (-3, 5) ;
a.affiche() ;
}
catch (ErrConst e)
{ System.out.println (e.getMessage()) ;
System.exit (-1) ;
}
coordonnees : 1 4
}
Erreur construction avec coordonnees -3 5
} 234
234
CLONER EN JAVA
Clone()
CLONER EN JAVA
Introduction

classA a;
a ……
a = new classA();
classA b;
b = a;
b
Dans la programmation orientée objet, il arrive que l'on doive cloner un
objet. Le "clonage" d'un objet pourrait se définir comme la création d'une
copie par valeur de cet objet. …
a ……

b ……
236
Clone()
CLONER EN JAVA

L'interface Cloneable
• Pour pouvoir être clonée, une classe doit implémenter l'interface
Cloneable.
• Celle-ci indique que la classe peut réécrire la méthode clone() héritée
de la classe Object.

Par convention, les classes implémentant l'interface


Cloneable doivent réécrire la méthode Object.clone()

237
Clone()
CLONER EN JAVA

La méthode clone()
La méthode clone() doit retourner une copie de l'objet que l'on veut
cloner. Cette copie dépend de la classe de l'objet

Par convention, l'objet retourné doit être indépendant de l'objet cloné,


c'est à dire que tous les attributs devront être eux aussi clonés.

238
CLONER EN JAVA Exemple Clone()
class Point implements Cloneable{
public Point(int a, int b){ x=a; y=b; }
public Point clone(){
Point point = null;
try{
point = (Point) super.clone();
}
catch(CloneNotSupportedException e) {
System.out.println (e.getMessage()) ;
System.exit (-1) ;
}
return point;
}
public void deplace(int dx, int dy){ x+= dx; y+= dy; }
public void affiche(){
System.out.println("je suis le point de coordonnées x= "+x+" et y= "+y);
}
private int x;
private int y;} 239
CLONER EN JAVA Exemple Clone()

public class Cloner{ public static void main(String [] args){


Point a;
Point b;
Point c;
b =new Point(0,0);
a= new Point(3,8);
je suis le point de coordonnées x= 3 et y= 8
a.affiche();
je suis le point de coordonnées x= 6 et y= 16
a.deplace(3, 8);
je suis le point de coordonnées x= 6 et y= 16
b=a.clone();
Point@dc6a77
c=a;
Point@d1e89e
b.affiche();
Point@dc6a77
c.affiche();
System.out.println(a.toString());
System.out.println(b.toString());
System.out.println(c.toString());
}}
240
LA CLASSE VECTOR
LA CLASSE ARRAYLIST
LA CLASSE VECTOR Classe Vector

La classe Vector permet de gérer des listes.


Object

//Attributs :
int capacityIncrement
Vector
// capacité ajoutée automatiquement au vecteur lorsqu'il est saturé.
//Si cette valeur est nulle, la capacité est doublée en cas de besoin.
int elementCount
// nombre d'éléments du vecteur
Object elementData []
// tableau des éléments du vecteur

242
LA CLASSE VECTOR Classe Vector

Quelques méthodes : Object


Vector()
// Crée un vecteur vide
Vector(int initialCapacity) Vector
// Crée un vecteur vide dont la capacité initiale est égale à l'argument
//spécifié.
Vector(int initialCapacity, int capacityIncrement)
// Crée un vecteur vide dont la capacité est égale à initialCapacity, et
//dont la capacité s'accroît de capacityIncrement lorsqu'il est saturé.
void addElement(Object obj)
// ajoute l'élément obj au vecteur
Object elementAt(int index)
// renvoie l'objet d'indice index.
Object firstElement()
// renvoie le premier élément du vecteur.
243
LA CLASSE VECTOR Classe Vector

Quelques méthodes :
void insertElementAt(Object obj, int index)
// insère l'objet obj de façon qu'il occupe l'indice index, les objets situés
//à la suite étant décalés.
boolean isEmpty() Object
// renvoie true si le vecteur est vide, sinon false.
Object lastElement() Vector
// renvoie le dernier élément du vecteur.
void removeAllElement()
// supprime tous les éléments du vecteur et remet à 0 le nombre de ses
//éléments.
boolean removeElement(Object obj)
// supprime la première occurrence de l'objet obj et avance d'un indice
//tous les éléments situés derrière.
// renvoie true si l'objet existe, sinon false.
244
LA CLASSE VECTOR Classe Vector

Quelques méthodes :
void removeElementAt(int index)
// Supprime l'élément d'indice index et avance d'un indice tous les
//éléments situés derrière.
void setElementAt(Object obj, int index) Object
// remplace l'élément d'indice index par l'objet obj.
int size() Vector
// donne le nombre d’éléments du vecteur

245
LA CLASSE VECTOR Classe Vector
public class LISTE{ Exemple
public static void main(String [] args){
Vector<Point> Liste;
Liste = new Vector<Point>(5);
Point a, b, c;
a =new Point(9,-5);
b= new Point(3,8);
c =new Point(-9,-25);
System.out.println("La taille de la liste = "+Liste.size());
Liste.add(a);
Liste.add(b);
Liste.add(d);
System.out.println("La taille de la liste = "+Liste.size());
a.deplace(3, 8);
for (int i=0; i<Liste.size(); i++){
System.out.println(Liste.elementAt(i).toString()) ;
Liste.elementAt(i).affiche();
}}} 246
LA CLASSE VECTOR Classe Vector
public class LISTE{ Exemple
public static void main(String [] args){
Vector<Point> Liste;
Liste = new Vector<Point>(5);
Point a, b, c;
a =new Point(9,-5); La taille de la liste = 0
b= new Point(3,8); La taille de la liste = 3
c =new Point(-9,-25);
Point@d1e89e
System.out.println("La taille de la liste = "+Liste.size());
je suis le point de coordonnées x= 6 et y= 16
Liste.add(a);
Point@ff057f
Liste.add(b);
Liste.add(d); je suis le point de coordonnées x= 9 et y= -5
System.out.println("La taille de Point@c1f10e
la liste = "+Liste.size());
a.deplace(3, 8); je suis le point de coordonnées x= -9 et y= -25
for (int i=0; i<Liste.size(); i++){
System.out.println(Liste.elementAt(i).toString()) ;
Liste.elementAt(i).affiche();
}}} 247
LA CLASSE ARRAYLIST Classe Arraylist

ArrayList<Point> Liste;
Liste = new ArrayList<Point>(10);
Liste.add(a);
Liste.add(b);
for (int i=0; i<Liste.size(); i++){
System.out.println(Liste.get(i).toString()) ;
Liste.get(i).affiche();

248
LA CLASSE ARRAYLIST Classe Arraylist

Création d’un ArrayList


il est possible d’indiquer la taille initiale dans le constructeur
Il y a 2 constructeurs :
ArrayList()
ArrayList(int initialCapacity)

Modification d’éléments
Il y a deux manières d’ajouter un élément :
à la fin d'un ArrayList avec la méthode
boolean add(Object newElement)
à une position donnée
void add(int index, Object newElement)
throws IndexOutOfBoundsException
le paramètre index indique où insérer le nouvel élément si position
incorrecte, une exception est lancée.
249
LA CLASSE ARRAYLIST Classe Arraylist

Modification d’éléments
pour remplacer un objet à une position donnée
Object set(int index, Object newElement)
throws IndexOutOfBoundsException
cette méthode fonctionne comme void add(int index, Object newElement)
sauf que l’élément à la position index est remplacé
Accès aux Éléments
pour accéder à un élément il n’y a pas d’indexation comme pour les
tableaux il faut utiliser la méthode spécialisée
Object get(int index) throws IndexOutOfBoundsException
exemple :
ArrayList aList = new ArrayList();
aList.add(new PacMan());
aList[0].display(); // interdit !
aList.get(0).display(); // ok
250
LA CLASSE ARRAYLIST Classe Arraylist

A ccès aux Eléments


pour tester le contenu, il existe la méthode
boolean is Empty()
pour connaître le nombre d’ éléments dans la liste,
il faut utiliser la méthode : int size()
exemple :
if (!aList.isEmpty()) {
for (int i=0; i < aList.size( ); i++){
System.out.println( aList.get( i));
}
}

251
LA CLASSE ARRAYLIST Classe Arraylist

Suppression d’éléments
Pour supprimer un élément à une position donnée, il faut utiliser la
méthode
Object remove(int index)
throws IndexOutOfBoundsException

Recherche d’éléments
pour savoir si un objet est présent ou non dans une liste, il faut utiliser
la méthode
boolean contains(Object obj).
pour connaître la position d’un élément dans une liste, on peut utiliser
deux méthodes
pour avoir la première occurrence , il faut utiliser
int indexOf( Object obj)
pour avoir la dernière occurrence , il faut utiliser
int lastIndexOf( Object obj)
252
PHASE D’IMPLÉMENTATION

Implémentation d’une association 1 à 1


Il faut voir le type de cette association :
bidirectionnelle : les deux objets se connaissent
unidirectionnelle : un seul des objets qui reconnait l’autre

Dans le cas d’une association bidirectionnelle chacun des deux objets doit
contenir une référence sur l’autre objet

Vehicule
conducteur -NumChassis : string
1 1
-Id_cond :int -immatricule : string
- model : int
+ demarrer() : void
+ arreter() : void
+ ralentir(int vitesse) : void
253
PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à 1 bidirectionnelle 1/2
public abstract class Vehicule {
private string numChassis ;
private string immatricule ;
private int model ;
private Conduteur cond;
// getter / setter
public void addConducteur(Conducteur c){
if (c != null){
if (c.getVehicule() != null) {
// si le conducteur c est déjà associé à un autre véhicule
c.getVehicule().setConducteur(null);
// cet autre véhicule doit se dissocier
}
this.setConducteur(c);
c.setVehicule(this);
}
}
} GUIDE DE LA MODÉLISATION UML 254
PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à 1 bidirectionnelle 2/2
public class Conducteur {
private int id_cond;
private Vehicule v;
// getter / setter
public void addVehicule(Vehicule v){
if (v != null){
if (v.getCondusteur() != null) {
// si le véhicule v est déjà associé à un autre conducteur
v.getConducteur().setVehicule(null);
// cet autre conducteur doit se dissocier
}
this.setVehicule(v);
v.setConducteur(this);
}
}
} GUIDE DE LA MODÉLISATION UML 255
PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à 1 unidirectionnelle 1/2

Dans le cas d’une association unidirectionnelle , l’objet émetteur


doit connaitre celui récepteur.

Vehicule
conducteur -NumChassis : string
1 1
-Id_cond :int -immatricule : string
- model : int
+ demarrer() : void
+ arreter() : void
+ ralentir(int vitesse) : void

Sur cet exemple, la classe véhicule doit contenir une référence vers la classe
conducteur.

256
PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à 1 unidirectionnelle 2/2
public abstract class Vehicule {
private string numChassis ;
private string immatricule ;
private int model ;
private Conduteur cond;

// getter / setter

public void addConducteur(Conducteur c) {


if ( c != null ) {
this.setConducteur(c);
}
}
} 257
PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à plusieurs bidirectionnelle 1/3
voie Conflit_insertion
1 0..*
- capacité :int -Id_conf : int
-- débit : int

L’objet ayant la cardinalité la plus élevée reçoit une référence sur l’objet ayant la
cardinalité la plus faible en respectant le sens de l’association
La cardinalité 0..* est traduite par une collection d’objets de types
conflit_insertion dans l’objet voie
Dans le cas où le degré de multiplicité est connu (n), la collection peut être
remplacée par un tableau de dimension n

GUIDE DE LA MODÉLISATION UML 258


PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à plusieurs bidirectionnelle 2/3
public class Conflit_insertion {
private int id_conf;
private Voie voie;
// getter / setter

public void addVoie(Voie v){


if (v != null){
if (! v.getConflits().contains(this)) {
if (voie != null) voie.remove(this);
this.setVoie(v)
voie.getConflits().add(this);
}
}
}
259
PHASE D’IMPLÉMENTATION
Implémentation d’une association 1 à plusieurs bidirectionnelle 3/3
public class Voie {
private int capacite;
private ArrayList<Conflit_insertion> conflits;
// getter / setter
public Voie() {
conflits = new ArrayList<Conflit_insertion>();
}
public void addConflit(Conflit_insertion c) {
if (c != null){
if (! conflits().contains(c)) {
if (c.getVoie != null) c.getVoie.remove(c);
this.conflits.add(c);
c.setVoie(this);
}
}
}
} 260
PHASE D’IMPLÉMENTATION

Implémentation d’une association plusieurs à plusieurs 1/2

Voie Vehicule
-Capacité : int 1..* Rouler 0..* -NumChassis : string
-débit : int -immatricule : string
+ createVéhicule(type:string) : véhicule - model : int
+ ajouterVéhicule(V : véhicule) : void + demarrer() : void
+ createConflit(V: véhicule) : Conflit + arreter() : void
+ ralentir(int vitesse) : void

Dans le cas d’une association bidirectionnelle chacune des deux classes doit
contenir une collection d’objets de l’autre classe

261
PHASE D’IMPLÉMENTATION
Implémentation d’une association plusieurs à plusieurs 2/2

public class Voie {


private int capacite;
private int debit;
public abstract class Vehicule { private vector<Vehicule> vehicules;

private string numChassis ; // getter / setter


private string immatricule ;
private int model ; public Vehicule createVehicule(String type){}
privateVector<Voie> voies; public void ajouterVehicule(Vehicule v)
{}
// getter / setter public Conflit createConflit(Vehicule v){}
}
public void demarer(){}
public void arreter() {}
public abstract void ralentir(int v) {}

} 262