Passer à la première page Programmer avec des objets Etienne Vandeput Namur 2002 – 2003 - 2004 [email protected]

Passer à la première page

Programmer avec des objets

Etienne VandeputNamur 2002 – 2003 - 2004

[email protected]


Programmer avec des objets© CeFIS 2004

Page 2

Who’s who?

Vu que nous ne sommes pas nombreux… Attentes Background …



Page 3

Objectifs

Remettre l'activité de programmation au goût du jour en présentant les mécanismes de la POO (et ce qui les justifie)

Apprendre à maîtriser un autre paradigme de programmation obsession de l’algorithmique et de l’exécution

Apprendre un langage qui a grandi avec le Web Étudier les possibilités d'enseignement de ce type de

programmation dans le secondaire porter un regard pédagogique (méthodologie, types de

représentations,…) Réfléchir à des stratégies et à des méthodologies simples



Page 4

Méthode Des développements théoriques accompagnés d'exemples

simples Des exercices résolus en salle de cours Des exercices à résoudre à domicile (parfois corrigés)

l'absence de pratique est justifiée par le fait que les participants sont censés travailler à domicile

ce postulat est souvent mis en défaut Des références

Un syllabus notes (définitivement?) provisoires Lisez les notes de bas de page

Une bibliographie avec des ouvrages de différents calibres (répondant à des besoins ): succincts, verbeux, illustrés,...

Une abondante documentation sur le web



Page 5

Plat du jour

Les concepts fondamentaux et les mécanismes de la POO en toute généralité.

Des exemples simples pour amener les concepts de base L'implantation des concepts élémentaires: classes, champs,

méthodes,... en Java (premier contact avec le langage) Quelques indications sur l'installation d'une version correcte

du soft



Page 6

En fin de séance, vous devriez pouvoir... Posséder une idée très générale des mécanismes de la

POO Avoir compris ce qu’est une classe, un objet, un champ de

donnée, une méthode Identifier, dans une description semblable à celles que nous

aurons données, des classes d’objets et des exemples pour leur structure en termes de champs de données et de méthodes

Être capables d’imaginer d’autres exemples semblables à ceux qui ont été présentés



Page 7

Pourquoi la POO?

Les limites des langages de programmation impératifs quelques milliers de lignes quelques personnes

Penser le travail autrement en terme de contrats à respecter

Comment? boîtes noires (logicielles)… I/O

Dans quel but? modularisation, réutilisation, adaptabilité (modification des

exigences), simplification du débogage NB Programmer « objet » ≠ utiliser un langage OO



Page 8

Exemple 1: où il est question de voitures… Classes

Les voitures… Instance (objet)

Ma voiture La voiture rouge qui est garée en face de chez moi…

Un état (ce qui caractérise l’objet statiquement) kms au compteur couleur pneus (composition)

Des comportements possibles (ce qui caractérise l’objet dynamiquement)

freine accélère …



Page 9

Quelques commentaires

Il importe d’abord de décrire l’environnement d’une manière qui nous permette de développer l’interaction entre les objets.

L’état d’un objet peut changer au cours du temps. Nous aurions pu parler de véhicules à quatre roues,

véhicules,… des airs de famille

Où se trouve la programmation? dans le comportement des objets

Freine: un input, un output ou un changement d’état vitesse diminue



Page 10

L'encapsulation Aussi appelée dissimulation des données Emballage de l'état de l'objet et de son comportement

l'état de l'objet est décrit par des champs de données le comportement est décrit par des « méthodes »

Avantage l'implantation est cachée à l'utilisateur de l'objet l'objet fonctionne comme une boîte noire

Pour que l'encapsulation fonctionne correctement, il faut exiger que l’état d'un objet ne soit modifiable que par l’objet lui-même et donc par l'intermédiaire des méthodes qu'il supporte pas d'accès direct aux champs de données de l'objet de la

part d'objets d'une autre classe



Page 11

Classes, instances, variables d'instance Les objets sont regroupés en classes

les objets d'une même classe supportent les mêmes méthodes et possèdent les mêmes champs

Un objet est une instance de classe Les méthodes apparaissent comme des services, des

contrats que l'objet s'engage à respecter simplification du débogage

Le contenu des champs est variable d'une instance à l'autre on parle de variables d'instances



Page 12

Exemple 2: le carré

Qu'est-ce qui caractérise un carré (et qui est susceptible de nous intéresser)? longueur du côté sommet (coin supérieur gauche) …

Autres possibilités coordonnées des quatre sommets

Que pouvons-nous demander à un objet de type carré de se dessiner de nous « dire » son périmètre, son aire, la longueur de ses

diagonales,… de changer ses dimensions, sa position,...



Page 13

Quelques observations Le calcul du périmètre:

plusieurs façons de faire La modification des dimensions:

l'objet garde le contrôle il n'y aura jamais de carré dont la longueur du côté est

négative (système consistant) Les informations sont typées:

type prédéfini: la longueur du côté est du type "nombre entier", par exemple.

type construit: le sommet est de type "Point" (une autre classe d'objets)

La définition d’une classe d’objets correspond en fait à la définition d’un nouveau type d’information



Page 14

L'héritage

Le carré, un polygone régulier particulier (spécialisation) Un polygone régulier possède des côtés de même longueur

la longueur du côté est propre aux polygones réguliers le nombre de côtés en est également une caractéristique le calcul du périmètre s'obtient en multipliant le nombre de

côtés par cette longueur une méthode pour calculer l'aire devrait exister mais elle est

indéfinissable à ce niveau La classe des carrés hérite de la classe des polygones

réguliers, de ses champs, de ses méthodes mais peut en avoir davantage: une méthode pour calculer la longueur de la diagonale



Page 15

Héritage et polymorphisme La classe des polygones réguliers généralise celles des carrés,

des triangles équilatéraux, des pentagones réguliers,… L'héritage permet de ne réinventer que ce qui est nécessaire.

la méthode de calcul du périmètre reste valable; celle de l'aire aussi à partir de l'angle au centre

la méthode de calcul de la longueur des diagonales du carré doit être inventée

la méthode de calcul de l'aire peut être redéfinie plus simplement Un carré est aussi un polygone régulier. On parle à ce propos de

polymorphisme. On peut aussi considérer un carré comme un polygone régulier si on

ne recherche pas un comportement spécifique au carré.



Page 16

Surcharge

Un carré est un polygône régulier, mais aussi un quadrilatère. On parle à ce propos d'héritage multiple.

Un quadrilatère n'est pas nécessairement un carré. assez évident dans l'exemple choisi, mais pas toujours en

programmation On peut calculer la longueur de la diagonale du carré sur

base de la longueur de son côté, mais aussi à partir de la connaissance des coordonnées de deux sommets opposés.

Il peut exister plusieurs versions d'une méthode pour obtenir un résultat ou un traitement on parle alors de surcharge le compilateur doit effectuer un choix



Page 17

Représentation

Nécessité d’un « graphisme » simple pour représenter les classes

Rectangles (trois parties): nom champs: un type de donnée (simple ou complexe) méthodes

Des règles à se donner



Page 18

Exemple 3: points, droites et cercles Programmer « objet », c’est avant tout décrire un

environnement, en termes d’objets et de classes d’objets, mais en pensant déjà un peu aux services que l’on pourrait leur demander.

Pas aussi simple dans la pratique besoin d’un schéma statique des données (ERA)

Un système de messages Un système de sous-traitance Programme= grande conversation entre objets et classes

d’objets



Page 19

Énoncé

Une droite est constituée de points. Deux points permettent de définir une droite, mais il y peut y avoir d’autres moyens. On peut avoir envie de modifier la direction d’une droite, de la faire se déplacer parallèlement à elle-même. Pour autant que l’on ait défini ce qu’est un cercle, on peut se demander si une droite est tangente à un cercle donné, si elle comprend un point donné etc.



Page 20

Un bout d’algorithmique

Les méthodes sont des ensembles d’instructions Parmi ces instructions, des appels de sous-traitance de

l’objet courant à d’autres objets ou classes: <nom de l’objet>.<nom de la méthode invoquée>

maVoiture.freine vitesse ← maVoiture.donneTaVitesse()

l’objet modifie l’environnement ou fournit un résultat avant de rendre la main à l’objet ou la classe appelante



Page 21

Exercice: À propos d’emballage de produits Quelle(s) classe(s) d’objets y verriez-vous…

champs, méthodes …de manière à pouvoir la faire évoluer en fonction des

exigences?

Je suis directeur d'une multinationale qui produit et emballe des produits très différents. Parmi ces produits, des chaussures pour hommes et pour dames. Je souhaite, à terme, disposer d'un logiciel qui me permettrait notamment de calculer le prix de revient de mes emballages et de ce qu'ils pourraient contenir.



Page 22

POO vs programmation impérative? Pas de concurrence avec la programmation impérative

toujours bien nécessaire pour le développement du code à l'intérieur des méthodes

Approche partiellement bottom-up alors que les adeptes de la programmation structurée prônaient davantage le top-down la POO est naturellement structurée

"Orienté" objet une orientation qui peut être plus ou moins manifeste

certains langages de script qualifiés d'orientés objet ne font pas apparaître de manière évidente ses mécanismes



Page 23

Les avantages de la POO Une approche plus naturelle (se rapprocher du monde réel

qui est aussi composé d'objets concrets ou abstraits) la programmation impérative oblige plutôt l'Hô à se rapprocher

de la machine Adaptabilité nettement supérieure

de nouvelles spécifications ne remettent pas en question le travail déjà effectué

Gestion simplifiée de la complexité principe de sous-traitance, de contrat à respecter

Programme en POO = conversation entre objets chaque objet rend un ensemble de services (sous forme

d'appel de méthodes)



Page 24

Le choix d'un langage

La pratique de plusieurs langages n'est sans doute pas souhaitable en situation d'apprentissage

Choix porté sur Java mise en œuvre claire des mécanismes

héritage polymorphisme surcharge

pas trop d'implicites seulement des raccourcis d'écriture

en phase avec le Web portable

bytecodes interprétables sur de nombreuses plateformes



Page 25

Définir une classe en Java La classe Point

class Point{public int x;

public int y;}

Le mot-clé class Nom d'une classe:

lettre + lettres ou chiffres convention: CompteurDeMots, GrandNombre,… Java est sensible à la casse

Définition de la classe: définition d'un bloc: { } alignement des accolades



Page 26

Modificateurs d'accès et types Le symbole ; est le séparateur d'instruction public est un modificateur d'accès

peut aussi s'appliquer aux méthodes et aux classes peut aussi prendre les valeurs private, protected,… on évite de donner un accès trop large si ce n'est pas

nécessaire Les champs de données

les variables d'instance x et y convention: minuscule puis majuscule à chaque nouveau mot

firstNumber, secondNumber,… les variables sont du type primitif int

Les méthodes aucune pour l'instant



Page 27

Types primitifs

Quatre types entiers byte (1 octet) short (2 octets) int (4 octets) long (8 octets)

Deux types numériques à virgule flottante float (4 octets) double (8 octets)

Un type caractère char (2 octets unicode)

Un type booléen boolean (deux valeurs: true et false)



Page 28

A propos des types primitifs... Tous les types numériques sont signés. Il n'y a pas de type "chaîne de caractères"

mais il existe une classe String prédéfinie remarquez la majuscule

Il est possible d'utiliser des écritures tellespublic int x = 3;private char c1 = 'a';public float y = 1.;

Attention, "a" désigne un objet de type String et non un caractère.



Page 29

Les méthodes

class Point{

private int x; private int y;

public int getAbscisse(){ return x;

} public int getOrdonnee(){

return y; } public void setAbscisse(int a){

x=a; } public void setOrdonnee(int b){

y=b; }}



Page 30

Structure

Un modificateur d'accès souvent public sauf si la méthode n'est utile qu'à l'intérieur de

la classe Le type du résultat s'il y en a un

public int ... void sinon

public void … Le nom de la méthode

public int getAbscisse ... La liste des paramètres (s'il y en a)

public int getAbscisse() ... public void setAbscisse(int a) ...



Page 31

Mais encore... Un bloc d'instructions

public void setAbscisse(int a){…} La convention pour le nom des méthodes est la même que

pour les variables Les paramètres sont séparés par des virgules et précédés

de leur type. Les variables d'instance sont devenues private.

Cela empêche tout objet de les modifier directement lui-même.

Un objet étranger devra sous-traiter le travail à l'objet concerné.

Si p1 est un objet de type Point et n une variable de type int, un appel ressemblera à:

• p1.setAbscisse(n);



Page 32

Et encore plus...

Une méthode void est l'équivalent d'une procédure. Une méthode qui renvoie un résultat d'un certain type

(primitif ou non) est l'équivalent d'une fonction. L'objet dont on invoque la méthode est en quelque sorte un

paramètre implicite. p1 est un paramètre implicite dans p1.setAbscisse(n);

Si la méthode renvoie un résultat, celui-ci doit figurer dans une expression plus complexe: int y = p1.getAbscisse();

le type de y est précisé au moment de l'affectation; il aurait pu l'être plus tôt.

= est le symbole de l'affectation lorsqu'il est employé entre des expressions de types primitifs.



Page 33

Comment naissent les objets? Les membres d'une classe:

les champs les méthodes les constructeurs

sorte de méthodes particulières dont le travail est de créer des objets

Un constructeur porte toujours le nom de la classe. Il existe un constructeur par défaut.

Que fait-il? Il arrive souvent que la définition d’une classe compte

plusieurs constructeurs.



Page 34

Signatures

La signature d'une méthode ou d'un constructeur se compose de son nom et de la liste des paramètres et de leur type. setPoint(int a, int b) est une signature. La signature est importante pour le compilateur.

Une méthode, un constructeur peuvent avoir plusieurs signatures différentes suivant le nombre et le type de leurs paramètres. Le type du résultat ne fait pas partie de la signature.



Page 35

Les constructeurs

public class Point{ private int x; private int y;

public Point(){ // Constructeur 1 setPoint(0,0);

} public Point(int a,int b){ // Constructeur 2

setPoint(a,b); }

...

...

... public void setPoint(int a,int b){

x=a; y=b;

}



Page 36

Utilisation des constructeurs Notez que setPoint globalise deux méthodes et est utilisée

dans les constructeurs. Utilisation possible dans toute méthode de classe ayant un

accès au constructeur ici, toutes (public)

Exemples

Point p1 = new Point();Point p2 = new Point(3,-1);int n = 25;Point p3;…p3 = new Point(2,n);

NB: int et Point et même String



Page 37

Paramètre implicite et déclaration de variables x = p1.getOrdonnee();

OK si cette affectation se trouve dans la description d'une méthode concernant un objet de type Point (le champ x existe et la méthode getOrdonnee() aussi)

il s'agit de l'abscisse du point courant et de l'ordonnée du point p1 la déclaration doit précéder l'utilisation

int x; x=…; ou int x=…; la portée d’une variable est le bloc dans lequel elle est déclarée

classe structure de contrôle méthode ...



Page 38

Références

Un exemple d’affectation utilisant des objets Employé entre deux expressions de types construits, le

signe = symbolise une affectation de référence. en Java, les variables d'instances de types construits sont des

références. l’instruction… Point p1, p2; …indique que p1 et p2 seront les

adresses de deux objets de type Point. Que signifie dès lors exactement…

p1=p2;



Page 39

Programme objet = conversation entre objets À tout moment, un objet ou une classe a la parole. Il ou elle exécute une de ses méthodes. Il ou elle rendra la main une fois son travail terminé sous

forme: d’un résultat (valeur ou référence d’objet) d’un signal indiquant que son travail est terminé

Qui commence? Programme = Une classe « Application » crée des objets

et/ou invoque des méthodes sur ces objets



Page 40

Un premier programme

public class PremierProgramme{

public static void main(String [] args){

System.out.println("Bienvenue au coursJava!");

}

}

La classe doit être déclarée public et être enregistrée dans un fichier qui porte le même nom.



Page 41

La méthode main

La conversation est initiée par une classe qui possède une méthode portant le nom prédéfini main. static

elle concerne la classe et non un quelconque de ses objets void

elle exécute des traitements mais ne renvoie pas de résultat son paramètre est un tableau de chaînes de caractères

fournis en ligne de commande possiblement vide String args[] est équivalent à String [] args

La classe System non instanciable out: une variable objet (voir documentation)



Page 42

Test

Compilation (production des octets de codes) javac PremierProgramme.java

Exécution (lancement de la machine virtuelle) java PremierProgramme

Précautions lancer la compilation à partir du répertoire contenant le fichier

source vérifier que le chemin (path) contient bien la description du

chemin d'accès au compilateur gare à la casse pas d'extension class pour le fichier fourni à la JVM



Page 43

Installer l'environnement de programmation Java Télécharger à partir de http://www.det.fundp.ac.be/cefis

/ressources/soft/j2sdk.exe java 2 sdk (software development kit), standard edition (j2se)

v 1.4 fichier exécutable de 40Mo environ

Installation par défaut dans c:\jdk1.4.1_03 sous Windows (dans usr/bin sous Linux)



Page 44

Choix d'un éditeur TextPad, un éditeur semi-intelligent qui gère notamment la

coloration syntaxique, l'indentation… disponible à l'essai sur http://www.textpad.com/download/ largement satisfaisant dans le cadre de nos activités

Le bloc-notes sous Windows ou des éditeurs comme vi ou emacs sous Linux

pour en savoir plus sur le mode d'emploi: www.linux-france.org/article/appli/emacs/manuel/

à réserver aux informaticiens claviérophiles qui tapent à dix doigts Jbuilder, un outil fantastique pour les développeurs (à oublier dans

le cadre de la découverte des mécanismes et des primitives d'un langage

Informations sur http://www.borland.com/products/downloads/download_jbuilder.html



Page 45

La machine virtuelle Java (JVM) Objectif de portabilité

développement d'Internet architecture centralisée architecture de systèmes distribués

(plus simples à faire évoluer) Production, par compilation, de bytecodes

code intermédiaire pour machines hypothétiques lisible par toute machine possédant un interpréteur adéquat

Installation de Java = fourniture de différentes librairies de classes différents outils: compilateur, interpréteur, générateur de

documentation,… JVM = système + instance(interpréteur)

plusieurs JVM peuvent tourner sur la même machine



Page 46

Schéma simplifié de compilation-exécution Écriture d'une classe Application (et éventuellement d'autres

classes) Enregistrement sous Application.java Compilation (production de bytecodes)

javac Application.java production d'un fichier Application.class

Activation de la JVM java Application (sans extension)

Choix des paramètres d'environnement corrects



Page 47

Synthèse (0)

La POO a connu son succès par les solutions qu'elle a tenté d'apporter aux problèmes de réutilisabilité, d'adaptabilité et de contrôlabilité des programmes.

Les solutions prennent la forme de mécanismes dont les principaux sont l'encapsulation (des données et des traitements) l'héritage le polymorphisme la surcharge

Jusqu'ici, seul le mécanisme d'encapsulation a été quelque peu envisagé.



Page 48

Synthèse (1)

Un programme POO est une conversation entre objets (et classes)

Les objets sont des instances de classes La définition d'une classe peut comprendre notamment la

définition de champs de données de méthodes supportées par les classes et/ou leurs objets de différents constructeurs

Ce regroupement des traitements et des données est connu sous le nom d'encapsulation. Son intérêt est de cacher à l'utilisateur la manière dont les

traitements sont implémentés et de contrôler davantage les erreurs et la consistance des données



Page 49

Synthèse (2)

Champs, méthodes et constructeurs sont des membres de classe

Une classe définit un type nouveau par rapport aux types existants et en particulier, les types primitifs qui sont au nombre de 8 en Java 4 types entiers 2 types nombres à virgule flottante un type caractère un type booléen



Page 50

Synthèse (3)

Les champs de données ont tous un type (primitif ou construit) par type construit, on entend une classe d'objets

Les méthodes et les constructeurs ont une signature qui se compose de leur nom la liste de leurs paramètres et de leurs types respectifs

Deux méthodes (constructeurs) diffèrent par leur signature Les classes, champs, méthodes et constructeurs sont

caractérisés par leur accessibilité public private ...



Page 51

Synthèse (4)

Les méthodes renvoient ou non un résultat d'un certain type (construit ou primitif). Le mot-clé void (pas de résultat renvoyé) ou le nom du type

précède la signature. Si le type du résultat est une classe d'objets, ce qui est

renvoyé est une référence à un objet (son adresse en mémoire)

Les constructeurs renvoient toujours une référence à un objet du type d'objets qu'ils construisent. Les adresses sont passées par valeur, ce qui signifie que leur

modification à l'intérieur d'une méthode ou d'un constructeur ne se répercute pas en dehors de la méthode ou du constructeur.



Page 52

Synthèse (5)

Les conventions pour le choix des identificateurs variables: minuscules et majuscules pour la première lettre de

chaque mot à partir du deuxième (nombre, longueurMot,…) méthodes: idem (getName, affiche,…) classes (et constructeurs qui ont le même nom): première

lettre majuscule puis idem (Point, JeuDeCarte,…) Les règles syntaxiques

séparateur d'instructions: le point-virgule délimiteurs de bloc: les accolades !!!

Le symbole d'affectation (=) entre variables de type(s) primitif(s): véritable affectation entre variables de type(s) objet(s): affectation de référence



Page 53

Synthèse (6)

La déclaration d'une variable doit précéder son affectation. La portée d'une variable est le bloc.

classe, méthode, constructeur, structure de contrôle,… Pour certains champs, des méthodes d'accès et d'altération

s'imposent. Les méthodes sont généralement accessibles de l'extérieur

de la classe. La valeur d'un champ n'est généralement accessible que de

l'intérieur de la classe (à moins qu'il soit déclaré public, ce qui n'est pas une bonne habitude).



Page 54

Synthèse (7)

Invocation d'une méthode (déclarée public) accès via le nom de l'objet appelé (s'il n'est pas l'appelant)

suivi du nom de la méthode int x = p1.getAbscisse(); p2.setOrdonnee(4);

Référence au champ de donnée d'un objet si l'objet fait partie de la classe ou si le champ est public

accès via le nom de l'objet et le nom du champ• int n=p1.x;

s'il s'agit du champ de l'objet courant et qu'aucune confusion n'est possible

accès via le nom du champ• int n=x;



Page 55

Synthèse (8) En Java, une application ressemble à une conversation entre des

objets initiée par une classe possédant une méthode main (classe exécutable) c'est une méthode de la classe modificateur static elle ne renvoie pas de résultat void (elle représente, en quelque

sorte, le programme principal) elle a comme paramètre un tableau de chaînes de caractères

String [ ] args (args est un nom de paramètre souvent utilisé) La déclaration de cette méthode commence donc par

public static void main(String [ ] args){… Une application ressemble donc à

public class Application{public static void main(String [ ] args){…}

}



Page 56

Synthèse (9)

La méthode main crée des objets et/ou utilise des classes et/ou des objets prédéfinis sur lesquels elle invoque des méthodes.

Chaque méthode invoquée sur une classe ou sur un objet peut elle-même créer de nouveaux objets ou appeler des objets ou des classes existant déjà.

La plus courte application en Javapublic class Application1{

public static void main(String args[]){

System.out.println("Bienvenue au cours Java!");

}

}



Page 57

Synthèse (10)

Possède un champ appelé out de type PrintStreamclass System{

static PrintStream out;

…

}

Les objets de type PrintStream supportent une méthode println qui prend comme paramètre une chaîne de caractères et envoie cette chaîne vers la sortie standard (l'écran).class PrintSream{

...

void println(String x){…}

...

}



Page 58

Amélioration de la classe Point Création d'une méthode distanceJusque qui prend comme

paramètre un autre point nécessité de faire appel à la méthode sqrt de la classe

prédéfinie Math la méthode sqrt est donc une méthode statique (voir sa

définition) p.x a du sens bien que le champ x soit déclaré private car p

fait partie de la classe Point la méthode sqrt de la classe Math renvoie un nombre du type

primitif double (d'où le type de résultat de la méthode)



Page 59

Description des classes

NomClasse

Champs (+accès)

Méthodes (+accès)

Application

+ main()

PrintStream

+println()

Point

-x: reel-y: reel

+ getAbscisse()reel+ getOrdonnee() reel+ setAbscisse(a: reel)+ setOrdonnee(b: reel)+ distanceJusque(p:Point):reel

Math

+sqrt(a: reel) reel



Page 60

public class Point{

private int x;private int y;

public Point(){setPoint(0,0);

}public Point(int a,int b){

setPoint(a,b);}public int getAbscisse(){

return x;}public int getOrdonnee(){

return y;}public void setAbscisse(int a){

x=a;}public void setOrdonnee(int b){

y=b;}public void setPoint(int a,int b){

x=a;y=b;

}public double distanceJusque(Point p){

int diffX=x-p.x;int diffY=y-p.y;return Math.sqrt(diffX*diffX+diffY*diffY);

}}



Page 61

public class Application2{

public static void main(String args[]){

Point p1=new Point(2,3);Point p2=new Point();System.out.println("La distance entre p1 et p2 est " + p1.distanceJusque(p2) + ".");

}

}

Code de l'application



Page 62

Schéma d’interaction des classes

Application

utilise

Point

System

utilise

Math

utilise

PrintStream

compose



Page 63

La somme de deux nombres Approche impérative

lire a, bsomme a + bécrire somme

Voici ce que cela pourrait donner en Java:public class AdditionDEntiersImperatif{

public static void main(String [] args){int n1 = 12;int n2 = 54;int somme = n1 + n2;System.out.println("La somme des nombres n1 et n2 est " +

somme+ ".");

}



Page 64

Approche objet

Fondée sur le système d'information une classe de nombres entiers

Basée sur des extensions, des améliorations futures possibles une méthode d'écriture des nombres en toutes lettres, en

chiffres romains,… Une application pour mettre en jeu les objets

construction affichage des résultats



Page 65

La classe Entier

class Entier{private int valeur;

public Entier(int v){valeur=v;

}

public Entier plus(Entier e){return new Entier(valeur + e.valeur);

}

public int getValeur(){return valeur;

}}



Page 66

L'application

public class AdditionDEntiers{

public static void main(String [] args){Entier n1 = new Entier(12);Entier n2 = new Entier(54);

System.out.println("La somme des nombres n1 et n2 est " +n1.plus(n2).getValeur());

}}



Page 67

Exercices

Ajoutez à la classe Entier une méthode qui renvoie le carré d'un Entier (sous forme de valeur entière ou d'objet)

Ajoutez à la classe Entier une méthode qui vérifie si un Entier est multiple de 7 (ou d'une valeur entière donnée)

Ecrivez la description d'une classe Triangle dont l'état serait caractérisé par les coordonnées des trois sommets et dont le comportement comprendrait une méthode de renvoi de son périmètre (on peut évidemment utiliser la classe Point)

Dressez le schéma de chaque classe et le diagramme d’interaction des classes



Page 68

Triangleclass Triangle{

Point s1,s2,s3;

public Triangle(Point s1, Point s2, Point s3){

// Le constructeur ne vérifie pas si les points sont alignés.

this.s1=s1;this.s2=s2;this.s3=s3;

}

public double perimetre(){

return s1.distanceJusque(s2)+s2.distanceJusque(s3)+s3.distanceJusque(s1);

}}



Page 69

Exemple d'application

public class ApplTriangle{


Point p1=new Point();Point p2=new Point(4,1);Point p3=new Point(3,-1);Triangle t=new Triangle(p1,p2,p3);System.out.println("Le périmètre du triangle ainsi défini est de "+t.perimetre()+".");

}

}



Page 70

Comparaison d'objets

o1==o2 vérifie si les références sont identiques (op ==) Besoin d’une méthode (egalA)

existence d’une méthode prédéfinie de la classe Object (héritage!!!) qui s’appelle equals

elle a un comportement par défaut comparaison des références o1.equals(o2) renvoie la valeur true si o1==o2

elle demande une réécriture dans toute classe souhaitant la spécialiser

exemple: comparaison des champs de données il est conseillé de lui conserver, à la réécriture, les qualités

d'une relation d'équivalence réflexive, symétrique et transitive



Page 71

Applicationpublic class Comparaison{


Point p1, p2;p1=new Point(3,1);p2=new Point(3,1);

if (p1==p2){System.out.println("Les références sont identiques.");

}else{

System.out.println("Les références sont différentes.");}

System.out.println();

if (p1.equals(p2)){System.out.println("L'objet p1 est identique à l'objet p2.");

}if (p2.equals(p1)){

System.out.println("L'objet p2 est identique à l'objet p1.");}

}}



Page 72

La méthode equals remplacée

public boolean equals(Point p){return (x==p.x && y==p.y);

}

public boolean equals(Point p){if (x==p.x && y==p.y){

return true;}else{

return false;}

}

équivalent à



Page 73

Les raccourcis d'écriture Un exemple dans la méthode précédente Une manière

d'associer la déclaration à l'initialisation Point p1=new Point(4,-2);

d'éviter de créer des variables locales inutilement Point p=new Point(getAbscisse(),getOrdonnee());

au lieu deint a, b;a = getAbscisse();b = getOrdonnee();Point p;p = new Point(a,b);

d'associer plusieurs actions en une seule instruction public Entier plus(Entier e){

return new Entier(valeur + e.valeur);}



Page 74

La lecture au clavier

Un peu moins simple que l'écriture (à l’écran) L'objet System.in Le passage par des classes prédéfinies

InputStreamReader et BufferedReader méthode readLine

En attendant: création d'une classe (non prédéfinie) Clavier et de plusieurs

méthodes statiques de lecture des différents types primitifs de données

lireInt, lireFloat, lireDouble, lireString



Page 75

Illustrationpublic class LireAuClavier{

public static void main(String [] args){System.out.println("Entrez un nombre entier au clavier: ");int i=Clavier.lireInt();

System.out.println(" Entrez un nombre à virgule au clavier: ");double d=Clavier.lireDouble();

System.out.println(" Entrez une chaîne de caractères au clavier: ");String s=Clavier.lireString();

System.out.println("La valeur du carré de l'entier est " + i*i + ".");System.out.println("La valeur de la racine carrée du nombre à virgule est "+ Math.sqrt(d) + ".");System.out.println("La chaîne de caractères saisie est " + s);

}}



Page 76

La méthode toString

Héritée de la classe Object Sans réécriture:

nom de la classe adresse de l’objet

La réécriture permet de préciser quelle chaîne de caractères doit être associée à l’objet. Ex: Point

Si p est un objet de type Point, comment sera interprété println(p)?



Page 77

Le passage des paramètres (1) Le passage de paramètres à une procédure, une fonction,

une méthode,… peut se faire par référence ou par valeur. Référence (adresse): une référence vers la variable est

fournie à la procédure, la fonction, la méthode… lui permettant ainsi de la modifier

l’effet de ces modifications est donc définitif (jusqu'à la prochaine modification) et visible en dehors de la procédure, la fonction, la méthode,…

Valeur: une copie de la valeur de la variable est transmise à la procédure, la fonction, la méthode… qui peut modifier à souhait cette copie sans toucher à l'original

l'effet de ces modifications n'est pas visible en dehors de cette procédure, fonction, méthode



Page 78

Le passage des paramètres (2) En Pascal, en C,… il est possible de passer un paramètre

par référence (adresse) ou par valeur En Java, le seul passage possible est le passage par valeur

Ce n'est pas gênant dès lors que la valeur (copie) transmise est elle-même une référence vers un objet. Possédant cette référence, la méthode peut provoquer une modification de l'état de l'objet.

Ce qui n'a pas changé après l'exécution de la méthode: la référence de l'objet

Ce qui peut avoir changé après l'exécution de la méthode: l'état de l'objet



Page 79

public class Point2{

private float x;private float y;

public Point2(){setPoint(0,0);

}public Point2(float a,float b){

setPoint(a,b);}public float getAbscisse(){

return x;}public float getOrdonnee(){

return y;}public void setAbscisse(float x){

this.x=x;}public void setOrdonnee(float y){

this.y=y;}public void setPoint(float x,float y){

setAbscisse(x);setOrdonnee(y);

}public String toString(){

return "(" + x + "," + y + ")";}



Page 80

public Point2 symetrique(){Point2 sym = new Point2(-x,-y);return sym;

}

public static void permute(Point2 p1, Point2 p2){Point2 aux = p2;p2 = p1;p1 = aux;

// Les références aux deux objets ont été permutées à l'intérieur de// la méthode.

System.out.println("Après permutation et avant la sortie de \la méthode...");System.out.println("p1: " + p1);System.out.println("p2: " + p2);System.out.println();

}}



Page 81

Passage par valeur

Dans la méthode permute, les copies des deux adresses reçues sont bien permutées. L'impression à l'intérieur de la méthode devrait le confirmer.

Une fois l'exécution de la méthode terminée, les copies disparaissent.

Les paramètres effectifs n'ont pas été modifiés. L'impression dans la méthode main devrait le confirmer.



Page 82

public class AppPoint2{

public static void main(String [ ] args){

Point2 p1=new Point2(3,-1);Point2 p2=new Point2(2,2);

// L'invocation de la méthode "symetrique" sur l'objet p1 renvoie un// objet anonyme qui est "imprimé ".

System.out.println("Le symétrique de " + p1 + " est " +p1.symetrique());System.out.println();

System.out.println("p1: " + p1);System.out.println("p2: " + p2);System.out.println();

// La permutation des deux objets est une permutation de copies de// ces objets.

Point2.permute(p1,p2);

// Lorsque la méthode se termine, ces copies disparaissent.// La permutation est donc sans effets apparents.

System.out.println("Après permutation et sortie de la \méthode...");System.out.println("p1: " + p1);System.out.println("p2: " + p2);System.out.println();



Page 83

L'état des objets peut être modifié…

// Il est pourtant possible de modifier de manière définitive la// coordonnée d'un point par l'intermédiaire d'une méthode.

p1.setPoint(p2.getAbscisse(),p2.getOrdonnee());

System.out.println("Après...");System.out.println("p1: " + p1);System.out.println("p2: " + p2);System.out.println();

}}



Page 84

La classe String

Les packages une manière d'organiser les librairies le package java.lang

importation automatique de classes considérées comme fondamentales

String, Math, System et bien d'autres (voir documentation) De nombreuses méthodes "prêt-à-l'emploi"

length, charAt, indexOf, valueOf, substring, toUpperCase, startsWith, replace, trim,...



Page 85

Exemples

public class AppString{


String message="Bienvenue au cours Java!\n";String messageMaj=message.toUpperCase();System.out.println(message + "\n" + messageMaj + "\n");

int a=12, b=4599;double c=215.34;System.out.println(String.valueOf(a).charAt(0) + "\t" + String.valueOf(b).charAt(2));System.out.println(String.valueOf(c).indexOf(".") + "\n");

String mot=message.substring(19,23);System.out.println(mot + "\t" + message.length() + "\n");

}}



Page 86

Exercice

• Imaginez une application utilisant une classe "Personne" avec les champs de données nécessaires pour donner corps aux méthodes suivantes:

• une méthode qui provoque "l'affichage" de l'objet "Personne"• les champs nom, prénom, n°tel séparés par des tabulations

• une méthode qui provoque l'affichage d'une carte de visite• 1e ligne: Prénom Nom• 2e ligne: Organisme• 3e ligne: Fonction• 4e ligne: email (tabulations) adresse

• une méthode qui provoque l'affichage d'une étiquette d'adresse• 1ère ligne: 1ère lettre du Prénom+point+ Nom (1ère lettre en

majuscule et le reste en minuscules)• 2e ligne: Adresse• 3e ligne: CP + Localité



Page 87

Les champs statiques

Un champ de données peut être propre à la classe et non à un objet particulier de cette classe. un numéro d'ordre indiquant la prochaine valeur à utiliser lors

de la création d'un objet private static long prochainNumero=1; la valeur de prochainNumero n'est accessible qu'à partir de la

classe (private) est propre à la classe (static) et de type entier (long)

Autres exemples: les champs in et out de la classe System



Page 88

Modification d'un champ statique

public static int prochainNumero = 1; // champ statique de la classe Cassettepublic int numero; // champ dynamique de type primitif entierpublic String Titre;public Date enregistreLe;...

Cassette c = new Cassette(); // création d’un objet c de type Cassette c.numero = Cassette.prochainNumero++ // affectation du numéro à la cassette



Page 89

Les méthodes statiques Une méthode peut aussi être propre à la classe.

la méthode sqrt de la classe Math la méthode d'altération d'un champ de donnée statique

celle qui ré-initialiserait la valeur de prochainNumero, par exempleprivate static void initialiserProchain(){

prochainNumero=1;

}

une méthode utilitairepublic static auCarre(int x){

System.out.println("Le carré de " + x + " est " + x*x + ".");

}



Page 90

Le modificateur d'accès final (1) Son rôle est d'empêcher toute modification future du champ

ou de la méthode auxquels il peut s'appliquer. Champ:

Exemples• private final nom;• private static final DIMENSION_MAXIMALE=10;

correspond à la déclaration et à l'affectation d'une variable dont la valeur ne pourra changer

un champ final doit être initialisé au plus tard au moment de la construction

les variables déclarées static final sont en fait des constantes l'utilisation des lettres majuscules et du caractère de

soulignement pour les constantes font partie des règles de bonne pratique



Page 91

Le modificateur d'accès final (2)

Méthodes une méthode déclarée final ne peut être redéfinie dans une

sous-classe (voir héritage) une méthode déclarée static est nécessairement et

implicitement final une méthode déclarée private est nécessairement et

implicitement final Classes

elles peuvent aussi être déclarées final si on ne souhaite pas que d'autres classes en héritent

Ce modificateur d'accès permet d'optimiser le travail du compilateur. Un appel à une telle méthode peut être remplacé par son

code.



Page 92

Les opérateurs Arithmétiques

les classiques +, -, *, /, % (reste de la division entière de … par…) attention aux conversions (promotions)de types

Compile? compile pas?

public class Promotion{


byte b1=2, b2=5, b3;b3=b1+b2;byte b4=b1+6;

}}



byte b1=2, b2=5;int b3=b1+b2;byte b4=b1;

}}



Page 93

Compile? Compile pas?public class Promotion{


int i1=50000, i2=60000;int i3=i1+i2;long i4=i1*i2;System.out.println(i3 + " " + i4);

}}



long i1=50000, i2=60000;long i3=i1+i2;long i4=i1*i2;System.out.println(i3 + " " + i4);

}}



Page 94

Mais encore...public class Promotion{


int i=50000;float f1=i+2.;float f2=i+2.f;System.out.println(f1 + " " + f2);

}}



char c='a';int i=5;System.out.println(c);System.out.println(c+i);c+=i;System.out.println(c);c=c+i;System.out.println(c);

}}



Page 95

Incrémentation, décrémentation Incrémentation

suffixe i++, préfixe ++i for(int i=0; i<50; i++)

Décrémentation suffixe i--, préfixe --i

Quel est celui des deux messages qui sera imprimé?int i=5;if ( i++>5) System.out.println(“Le test précède l’incrémentation”);if ( ++i>5) System.out.println(“L’incrémentation précède le test”);

Résultat?int a = 2, b = 5;int i = a * ++b;System.out.println(“i vaut “ + i + “.”);



Page 96

Affectation élargie

Une autre manière de raccourcir les écritures: a *= 2 a = a * 2 existe aussi avec +, -, / et %

int a = 25, b = 25;

a /= 4;

b %= 6;

System.out.println(a + "\t" + b);

fonctionne également avec + pour les chaînes de caractèresString nom = "Vandeput";

String prenom = "Etienne";

nom += " " + prenom;

System.out.println(nom);

concaténation du prénom au nom avec espace entre les deux



Page 97

Opérateurs logiques, relationnels, conditionnel Les classiques ET, OU, NON et les opérateurs optimisés

&, |, ^,! &&, ||

Pour la comparaison: <, >, <=, >=, ==, !=

L'opérateur conditionnel permet également de beaux raccourcis d'écriture du genreint a, b;

a = … ;

b = … ;

...

int max = a > b ? a : b;



Page 98

Les commentaires

// pour les fins de ligne co++; // incrémentation du compteur

mais aussi /* … */ pour des textes de n'importe quelle longueur (plusieurs lignes) /*

Programme de …réalisé par …Copyright …*/

/** … */ pour des textes destinés au générateur de documentation, l'utilitaire java.doc



Page 99

Le jeu du compilateur

Repérer les erreurs de syntaxe attention des conversions implicites de types sont possibles byte, short int

Transformer les instructions correspondantes en commentaires (//)

Prédire l’affichage Tester



Page 100

public class Ex11ch4{

public static void main(String [ ] args){

byte b1 = 5, b2 = 127;short s1, s2;int i;char c = 'b';

b2 += b1;b2 = b2 + b1;b1 += 2;s1 = b1 + 2;s2 = s1 * 2;c += 2;c = c + 2;i = b1 + b2;i += 5;

System.out.println(b1);System.out.println(b2);System.out.println(s1);System.out.println(s2);System.out.println(i);System.out.println(c);

}}



Page 101

A retenir...

Les opérateurs arithmétiques provoquent des "promotions" des types byte et short vers le type int

L'opérateur d'affectation élargie n'a pas tout à fait le même effet qu'une opération suivie d'une affectation pas de conversion implicite dans le cas d'une affectation

élargie b2 *= b1 OK b2= b2*b1 KO

Pas de promotion par les opérateurs arithmétiques pour les expressions de type int



Page 102

Le jeu du compilateur (suite) Les invocations sont-elles correctes? Les affectations sont-elles correctes? Correction Compilation



Page 103



Bidon b = new Bidon();long valeur = 100;

b.reagir(valeur);b.agir(valeur);agir(valeur);

}}

class Bidon{

private static final long k = 5;private long champ;

static void agir(long valeur){champ = valeur;

}

void reagir (long valeur){champ = valeur;k = valeur;

}}



Page 104

A retenir...

Défense de modifier un champ final Inutile d'invoquer une méthode statique par le biais d'un

objet le faire plutôt par le biais de la classe

Bidon.agir(valeur); Une invocation de méthode sans nom d'objet (ou de classe)

exige que cette méthode soit définie à l'intérieur de la classe.



Page 105

Choix de la méthode par le compilateur Résolution de la surcharge

choix de la meilleure méthode basé sur la signature doit coller au nombre de paramètres doit coller le mieux possible aux types des paramètres

(promotions acceptées) Un exercice pour comprendre: quel affichage produit le

programme suivant? attention aux accès

public, private même classe, classes différentes



Page 106

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

A a = new A();a.g();System.out.println("A partir de la méthode MAIN");System.out.println("---------------------------");int n =1; long q = 12; float x =1.5f; double y = 2.5;a.f(n,q);a.f(q,n);a.f(n,x);a.f(n,y);

}}

class A{public void f(int n, float x){

System.out.println("f(int n, float x)\tn = " + n + " x = " + x);}private void f(long q, double y){

System.out.println("f(long q, double y)\tq = " + q + " y = " + y);}public void f(double y1, double y2){

System.out.println("f(double y1, double y2)\ty1 = " + y1 + " y2 = " + y2);}public void g(){

int n =1; long q = 12; float x =1.5f; double y = 2.5;System.out.println("A partir de la méthode g");System.out.println("------------------------");f(n,q);f(q,n);f(n,x);f(n,y);

}}



Page 107

Les tableaux

Non dimensionnés à la déclaration String [] prenoms;

Point [] sommets;int [] baremes;

Dimensionnés à l'initialisation prenoms = new String [5];

int [] multiplesDe3 = new int [] {0, 3, 6, 9}

int [] valeurs = {128, 135, 136, 141}; baremes = {128, 135, 136, 141}; // incorrect

Exemple calcul d'une série de points du graphe d'une fonction



Page 108

public class Tableau{

public static void main(String[ ] args){

Point[ ] tableValeurs = new Point[5];

for (int i = 0; i<5; i++){tableValeurs[i] = new Point(i, i*i);System.out.println("t[" + i + "] = " + tableValeurs[i]);

}}

}

Exemple

L'initialisation d'un tableau passe souvent par l'emploi d'une structure de contrôle répétitive



Page 109

Lancers de dés

On souhaite lancer deux dés un certain nombre de fois et produire une statistique sur la somme des deux points obtenus à chaque fois.

Une classe DeuxDes pour implémenter une méthode statique lancer pas besoin de créer 100.000 objets quand on peut en

réinitialiser un seul (la classe) les champs premier et second et les méthodes d'accès sont là

pour le fun appel à la classe Math transtypage pour obtenir un effet d'arrondi (vers le bas)



Page 110

public class AppLancer{public static void main(String [] args){int [] stat = new int [11];System.out.println("Combien de lancers?\n");int i = Clavier.lireInt();for (int j=0; j<i; j++){stat[DeuxDes.lancer()-2]++;

} if(i>0){System.out.println("\nRésultats après " + i + " lancers:\n");for (int j=0; j<11; j++){ System.out.println(Integer.toString(j+2) + ": \t" + stat[j] + "\t soit " +100*stat[j]/i+ "%");}

} else{

System.out.println("Aucun lancer!"); }}

}

class DeuxDes{private static int premier;private static int second;public static int lancer(){premier = (int)(Math.random()*6)+1;second = (int)(Math.random()*6)+1;return premier + second;

}public static int getPremier(){return premier;

}public static int getSecond(){return second;

}}



Page 111

A propos des E/S...

L'utilisation d'un environnement type "ligne de commande" peut s'avérer restrictif à terme.

A ce stade de connaissance du langage, il peut être fait usage de quelques méthodes statiques de certaines classes graphiques. Les classes graphiques sont issues de deux packages:

java.awt (plus ancien) javax.swing

La méthode statique showInputDialog de la classe JOptionPane affiche une boîte de dialogue attendant un input de l'utilisateur.

La méthode showMessageDialog produit un output dans une boîte de dialogue



Page 112

Illustration naïveimport javax.swing.*;

public class EntreeDeDonnees{


String nom = JOptionPane.showInputDialog("Quel est votre prénom?");JOptionPane.showMessageDialog(null,"Bienvenue au cours Java, " + nom + ".");System.exit(0);

}}

Une instruction explicite de sortie du programme est nécessaire lorsque des classes graphiques sont utilisées.



Page 113

Héritage

Motivation le regroupement d'objets en classes ne suffit pas

besoin de descriptions plus fines besoin de modifier certains comportements

réutilisation ne pas tout inventer mais plutôt améliorer l'existant

Localisation dans un énoncé relations de type "...est un…", "...est une…"

un carré est un quadrilatere un compte épargne est un(e sorte de) compte

à ne pas confondre avec les relations de type "…a un…", "…a une…"

un cercle a un centre (qui est un point) une planète a un satellite (qui est aussi une planète)



Page 114

Spécialisation...

Une classe qui hérite d'une autre classe la spécialise plus de champs

les objets de la classe CompteCourant auront un champ decouvertAutorise, par exemple

plus de méthodes et/ou des constructeurs spécifiques la classe CompteEpargne définira une méthode calculInteret,

par exemple des méthodes modifiées

la méthode calculPerimetre de la classe Carre peut être redéfinie plus simplement (ou effectuer le calcul sur d'autres bases)



Page 115

…et généralisation

Une classe dont une autre classe hérite la généralise. Parfois on se rend compte que plusieurs classes peuvent

avoir des états et des comportements communs. Une classe Quadrilatere peut généraliser des classes comme

Carre, Rectangle, Losange,… Les classes de généralisation sont assez souvent abstraites

Elles ne sont pas complètement implémentées mais on veut pouvoir tirer profit de la généralisation en invoquant des comportements dont la sémantique est commune

• la méthode pour calculer sa surface, par exemple, pourrait être définie concrètement au niveau de chaque sous-classe

• on pourrait aussi en signaler l'existence (sans la décrire) à plus haut niveau



Page 116

Vocabulaire

On parle de sous-classe pour désigner la classe qui hérite superclasse pour désigner la classe dont hérite une classe

donnée on dit d'une sous-classe qu'elle étend sa superclasse

En Java, il n'y a que de l'héritage simple une classe ne peut hériter de plusieurs classes différentes

Et l'héritage multiple alors? parfois utile, il est simulé par l'usage des interfaces une classe peut implémenter une ou plusieurs interfaces



Page 117

Surcharge vs remplacement La surcharge

(en anglais overloading) concerne la possibilité, pour une méthode, d'avoir plusieurs signatures.

m(int)m(String,int)

Le mécanisme d'héritage enrichit les possibilités de surcharge si les signatures sont différentes de celles qui existent déjà

m(String,String) Le remplacement

(en anglais overriding) concerne l'existence de la signature d'une méthode dans une classe plus élevée de la hiérarchie

m(int)



Page 118

Illustration de ces trois mécanismes Les classes

Personne Eleve (qui hérite de Personne) Residence

pour illustrer la composition dans Personne



Page 119

/* Illustration de l'héritage, de la surcharge et du remplacement */

class Personne{

protected final String nom;protected final String prenom;protected Residence r; //------------------------> Composition

public Personne(String nom){this.nom = nom;this.prenom = "";

}public Personne(String nom, String prenom){ //---> Surcharge

this.nom = nom;this.prenom = prenom;

}

public String toString(){return "Identité: " + nom + " " + prenom;

}}

class Residence{

private String rue;private String numero;private int codePostal;private String localite;

}



Page 120

class Eleve extends Personne{

private String classe;

public Eleve(String nom, String prenom, String c){super(nom, prenom);classe = c;

}

public String toString(){ //----------------------> Remplacementreturn "Identité " + nom + " " + prenom + "\nClasse: " + classe;

}}

public class AppHSR{/** Classe d’application */

public static void main(String [] args){/** Création de trois objets: */

Eleve e = new Eleve("Vandeput", "", "5TTr");Personne p1 = new Personne("Vandeput");Personne p2 = new Personne("Vandeput", "Etienne");

// Impression des objets comme chaînes de caractèresSystem.out.println(e + "\n\n" + p1 + "\n\n" + p2 + "\n");

}}



Page 121

Commentaires

Modification de l'accès aux champs nom et prenom nécessaire pour que la classe Eleve puisse accéder aux

champs de la classe Personne protected donne un accès aux classes qui héritent de la

classe Personne (et à celles qui sont dans le même package - voir plus loin)

Le constructeur de la classe Eleve fait appel à celui de la classe Personne

Chaque fois qu'elle est redéfinie, la méthode toString vient en remplacement pour rappel, elle existe déjà au niveau de la classe Object



Page 122

Les inconvénients du M.A. protected Une faille dans le système Le programmeur peut faire hériter de cette classe, une

classe qu'il construit. De cette façon, il a un accès direct aux champs de la classe Infraction au principe d'encapsulation A utiliser avec modération...



Page 123

Constructeurs et héritage En l'absence d'un appel à un constructeur spécifique de la

superclasse (comme dans l'exemple précédent) appel au constructeur sans argument de la superclasse

il existe OK il n'existe pas et il n'y en a pas d'autres OK il n'existe pas mais il y en a d'autres KO

S'il y a appel spécifique à un constructeur de la superclasse, il doit précéder toutes les autres instructions.

Il est également possible d'appeler un autre constructeur de la classe.

Exemples



Page 124

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

A a = new A();B b = new B(2);System.out.println(a + "\n" + b);

}}

class A{int x;

A(){System.out.println("Un objet A est construit.");


return "x: " + x;}

}

class B extends A{int y;

B(int y){this.y = y;


return "x: " + x + "\t" + "y: " + y;}

}



Page 125

Commentaires

L'existence d'un constructeur sans argument dans la définition de la classe A évite une erreur de compilation conséquence: le message "Un objet A est construit" s'affiche

même lors de la création d'un objet de type B La méthode toString de la classe A remplace celle de la

classe Object, celle de la classe B remplace celle de la classe A.

La substitution d'un constructeur avec argument à celui sans argument dans A nous oblige à quelques corrections.

Illustration



Page 126

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

A a = new A(5);B b = new B(2,4);System.out.println(a + "\n" + b);

}}

class A{int x;

A(int x){this.x = x;


return "x: " + x;}

}

class B extends A{int y;

B(int x, int y){super(x); // Appel explicite d’un constructeur de A

this.y = y;}public String toString(){

return "x: " + x + "\t" + "y: " + y;}

}



Page 127

Un exercice pour se distraire Construction d'une pile

exemple des assiettes les principales actions

empiler dépiler vérifier si la pile est vide obtenir une copie de l'élément en haut de la pile



Page 128

Le polymorphisme (1)

Idée les membres d'une classe ayant hérité d'une autre classe

peuvent être déclarés comme faisant partie de cette dernière (ou d'une classe située plus haut dans le graphe d'héritage)

class A{void m(){

…}

class B extends A{…

}…A b = new B();…b.m();...

on peut donc invoquer sur un objet de la sous-classe une méthode définie à un niveau supérieur

…puisque la sous-classe en hérite ou la redéfinit



Page 129


L'inverse n'est pas possible un directeur est aussi un enseignant mais un enseignant n'est

pas nécessairement un directeur Enseignant e = new Directeur(); // OK Directeur d = new Enseignant() // KO

d étant un objet dont le type réel est Enseignant, il est impossible de lui demander d'effectuer des traitements spécifiques aux directeurs



Page 130


Mécanisme le compilateur recherche la signature de la méthode à partir

du type déclaré de l'objet (souvent, une classe de niveau supérieur dans le graphe d'héritage)

à l'exécution, l'interpréteur recherche une méthode qui a cette signature en commençant sa recherche dans la classe elle-même et en remontant dans la hiérarchie si nécessaire

Avantage le programmeur est libéré d'une partie du travail il s'occupe des généralités (et peut faire confiance à

l'interpréteur pour les spécificités)



Page 131

Liaisons statiques et dynamiques Méthode déclarée static (ou private ou final)

le compilateur sait que cette méthode ne sera pas redéfinie à plus bas niveau

il peut donc insérer le code de la méthode dans la séquence des opérations à effectuer

Méthode ne possédant aucune de ces limitations l'interpréteur fera le choix de la méthode en fonction du type

réel de l'objet à l'exécution Ex: on définit un tableau de formes (la classe Forme possédant

une méthode dessineToi)On initialise ce tableau avec des formes diverses (carrés, rectangles, cercles,…)Une boucle parcourt le tableau en demandant à chaque forme de se dessiner. Les méthodes utilisées pourront être différentes d'un élément du tableau à l'autre.



Page 132

Exercices

Héritage et constructeurs Polymorphisme Résolution de surcharge et choix de la bonne méthode à

l'interprétation



Page 133



A a1 = new A();A b1 = new B();A b2 = new B(5);A a2 = new B(-1);

System.out.println(a1.valeur);System.out.println(b1.valeur);System.out.println(b2.valeur);System.out.println(a2.valeur);

}}

class A{

int valeur;}

class B extends A{

B(){valeur=100;

}

B(int v){valeur = valeur + v;

}}



Page 134

public class Hierarchie1{


Parallelogramme p = new Parallelogramme();Rectangle r = new Rectangle();Carre c = new Carre();Quadrilatere q = new Quadrilatere();Triangle t = new Triangle();Polygone g = new Polygone();Forme f = new Forme();

p.seDefinir();r.seDefinir();c.seDefinir();q.seDefinir();t.seDefinir();g.seDefinir();f.seDefinir();System.out.println();

f = c;g = r;q = p;

f.seDefinir();g.seDefinir();q.seDefinir();

}}



Page 135

class Forme{

public void seDefinir(){System.out.println("Je suis une forme.");

}}

class Polygone extends Forme{

public void seDefinir(){super.seDefinir();System.out.println("Je suis aussi un polygone.");

}}

class Triangle extends Polygone{}

class Quadrilatere extends Polygone{}

class Carre extends Quadrilatere{public void seDefinir(){

System.out.println("Je suis un carré.");}

}

class Rectangle extends Quadrilatere{public void seDefinir(){

super.seDefinir();System.out.println("Je suis aussi un rectangle.");

}}

class Parallelogramme extends Quadrilatere{}



Page 136

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

A a = new A(); A b = new B(); A c1 = new C();C c2 = new C(); B d1 = new D(); A d2 = new D();

a.m("Hello",5);a.m(5,"Hello");a.m(5,10);a.m("5",10);b.m(5,"Hello");b.m(5,10);c1.m(5,10);c1.m(5,"Hello");c2.m(5,10);d1.m(5,"Hello");d2.m("Hello",5);d2.m(5,10.f);d2.m(5.f,10);

}}

class A{void m(String s, int i){

System.out.println("Dans A: m(String , int)\t" + s + "\t" + i);}void m(int i, String s){

System.out.println("Dans A: m(int, String)\t" + i + "\t" + s);}void m(int i1, int i2){

System.out.println("Dans A: m(int, int)\t" + i1 + "\t" + i2);}void m(float f1, float f2){

System.out.println("Dans A: m(float, float)\t" + f1 + "\t" + f2);}

}



Page 137

class B extends A{

void m(int i, String s){System.out.println("Dans B: m(int, String)\t" + i + "\t" + s);

}

void m(float f, int i){System.out.println("Dans B: m(float, int)\t" + f + "\t" + i);

}}

class C extends A{

void m(int i1, int i2){System.out.println("Dans C: m(int, int)\t" + i1 + "\t" + i2);

}}

class D extends B{

void m(int i1, int i2){System.out.println("Dans D: m(int, int)\t" + i1 + "\t" + i2);

}

void m(int i, String s){System.out.println("Dans D: m(int, String)\t" + i + "\t" + s);

}}



Page 138

Les structures de contrôle Alternative, sélective, répétitives Pas toujours nécessaires en fonction de la modélisation

adoptée Ex1: le problème de la sélection de la méthode selon le type

d'objet de la forme est résolu par le polymorphisme et le graphe d'héritage

Ex2: il existe des interfaces "itérateurs" qu'il est possible d'utiliser pour éviter l'écriture de structures répétitives

La décision est à prendre en fonction de la complexité du problème



Page 139

Alternative simple

if (p1.equals(p2)){System.out.println("Ces deux points ne définissent pas une droite!");

}else{

Droite d = new Droite(p1,p2);System.out.println("La droite d a pour équation: ", d);

}



Page 140

Sélectif

switch (valeur_entière){

case valeur1:bloc_de_traitement1

case valeur2:bloc_de_traitement2

...

default:bloc_de_traitement_par_défaut

}



Page 141

Commentaires

Valeur entière pour le paramètre Traitement par défaut

valeur non trouvée Pas de traitement

si valeur non trouvée et pas de traitement par défaut Interruption à préciser chaque fois si nécessaire

break Une valeur de retour provoque l'interruption



Page 142

public class H2D{


String car = Clavier.lireString();if (car.length()!=1){

System.out.println("ERREUR: un seul caractère");}else{

char c=car.charAt(0);int val=deci(c);if(val!=-1){

System.out.println("Valeur du caractère:" + val);}

}}

public static int deci(char c){

switch(c){

case '0': case '1': case '2': case '3': case '4':case '5': case '6': case '7': case '8': case '9':

return c-'0';case 'A': case 'B': case 'C': case 'D': case 'E':case 'F':

return c-'A'+10;case 'a': case 'b': case 'c': case 'd': case 'e':case 'f':

return c-'a'+10;default:

System.out.println("Ce caractère n’est pas employé en hexadécimal");return (-1);

}}

}



Page 143

Répétitives

Boucle à parcourir éventuellement 0 fois

tant qu'une condition est vérifiée while

au moins une fois jusqu'à ce qu'une condition soit vérifiée do

…while

un nombre connu de fois détermination possible de ce nombre sur base d'une valeur

initiale et d'une valeur finale for



Page 144

whilewhile (expression_booléenne){

bloc_de_traitement}

public class BoucleWhile{


int i = 0;

while (i++<8){

System.out.println("Bienvenue à la séance " + i + " du cours Java.");

}

}

}



Page 145

do - while

dobloc_de_traitement

while (expression_booléenne);

public class BoucleDoWhile{


int i = 1;do

System.out.println("Bienvenue à la séance " + i + " du cours Java.");while (i++<5);

}}



Page 146

forfor (initialisations; expression_booléenne; incrémentations){

bloc_de_traitement{

public class BoucleFor{


for(int i=1;i<=8;++i){System.out.println("Bienvenue à la séance " + i + " du cours Java.");

}}

}



Page 147

Richesse syntaxique de la structure for Initialisation possible de plusieurs variables

il est possible de tout écrire en arguments Incrémentation possible de plusieurs variables

au sens large x /= 2 est une incrémentation au sens large x diminue

Exemplepublic static int pD2(int valeur){

int exp;

for(exp=0, valeur-=1; valeur>0; exp++, valeur/=2){

}

return exp;

}

}



Page 148

Les interruptions du flux normal d'exécution break

pas seulement pour la structure switch permet de quitter le bloc courant possibilité de "s'échapper" davantage en travaillant avec des

étiquettes continue

renvoie l'exécution à la fin de la boucle nouvelle incrémentation nouveau test

return retour à l'appelant



Page 149

doint revenus = Clavier.lireInt() ;if(revenus<100000)

break;...

while(...);

taxation:do

int revenus = Clavier.lireInt() ;if(revenus<100000){

System.out.println("Pas de taxation");break taxation;

}...

while(...);



Page 150

Exercice

Le type abstrait Ensemble éléments de même type un même élément ne peut se répéter

Primitives ajouter, supprimer un élément vérifier l'appartenance d'un élément à un ensemble obtenir sa cardinalité

Implantation liste chaînée simple ou liste doublement chaînée



Page 151

Une piste intéressante

Le sitehttp://www.enseignement.polytechnique.fr/profs/informatique/

à voir en particulier: les pages de Jean Berstel et Jean-Eric Pin



Page 152

Un exercice d’échauffement! Imaginez ce qui se passera si on fournit les instructions de

droite au compilateur va-t-il rejeter des choses? s’il les accepte, pouvez-vous imaginer ce qu’il va créer dans la

mémoire et comment celle-ci va-t-elle évoluer?



Page 153

1. A x = new A();A y = new A();x.methode(y);

2. A x = new A();A y = new B();x.methode(y);

3. A x = new A();B y = new B();x.methode(y);

4. B x = new B();B y = new B();x.methode(y);

5. A x = new B();B y = new B();x.methode(y);

6. B x = new B();B y = new A();x.methode(y);

class A{

A autre;

void methode(A v){autre = new A();

}}

class B extends A{

int valeur;

void methode(A v){super.methode(v);valeur++;

}

void methode(B v){autre = v;

}}



Page 154

Autres mécanismes

Outre les mécanismes fondamentaux et incontournables... Encapsulation Héritage Polymorphisme

…il existe d'autres concepts qui s'avèrent utiles dans certaines circonstances particulières Classes (et méthodes) abstraites Interfaces Classes internes, anonymes



Page 155

Classes abstraites

Sorte de conséquence du processus de généralisation définir des classes et, dans ces classes, des méthodes dont la

description d'une implémentation serait hâtive une classe Forme une méthode calculDuPerimetre

Idée déclarer sans définir

pas d'accolades, juste une signature et des modificateurs d'accès

intérêt pour le développement: on sait que la méthode existe (sera implémentée) et on peut s’en servir

à combiner avec le polymorphisme



Page 156

Exemple

Trinôme du second degré on souhaite

disposer des valeurs des racines quand elles existent vérifier si une valeur se situe entre les racines quand la question

a du sens ...

plusieurs sortes de trinômes... avec deux racines avec racine double sans racines

…et si on souhaite travailler avec les nombres complexes avec racines complexes



Page 157

Observation sur l'héritage Un graphe d'héritage n'est pas nécessairement synonyme

de "partition de la classe d'héritage" il n'est pas obligatoire de retrouver toutes les possibilités

héritent de Quadrilatere: Carre, Rectangle et le reste? pas nécessairement utile

certaines classes ayant hérité peuvent correspondre à des situations identiques mais dont le choix est lié à des traitements différents

un trinôme sans racine est aussi un trinôme ayant deux racines complexes

selon les traitements escomptés, l'objet créé sera l'un ou l'autre



Page 158

Problème du trinôme

Idée définir les méthodes au niveau de la classe Trinome tous les objets sont des trinômes mais au moment d'en créer

un, on choisit sa spécificité (polymorphisme) Difficulté

les méthodes comme calculerRacines, estEntreRacines,… ne peuvent être définies au niveau de la classe Trinome

Solution elles sont déclarées mais pas définies classes abstraites



Page 159

Syntaxe

Utilisation du mot-clé abstract dans la déclaration de la méthode et donc, obligatoirement, dans la déclaration de la classepublic abstract class Trinome{

protected double a, b, c;

...

public abstract void calculerRacines();

...

}



Page 160

Remarques

Dès qu'une méthode est abstraite, la classe qui en contient la déclaration l'est aussi. le mot-clé abstract est donc nécessaire pour les deux

sinon erreur à la compilation La déclaration de la méthode abstraite s'arrête après la

signature de la méthode. Une classe abstraite ne peut être instanciée. Des méthodes d'une classe abstraite peuvent être

concrètes. une méthode getValeurDeA, par exemple

Une classe d'héritage ne devient concrète que si elle ne comprend plus aucune méthode abstraite.



Page 161

Créer des objets en ignorant de quel type! Le code de la méthode main ci-dessous illustre la création

de trinômes. Le programmeur qui rédige ce code ne sait de quel type

véritable sera chaque objet.

public class AppAbstract{


Trinome t1 = Trinome.creer(1.,2.,1.);

Trinome t2 = Trinome.creer(1.,-1.,1.);

Trinome t3 = Trinome.creer(1.,5.,6.);

t1.calculerRacines();



}

}



Page 162

Une classe Rho pour éviter les types primitifs

class Rho{

private double valeur;

public Rho(double a, double b, double c){

valeur = b*b - 4*a*c;

}

public double getValeur(){

return valeur;

}

}



Page 163

abstract class Trinome{

protected double a, b, c;Rho d;

public Trinome(double a, double b, double c, Rho d){this.a = a;this.b = b;this.c = c;this.d = d;

}

public static Trinome creer(double a, double b, double c){Rho d = new Rho(a,b,c);if (d.getValeur()<0){

return new TrinomeSansRacine(a,b,c,d);}else{

if (d.getValeur()==0){return new TrinomeAvecRacineDouble(a,b,c,d);

}else{

return new TrinomeAvecDeuxRacines(a,b,c,d);}

}}

public abstract void calculerRacines();}



Page 164

Héritage

Trois classes étendent la classe Trinome et la concrétisent TrinomeSansRacine TrinomeAvecRacineDouble TrinomeAvecDeuxRacines

Les constructeurs de ces classes font appel aux constructeur de la classe Trinome essentiellement pour le remplissage des champs de données la méthode abstraite calculerRacines est implantée dans

chacune d'entre elles de manière différente



Page 165

class TrinomeSansRacine extends Trinome{

public TrinomeSansRacine(double a, double b, double c, Rho d){super(a,b,c,d);

}

public void calculerRacines(){System.out.println("Il n'y a pas de racines réelles.");

}}

class TrinomeAvecRacineDouble extends Trinome{

public TrinomeAvecRacineDouble(double a, double b, double c, Rho d){super(a,b,c,d);

}

public void calculerRacines(){System.out.println("La racine double est " + (-b/2*a));

}}

class TrinomeAvecDeuxRacines extends Trinome{

public TrinomeAvecDeuxRacines(double a, double b, double c, Rho d){super(a,b,c,d);

}

public void calculerRacines(){System.out.println("Les racines sont " + (-b+Math.sqrt(d.getValeur()))/(2*a) + " et " + (-b-Math.sqrt(d.getValeur()))/(2*a) + ".");

}}



Page 166

Observation

La méthode statique créer de la classe abstraite Trinome est intéressante elle permet de créer des objets de types réels différents en

fonction de la valeur du discriminant on n'évite pas l'utilisation de structures de sélection mais c'est

uniquement pour la création des objets le programmeur de la méthode main invoque cette méthode

pour créer des objets dont il pourrait ne pas connaître le type et invoquer les méthodes de la classe Trinome sur ces objets



Page 167

Intérêt d'une telle approche Adaptabilité?

première amélioration souhaitée on souhaite parfois pouvoir calculer des racines complexes on aimerait disposer d'une méthode qui examine si une valeur

donnée se trouve ou non entre les valeurs des racines éventuelles

Création d'une classe supplémentaire qui étend la classe Trinome pas de conflit avec la classe TrinomeSansRacine

la décision de construire un objet de tel ou tel type est prise dans la méthode creer de Trinome

le problème est réglé par l'ajout d'un paramètre booléen à la signature de cette méthode



Page 168

Autre version de la méthode main Un paramètre a été ajouté à la méthode créer

public class AppAbstract2{


Trinome t1 = Trinome.creer(1,2,1,true);

Trinome t2 = Trinome.creer(1,-1,1,true);

Trinome t3 = Trinome.creer(1,-1,1,false);

Trinome t4 = Trinome.creer(1,5,6,true);





}

}



Page 169

Modification de la méthode creerpublic static Trinome creer(double a, double b, double c, boolean complexe){

Rho d = new Rho(a,b,c);

if (d.getValeur()<0){

if (complexe){

return new TrinomeAvecRacinesComplexes(a,b,c,d);

}

else{

return new TrinomeSansRacine(a,b,c,d);

}

}

else{

if (d.getValeur()==0){

return new TrinomeAvecRacineDouble(a,b,c,d);

}

else{

return new TrinomeAvecDeuxRacines(a,b,c,d);

}

}

}



Page 170

Nouvelle classeclass TrinomeAvecRacinesComplexes extends Trinome{

public TrinomeAvecRacinesComplexes(double a, double b, double c, Rho d){

super(a,b,c,d);

}

public void calculerRacines(){

System.out.println("Les racines complexes sont " +

((-b+Math.sqrt(-d.getValeur()))/2*a) + "i et " +

((-b-Math.sqrt(-d.getValeur()))/2*a) + "i.");

}

}



Page 171

Exercice

Une deuxième amélioration est souhaitée: on voudrait savoir si une valeur donnée est ou non située

entre les racines éventuelles d'un trinôme développer une méthode estEntreRacines renvoyant une valeur

booléenne sur base de la fourniture d'une valeur numérique on admet que s'il n'y a pas de racine réelle, la valeur renvoyée

est false suggestion:

définir une classe Racine et modifier les méthodes concernées un objet de type Trinome possèdera deux champs de type

Racine; les champs pointeront "dans le vide" si les racines réelles n'existent pas



Page 172

Les interfaces

Ce concept fait penser à celui de moyen de communication. Exemple: comment faire pour lier une application comme

toutes celles que nous avons développées jusqu'ici, à une interface graphique

! Interface n'est pas synonyme d'interface graphique ! Mais les interfaces graphiques tirent profit du concept plus

général d’interface Une première définition:

sorte de classe abstraite (mais complètement, ç-à-d. toutes les méthodes sont abstraites) et ne possédant pas instances et déclarant une espèce de contrat qui sera véritablement réalisé par toutes les classes qui l'implantent



Page 173

Interfaces vs classes abstraites Pourquoi des interfaces alors qu'il existe des classes

abstraites? dans une interface, toutes les méthodes sont abstraites dans une classe abstraite, certaines méthodes peuvent être

concrètes est des champs d'instance peuvent être définis Pourquoi ne pas remplacer les interfaces par des classes

abstraites sans champs d'instance et ne comprenant que des méthodes abstraites? un autre mécanisme est recherché: celui de l'héritage multiple une classe ne peut hériter que d'une seule autre classe une classe pourra implanter plus d'une interface



Page 174

Syntaxe et observations

interface Forme{

public abstract double surface();

public abstract double volume();

}

Toute interface a un accès public ce mot-clé est donc inutile devant le mot Interface les méthodes sont, de manière automatique, abstraites et

d'accès public les mots-clés public et abstract sont donc également inutiles

Une interface peut en étendre une autre héritage d'interface



Page 175

Classe implantant une interfaceclass Point implements Forme{

private double x, y;

... // autres champs, constructeurs et méthodes

public double surface(){

return 0.0;

}

public double volume(){

return 0.0;

}

}



Page 176

Autre exempleclass Carre implements Forme{

private final String nom;private double cote;

public Carre(String n, double c){nom = n;cote = c;

}

public double surface(){return cote*cote;

}public double volume(){

return 0.0;}public String getNom(){

return nom;}

}



Page 177

Détails

Pas de champs d'instance, mais possibilité de définir des constantes si un groupe de constantes est régulièrement utilisé par les

classes de certaines applications, il est possible de définir ces constantes dans une interface sans nécessairement y ajouter de méthodes

chaque classe qui voudra les utiliser n'aura qu'à implanter cette interface sans méthodes

Les noms portés par les interfaces sont souvent des adjectifs. Ex: les interfaces Clonable et Comparable du package

java.lang



Page 178

Interface et héritage multiple Une classe ne peut hériter que d'une seule autre mais peut

implanter plusieurs interfaces dans ce cas, elle devra remplir le contrat déclaré par chacune

des interfaces le "Canada dry" de l'héritage multiple

ça en a le goût, mais ça n'en est pas, notamment parce que des champs d'instance ne peuvent être hérités

Lorsqu'une classe implante plusieurs interfaces, on est sûr de pouvoir invoquer n'importe quelle méthode de n'importe laquelle de ces interfaces sur les objets de cette classe



Page 179

Exemple d’héritage multiple L'interface Clonable de java.lang ne comprend pas de

méthode son implantation par une classe assure simplement que la

méthode clone de Object pourra être utilisée L'interface Comparable de java.lang comprend la seule

méthode compareTo voir les recommandations

class MaClasse implements Comparable, Clonable{

public int compareTo(Object o){

...

}

...

}



Page 180

Interface graphique et événements Une première approche

nécessité, pour des applications interactives utilisant des interfaces graphiques, de s'intéresser aux événements

clic de souris modification du contenu d'une zone de texte choix d'un item dans une liste temps qui passe …

le modèle des événements en (trop) bref n'importe quelle classe peut implanter l'interface ActionListener

comprenant la méthode actionPerformed les instances d'une telle classe seront nécessairement des

"écouteurs" qui réaliseront l'action décrite dans actionPerformed à chaque réception de message de la part d'un objet dont il est à l'écoute



Page 181

Principe

Les objets écouteurs sont des instances de classes qui doivent implanter l'interface ActionListener Nécessité de décrire la méthode actionPerformed dans les

classes d'implantation Certains objets, tels les objets graphiques, peuvent se voir

attribuer une liste d'objets écouteurs méthode addActionListener ou passage d'un paramètre

(comme pour un objet Timer) Les objets possédant des listes d'écouteurs envoient des

messages à ces écouteurs quand un événement particulier se produit

L'écouteur exécute la méthode actionPerformed



Page 182

Exemple rudimentaire

Toutes les 5 secondes, un message affiche le temps écoulé. Une boîte de dialogue permet d'interrompre le programme. Cette application provoque un affichage au niveau de la

fenêtre de l'OS. Elle sera améliorée par la suite.

Plusieurs packages sont nécessaires voir justification dans le code



Page 183

import java.util.*; // pour Dateimport java.awt.event.*; // pour ActionEvent et ActionListenerimport javax.swing.*; // pour JOptionPaneimport javax.swing.Timer; // pour éviter le conflit avec la classe Timer de java.util

public class AppChrono{


ActionListener chrono = new AfficheurDeTemps(); // Usage du polymorphismeTimer t = new Timer(5000,chrono);t.start();JOptionPane.showMessageDialog(null, "Fin du programme?");System.exit(0);

}}

class AfficheurDeTemps implements ActionListener{

private final Date topChrono = new Date();

public void actionPerformed(ActionEvent e){

Date now = new Date();System.out.println("Temps écoulé: " + (now.getTime() - topChrono.getTime())/1000+ " secondes");

}}



Page 184

Intérêt des interfaces Ingénierie logicielle

Souhait de développer séparément les classes correspondant aux écrans de saisie et d'affichage l'application qui traite les données fournies via ces écrans de saisie et qui

y affiche les résultats Association des deux, faite par le biais d'objets Intérêt des interfaces pour ne pas perdre des opportunités de

réutiliser et d'adapter, les interfaces définissent le contrat à remplir par les objets sans savoir de

quels objets il s'agit (pourvu que leur implémentation répond au contrat) En Java

Utilité des interfaces également pour le fonctionnement du modèle des événements

voir exemple qui suit



Page 185

De plus…

Le polymorphisme, les classes abstraites, les interfaces des outils pour abstraire les problèmes en évitant de tout

savoir à propos des objets concernés lorsqu'on doit traiter avec un objet, et si c'est possible, il vaut

mieux le considérer comme un objet d'une superclasse que sa classe étend ou comme une interface que sa classe implante

des outils au service de la souplesse des programmes



Page 186

Le modèle des événements en Java Des événements

qui seront généralement des objets de classes prédéfinies possédant champs et/ou méthodes

Des sources d'événements autres objets de classes prédéfinies: bouton, champ texte,

case à cocher, chronomètre,… Des écouteurs

objets de n'importe quelles classes pourvu qu'elles implantent une ou plusieurs interfaces spécifiques…

ActionListener, MouseListener, FocusListener,… ...ou qu'elles étendent une classe particulière

WindowAdapter, MouseAdapter,...



Page 187

Principe Une source d'événements possède une liste d'écouteurs

d’événements. Plusieurs techniques permettent d'ajouter des objets

écouteurs à la liste d'une source: méthodes (addActionListener, addMouseListener,…) passage de paramètres à la création de l'objet source

Lorsque la source détecte un événement, il crée un objet événement particulier et envoie un message à ses écouteurs avec cet objet événement comme paramètre. ActionEvent, MouseEvent, FocusEvent,…

L'écouteur (dont la classe implante des interfaces et/ou étend une classe) exécute la méthode concernée. interface implantée ActionListener + événement ActionEvent

méthode actionPerformed



Page 188

Hiérarchies

D'événements AWTEvent

ActionEvent MouseEvent ...

De classes graphiques Frame

JFrame …

Pas toujours simple de s'y retrouver !



Page 189

Exemple Une boîte de dialogue se compose d'un champ texte

précédé d'une étiquette (label) destiné à contenir un nombre entier et d'un bouton dont la pression doit permettre de vérifier si le nombre est un multiple de 7 ou non.

Le résultat est affiché sous forme d'une étiquette. La source:

le bouton L'événement

une pression de ce bouton L'écouteur

un objet d'une classe à créer Comme il faut créer une boîte de dialogue, il est commode

de faire de cette boîte, l'objet écouteur.



Page 190

Plusieurs versions Une boîte de dialogue pour détecter les multiples de 7

version 1 pas de contrôle de fermeture de la fenêtre pas de test sur le format des nombres

version 2 contrôle de fermeture de la fenêtre

version 3 modification du contrôle de fermeture (classe anonyme) test sur le format des nombres

version 4 (suppression du bouton) autres types d'événements

• validation ou perte de focus version 5

mise à jour automatique



Page 191

Les classes utiles

JFrame symbolise un cadre à l'écran (avec barre de titre) un cadre ne peut être rempli directement

Container symbolise un conteneur de divers éléments graphiques

FlowLayout symbolise un gestionnaire de mise en page

le plus simple: les éléments se suivent JTextField, JButton, JLabel

champ texte, bouton et étiquette

Voir classes, héritages, constructeurs et méthodes



Page 192

Concrètement Création d'une classe BoiteMultiple qui implante

ActionListener la boîte de dialogue sera l'écouteur

possibilité de faire autrement le constructeur de cette classe construit aussi l'interface

graphique il ne suffit pas de créer les éléments de la boîte, il faut les

ajouter au conteneur la boîte ne s'affiche pas sans une instruction pour la rendre

visible• à placer dans le constructeur ou dans la classe

application obligation d'implanter la méthode actionPerformed

examiner par quel élément l'événement a été produit et, le cas échéant, effectuer le traitement nécessaire



Page 193

import java.awt.*; // Container, FlowLayoutimport java.awt.event.*; // ActionEventimport javax.swing.*; // JFrame, JButton, JTextField, JLabel

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

BoiteMultiple bm = new BoiteMultiple();bm.setVisible(true);

}}

class BoiteMultiple extends JFrame implements ActionListener {

JButton b;JTextField jt;JLabel lm;

// Construction de la boîte de dialoguepublic BoiteMultiple(){

// Paramétrage de la fenêtresetTitle("Multiple de 7?");setSize(450,80);setLocation(300,300);

// Obtention d'une référence vers le conteneurContainer c = getContentPane();



Page 194

// Création d'un gestionnaire de mise en page pour le conteneurFlowLayout fl = new FlowLayout();c.setLayout(fl);

// Création des composants de la fenêtreJLabel ln = new JLabel("Nombre à examiner:");jt = new JTextField(8);b = new JButton("Vérifier");lm = new JLabel("Multiple de 7: ");

// Ajout des composants au conteneurc.add(ln);c.add(jt);c.add(b);c.add(lm);

// Ajout de l'objet courant à la liste des écouteurs du boutonb.addActionListener(this);

}

// Implantation de la méthode d'écoutepublic void actionPerformed(ActionEvent ae){

if (ae.getSource()==b){int n = Integer.parseInt(jt.getText());if (n % 7 == 0) lm.setText("Multiple de 7: " + "oui");else lm.setText("Multiple de 7: " + "non");

}}

}



Page 195

Variante

Autre écouteur... créer une classe EcouteBouton y déplacer la méthode actionPerformed créer un objet de ce type dans la classe application et le

passer en paramètre au constructeur qui l'ajoutera dans la liste des écouteurs du bouton



Page 196

import java.awt.*;import java.awt.event.*;import javax.swing.*;

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

BoiteMultiple bm = new BoiteMultiple();bm.setVisible(true);EcouteFenetre ef = new EcouteFenetre();bm.addWindowListener(ef);

}}








Page 197

// Création d'un gestionnaire de mise en page pour le conteneurFlowLayout fl = new FlowLayout();c.setLayout(fl);// Création des composants de la fenêtreJLabel ln = new JLabel("Nombre à examiner:");jt = new JTextField(8);b = new JButton("Vérifier");lm = new JLabel("Multiple de 7: ");// Ajout des composants au conteneurc.add(ln);c.add(jt);c.add(b);c.add(lm);// Ajout de l'objet courant à la liste des écouteurs du boutonb.addActionListener(this);

}


if (ae.getSource()==b){int n = Integer.parseInt(jt.getText());if (n % 7 == 0) lm.setText("Multiple de 7: " + "oui");else lm.setText("Multiple de 7: " + "non");

}}

}

class EcouteFenetre extends WindowAdapter {public void windowClosing(WindowEvent we){

System.exit(0);}

}



Page 198

Autres variantes

Terminer proprement l'application détecter l'événement de fermeture de la boîte dialogue créer une classe qui étend WindowAdapter et donc implante

la méthode windowClosing Utiliser une classe anonyme pour ne pas multiplier

inutilement le nombre de classes Contrôler la saisie Valider de plusieurs manières Feed-back immédiat



Page 199

import java.awt.*;import java.awt.event.*;import javax.swing.*;

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

BoiteMultiple bm = new BoiteMultiple();bm.setVisible(true);bm.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent we){System.exit(0);

}});

}}








Page 200


// Création des composants de la fenêtreJLabel ln = new JLabel("Nombre à examiner:");jt = new JTextField(8);b = new JButton("Vérifier");lm = new JLabel("Multiple de 7: ");

// Ajout des composants au conteneurc.add(ln);c.add(jt);c.add(b);c.add(lm);

// Ajout de l'objet courant à la liste des écouteurs du boutonb.addActionListener(this);

}


if (ae.getSource()==b){try{

int n = Integer.parseInt(jt.getText());if (n % 7 == 0) lm.setText("Multiple de 7: " + "oui");else lm.setText("Multiple de 7: " + "non");

}catch(NumberFormatException nfe){

jt.setText("");lm.setText("Multiple de 7: ");

}}

}}



Page 201

class BoiteMultiple extends JFrame implements ActionListener, FocusListener {

JTextField jt;JLabel lm;





// Création des composants de la fenêtreJLabel ln = new JLabel("Nombre à examiner:");jt = new JTextField(8);lm = new JLabel("");

// Ajout des composants au conteneurc.add(new JButton("OK")); // Bouton inutile, pour tester la perte de focusc.add(ln);c.add(jt);c.add(lm);

// Ajout de l'objet courant à la liste des écouteurs du champ textejt.addActionListener(this);jt.addFocusListener(this);

}



Page 202

// Implantation des méthodes d'écoute

// Pour l'interface ActionListenerpublic void actionPerformed(ActionEvent ae){

mettreAJour();}

// Pour l'interface FocusListenerpublic void focusGained(FocusEvent fe){}

public void focusLost(FocusEvent fe){mettreAJour();

}

// Méthode de mise à jour (économie d'échelle)public void mettreAJour(){

try{int n = Integer.parseInt(jt.getText());if (n % 7 == 0) lm.setText("Multiple de 7");else lm.setText(« Non multiple de 7");


jt.setText("");lm.setText("");

}}

}



Page 203

class BoiteMultiple extends JFrame implements DocumentListener {

JTextField jt;JLabel lm;





// Création des composants de la fenêtreJLabel ln = new JLabel("Nombre à examiner:");jt = new JTextField(8);lm = new JLabel("");

// Ajout des composants au conteneurc.add(ln);c.add(jt);c.add(lm);

// Ajout de l'objet courant à la liste des écouteurs du "document" associéjt.getDocument().addDocumentListener(this);

}



Page 204

// Implantation des méthodes d'écoute// Pour l'interface DocumentListenerpublic void insertUpdate(DocumentEvent de){

mettreAJour();}

public void changedUpdate(DocumentEvent de){}

public void removeUpdate(DocumentEvent de){mettreAJour();

}

// Méthode de mise à jour (économie d'échelle)public void mettreAJour(){

String s=jt.getText();try{

int n=Integer.parseInt(s);if (n % 7 == 0){

lm.setText("Multiple de 7");}else{

lm.setText("Non multiple de 7");}


jt.setText("");lm.setText("");

}}

}



Page 205

Traitement des exceptions Java (comme d'autres langages avant lui) prévoit un système

intéressant de traitement des erreurs toute erreur génère une exception les classes d'exceptions sont hiérarchisées il existe des exceptions vérifiées (peu)…

problème d'IO, par exemple le compilateur oblige le programmeur à prévoir leur traitement (fin

correcte du programme, par exemple) ... et des exceptions non vérifiées

que le programmeur est libre ou non de prendre en compte division par zéro, type incorrect,…

le programmeur peut aussi construire ses propres exceptions (throws) une structure sympathique: try… catch

try pour le bloc sensible catch pour le traitement à effectuer



Page 206

Applets: les bases

En Java Applications

méthode main Applets

méthode init la classe est fournie au navigateur, par le biais d’un document

HTML, qui se charge de la faire exécuter

<html><body><applet code=«Application1.class» width=«300» height=«200»></applet></body></html>



Page 207

Constructeur et méthode init Méthode init: exécutée au lancement de l’applet

Voir aussi start, stop et destroy Applet est une classe

Existence de constructeur Préférence accordée à la méthode init Une applet est un conteneur Transformation possible d’une application graphique en

applet



Page 208

import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*;

public class AppletBoutons extends JApplet implements ActionListener{

private JPanel panneau, panneauCommande;private JButton b1, b2;

public void init(){panneau=new JPanel();panneauCommande=new JPanel();Container c=getContentPane();c.add(panneau);c.add(panneauCommande,"South");b1=new JButton("green");b2=new JButton("red");b1.addActionListener(this);b2.addActionListener(this);panneauCommande.add(b1);panneauCommande.add(b2);panneau.setVisible(true);

}

public void actionPerformed(ActionEvent ae){if (ae.getSource()==b1){

panneau.setBackground(Color.green);}else{

panneau.setBackground(Color.red);}

}}



Page 209

Chrono version graphique Un exercice récapitulatif sur le modèle des événements Des améliorations par rapport à la version en ligne de

commande mise à jour du chronomètre toutes les secondes possibilité d’arrêter, de relancer, de mettre à zéro

Voir code



Page 210

Transformation en applet La classe Chronometre doit hériter de Japplet et plus de

JFrame. Classe unique

à l’écoute de tous les événements qui doit donc implémenter Actionlistener nécessité de travailler avec la méthode getSource pour

distinguer les traitements disparition des classes ChangeChrono et AfficheurDeTemps

La classe AppLayout doit disparaître. Voir code et démo



Page 211

Interfaces Java entreécrans et programme Écran graphique simple pour gérer le fonctionnement d'un

compteur un bouton permet de réaliser l'incrémentation et l'affichage de

la valeur s'effectue dans un champ texte Doit fonctionner aussi, à terme, pour des compteurs plus

spécifiques ou pour des classes d’objets qui ont au moins les fonctionnalités de base de ceux-ci.

Une version classique suivie par des versions avec interface qui montre que les écrans et leur gestion peuvent être réutilisés sans toucher à rien



Page 212

Première version: solution classique Classe Compteur

trois méthodes qui n'appellent pas de commentaires Classe EcranCompteur

un constructeur qui associe un compteur à l'écran construit

une méthode pour traiter l'événement Classe pour être à l’écoute de la fenêtre

gérer sa fermeture Voir code



Page 213

Variantes

Classe anonyme pour le contrôle de la fermeture de la fenêtre (2)

Utilisation d'une interface (3) un objet écran n'a besoin que d'un objet supportant cette

interface, peu importe son type il ne faut pas réécrire la classe EcranCompteur pour qu'elle

soit utilisable avec des objets d'autres classes que Compteur, pourvu que ces classes possèdent une description des méthodes de l'interface

Spécialisation par héritage de la classe Compteur (4) Utilisation de l'interface avec une autre classe d'objets (5)



Page 214

Les packages

Une organisation plus logique des classes et des interfaces. Ex: des classes représentant des écrans de l'IHM seront

regroupées dans un même package Cette organisation est au service du programmeur qui est

censé retrouver ces classes et ces interfaces plus aisément grâce à elle.

L'organisation des packages n'est en rien liée à l'héritage. une classe d'un package peut hériter d'une classe se trouvant

dans un autre package voir documentation des classes prédéfinies



Page 215

Nommage des classes et des packages Lors de la description d'une classe, on utilise un nom court.

class Point{...

Toute classe appartient à un package. déclaration en début de fichierpackage be.ac.fundp.det.eva.ecrans

Le nom complet d'une classe est constitué du nom de son package suivi de son nom court.be.ac.fundp.det.eva.ecrans.Point

Il existe un package par défaut (sans nom) lié à la machine virtuelle. permet d'éviter des instructions d'importation au début du

développement



Page 216

Identification des classes Le compilateur utilise les noms complets.

soit que le programmeur les mentionneeva.ecrans.Point = new eva.ecrans.Point();

plutôt contraignant mais parfois utile pour éviter une confusion• classes portant les mêmes noms (cfr Date, Timer,…)

soit qu'il peut les reconstituer importation d'un package completimport eva.ecrans.*; importation d'une seule classeimport eva.ecrans.Point possibilité de créer une arborescence de packagespackage eva.ecrans

package eva.ecrans.saisie

attention, pour importer ces 2 packages, il faut 2 instructionsimport eva.ecrans.*;

import eva.ecrans.saisie.*;



Page 217

Lien entre packages et file system Le classpath est déterminant.

le classpath est c:\jdk1.3.1_02\exemples\classes la classe Point3 doit être enregistrée dans un sous-dossier

eva\geometrie construit à partir du classpath c:\jdk1.3.1_02\exemples\classes\eva\geometrie

import eva.geometrie.Point3;

public class AppPackage{


Point3 p = new Point3(3,7);

System.out.println("Coordonnée de p: " + p);

}

}

la classe AppPackage se trouve dans le package par défaut elle est donc recherchée à partir du classpath



Page 218

Classes "système"

Les packages tels java.lang, java.util et autres packages de classes prédéfinies se cachent dans des fichiers compressés i18n.jar et rt.jar

Ces fichiers se trouvant dans des dossiers installés avec Java en ce qui nous concerne, c'est le dossier c:\jdk1.3.1_02\jre\lib\

Lorsque le programmeur le souhaite, il peut aussi archiver ses fichiers utilitaire jar

Une référence intéressante: http://java.sun.com/j2se/1.3/docs/tooldocs/findingclasses.html



Page 219

Garbage Collector

Ou collecteur d'ordures, ou éboueur ou ramasse-miettes… Les objets sont créés par l'instruction new(…) Dès qu'ils cessent d'être référencés, les objets sont

susceptibles d'êtres détruits ils ne le sont pas nécessairement immédiatement car cela

dépend des ressources disponibles en mémoire le garbage collector est une tâche de la plus basse priorité si des ressources sont mobilisées (un fichier, par exemple), il

est bon que le code provoque la libération de ces ressources, ce qui est possible par l'utilisation de la méthode finalize (héritée de la classe Object)

Documents

Passer à la première page Programmer avec des objets Etienne Vandeput Namur 2002 – 2003 - 2004 [email protected]