Programmer avec des objets

Programmer avec des objets
Etienne Vandeput Namur 2002 –

Who’s who? Vu que nous ne sommes pas nombreux… Attentes Background …
Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 … Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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,... Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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é. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

É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. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

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 telles public 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. Programmer avec des objets © CeFIS 2004

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; Programmer avec des objets © CeFIS 2004

Structure Un modificateur d'accès Le type du résultat s'il y en a un
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) ... Programmer avec des objets © CeFIS 2004

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); Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

Comment naissent les objets?
30/03/2017 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. Le constructeur par défaut est toujours appelé. Les autres « surchargent » le premier. Ex: Point() avec (1,1) plutôt que Point() avec (0,0) par défaut Les objets en mémoire… Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

Les constructeurs public class Point{ private int x; private int y;
30/03/2017 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; Ajouter un champ « nom » de type char ou String Programmer avec des objets © CeFIS 2004

Utilisation des constructeurs
30/03/2017 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 Un objet ou une classe peuvent créer un autre objet par le biais d’une de ses méthodes. Programmer avec des objets © CeFIS 2004

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 ... Programmer avec des objets © CeFIS 2004

Références Un exemple d’affectation utilisant des objets
30/03/2017 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; Ex: p1=p2 puis p1.setAbscisse(4), puis p2.getAbscisse() à proposer avant Programmer avec des objets © CeFIS 2004

Programme objet = conversation entre objets
30/03/2017 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 Schéma avec O1, O2,… Schéma avec Application1, Point, Cercle,… dans le « main »: crée un Point, crée un cercle, Cercle comprends-tu le Point… Programmer avec des objets © CeFIS 2004

30/03/2017 Un premier programme public class PremierProgramme{ public static void main(String [] args){ System.out.println("Bienvenue au cours Java!"); } La classe doit être déclarée public et être enregistrée dans un fichier qui porte le même nom. En Java: nom de la classe = nom du fichier Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Installer l'environnement de programmation Java
Télécharger à partir de 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) Programmer avec des objets © CeFIS 2004

Choix d'un éditeur TextPad, un éditeur semi-intelligent qui gère notamment la coloration syntaxique, l'indentation… disponible à l'essai sur 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: à 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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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é. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 ... Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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). Programmer avec des objets © CeFIS 2004

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; Programmer avec des objets © CeFIS 2004

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){…} } Programmer avec des objets © CeFIS 2004

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 Java public class Application1{ public static void main(String args[]){ System.out.println("Bienvenue au cours Java!"); } Programmer avec des objets © CeFIS 2004

Synthèse (10) Possède un champ appelé out de type PrintStream
class 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){…} Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

Description des classes
NomClasse Champs (+accès) Méthodes (+accès) Description des classes Point Application + main() PrintStream +println() Math +sqrt(a: reel) reel -x: reel -y: reel + getAbscisse()reel + getOrdonnee()  reel + setAbscisse(a: reel) + setOrdonnee(b: reel) + distanceJusque(p:Point):reel Programmer avec des objets © CeFIS 2004

Programmer avec des objets © CeFIS 2004
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){ public double distanceJusque(Point p){ int diffX=x-p.x; int diffY=y-p.y; return Math.sqrt(diffX*diffX+diffY*diffY); Programmer avec des objets © CeFIS 2004

Code de l'application Programmer avec des objets © CeFIS 2004
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) + "."); } Programmer avec des objets © CeFIS 2004

Schéma d’interaction des classes
Application utilise System utilise compose Point PrintStream utilise Math Programmer avec des objets © CeFIS 2004

La somme de deux nombres
Approche impérative lire a, b somme  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 + "."); } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

La classe Entier Programmer avec des objets © CeFIS 2004 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; Programmer avec des objets © CeFIS 2004

L'application Programmer avec des objets © CeFIS 2004
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()); } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Triangle Programmer avec des objets © CeFIS 2004 class 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); Programmer avec des objets © CeFIS 2004

Exemple d'application Programmer avec des objets © CeFIS 2004
public class ApplTriangle{ public static void main(String [] args){ 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()+"."); } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Application Programmer avec des objets © CeFIS 2004
public class Comparaison{ public static void main(String [] args){ 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."); Programmer avec des objets © CeFIS 2004

La méthode equals remplacée
public boolean equals(Point p){ return (x==p.x && y==p.y); } équivalent à public boolean equals(Point p){ if (x==p.x && y==p.y){ return true; } else{ return false; Programmer avec des objets © CeFIS 2004

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 de int 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); } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Illustration Programmer avec des objets © CeFIS 2004
public 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); } Programmer avec des objets © CeFIS 2004

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)? Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 + ")"; Programmer avec des objets © CeFIS 2004

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(); Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

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); // 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..."); Programmer avec des objets © CeFIS 2004

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(); } Programmer avec des objets © CeFIS 2004

La classe String Les packages De nombreuses méthodes "prêt-à-l'emploi"
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,... Programmer avec des objets © CeFIS 2004

Exemples Programmer avec des objets © CeFIS 2004
public class AppString{ public static void main(String [] args){ 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"); } Programmer avec des objets © CeFIS 2004

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: (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é Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Modification d'un champ statique
public static int prochainNumero = 1; // champ statique de la classe Cassette public int numero; // champ dynamique de type primitif entier public 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 Programmer avec des objets © CeFIS 2004

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 exemple private static void initialiserProchain(){ prochainNumero=1; } une méthode utilitaire public static auCarre(int x){ System.out.println("Le carré de " + x + " est " + x*x + "."); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

Les opérateurs Arithmétiques Compile? compile pas?
les classiques +, -, *, /, % (reste de la division entière de … par…) attention aux conversions (promotions)de types Compile? compile pas? public class Promotion{ public static void main(String [] args){ byte b1=2, b2=5, b3; b3=b1+b2; byte b4=b1+6; } public class Promotion{ public static void main(String [] args){ byte b1=2, b2=5; int b3=b1+b2; byte b4=b1; } Programmer avec des objets © CeFIS 2004

Compile? Compile pas? Programmer avec des objets © CeFIS 2004
public class Promotion{ public static void main(String [] args){ int i1=50000, i2=60000; int i3=i1+i2; long i4=i1*i2; System.out.println(i3 + " " + i4); } public class Promotion{ public static void main(String [] args){ long i1=50000, i2=60000; long i3=i1+i2; long i4=i1*i2; System.out.println(i3 + " " + i4); } Programmer avec des objets © CeFIS 2004

Mais encore... Programmer avec des objets © CeFIS 2004
public class Promotion{ public static void main(String [] args){ int i=50000; float f1=i+2.; float f2=i+2.f; System.out.println(f1 + " " + f2); } public class Promotion{ public static void main(String [] args){ char c='a'; int i=5; System.out.println(c); System.out.println(c+i); c+=i; c=c+i; } Programmer avec des objets © CeFIS 2004

Incrémentation, décré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 + “.”); Programmer avec des objets © CeFIS 2004

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ères String nom = "Vandeput"; String prenom = "Etienne"; nom += " " + prenom; System.out.println(nom); concaténation du prénom au nom avec espace entre les deux Programmer avec des objets © CeFIS 2004

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 genre int a, b; a = … ; b = … ; ... int max = a > b ? a : b; Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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); } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Le jeu du compilateur (suite)
Les invocations sont-elles correctes? Les affectations sont-elles correctes? Correction Compilation Programmer avec des objets © CeFIS 2004

public class Ex12ch4{ public static void main(String [] args){ 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){ k = valeur; Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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(){ 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); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Exemple L'initialisation d'un tableau passe souvent par l'emploi d'une structure de contrôle répétitive 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]); } Programmer avec des objets © CeFIS 2004

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 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) Programmer avec des objets © CeFIS 2004

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; Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Illustration naïve import javax.swing.*; public class EntreeDeDonnees{ public static void main(String [] args){ 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. Programmer avec des objets © CeFIS 2004

Héritage Motivation Localisation dans un énoncé
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) Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

…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 Programmer avec des objets © CeFIS 2004

Vocabulaire On parle de En Java, il n'y a que de l'héritage simple
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 Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

Illustration de ces trois mécanismes
Les classes Personne Eleve (qui hérite de Personne) Residence pour illustrer la composition dans Personne Programmer avec des objets © CeFIS 2004

/* 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.prenom = prenom; public String toString(){ return "Identité: " + nom + " " + prenom; class Residence{ private String rue; private String numero; private int codePostal; private String localite; Programmer avec des objets © CeFIS 2004

class Eleve extends Personne{ private String classe; public Eleve(String nom, String prenom, String c){ super(nom, prenom); classe = c; } public String toString(){ // > Remplacement return "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ères System.out.println(e + "\n\n" + p1 + "\n\n" + p2 + "\n"); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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... Programmer avec des objets © CeFIS 2004

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  Programmer avec des objets © CeFIS 2004

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."); public String toString(){ return "x: " + x; class B extends A{ int y; B(int y){ this.y = y; return "x: " + x + "\t" + "y: " + y; Programmer avec des objets © CeFIS 2004

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  Programmer avec des objets © CeFIS 2004

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; public String toString(){ 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; return "x: " + x + "\t" + "y: " + y; Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Le polymorphisme (2) 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 Programmer avec des objets © CeFIS 2004

Le polymorphisme (3) Mécanisme Avantage
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) Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

Exercices Héritage et constructeurs Polymorphisme
Résolution de surcharge et choix de la bonne méthode à l'interprétation Programmer avec des objets © CeFIS 2004

public class Ex1ch5{ public static void main(String [] args){ 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; Programmer avec des objets © CeFIS 2004

public class Hierarchie1{ public static void main(String [] args){ 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; } Programmer avec des objets © CeFIS 2004

class Forme{ public void seDefinir(){ System.out.println("Je suis une forme."); } class Polygone extends Forme{ super.seDefinir(); System.out.println("Je suis aussi un polygone."); class Triangle extends Polygone{ class Quadrilatere extends Polygone{ class Carre extends Quadrilatere{ System.out.println("Je suis un carré."); class Rectangle extends Quadrilatere{ System.out.println("Je suis aussi un rectangle."); class Parallelogramme extends Quadrilatere{ Programmer avec des objets © CeFIS 2004

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); Programmer avec des objets © CeFIS 2004

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{ System.out.println("Dans D: m(int, int)\t" + i1 + "\t" + i2); System.out.println("Dans D: m(int, String)\t" + i + "\t" + s); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Alternative simple Programmer avec des objets © CeFIS 2004
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); Programmer avec des objets © CeFIS 2004

Sélectif Programmer avec des objets © CeFIS 2004
switch (valeur_entière){ case valeur1: bloc_de_traitement1 case valeur2: bloc_de_traitement2 ... default: bloc_de_traitement_par_défaut } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

public class H2D{ public static void main(String [] args){ 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); Programmer avec des objets © CeFIS 2004

Répétitives Boucle à parcourir éventuellement 0 fois au moins une 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 Programmer avec des objets © CeFIS 2004

while Programmer avec des objets © CeFIS 2004
while (expression_booléenne){ bloc_de_traitement } public class BoucleWhile{ public static void main(String [] args){ int i = 0; while (i++<8){ System.out.println("Bienvenue à la séance " + i + " du cours Java."); Programmer avec des objets © CeFIS 2004

do - while Programmer avec des objets © CeFIS 2004 do
bloc_de_traitement while (expression_booléenne); public class BoucleDoWhile{ public static void main(String [] args){ int i = 1; System.out.println("Bienvenue à la séance " + i + " du cours Java."); while (i++<5); } Programmer avec des objets © CeFIS 2004

for Programmer avec des objets © CeFIS 2004
for (initialisations; expression_booléenne; incrémentations){ bloc_de_traitement { public class BoucleFor{ public static void main(String [] args){ for(int i=1;i<=8;++i){ System.out.println("Bienvenue à la séance " + i + " du cours Java."); } Programmer avec des objets © CeFIS 2004

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 Exemple public static int pD2(int valeur){ int exp; for(exp=0, valeur-=1; valeur>0; exp++, valeur/=2){ } return exp; Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

do int 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(...); Programmer avec des objets © CeFIS 2004

Exercice Le type abstrait Ensemble Primitives Implantation
é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 Programmer avec des objets © CeFIS 2004

Une piste intéressante
Le site à voir en particulier: les pages de Jean Berstel et Jean-Eric Pin Programmer avec des objets © CeFIS 2004

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? Programmer avec des objets © CeFIS 2004

1. A x = new A(); A y = new A(); x.methode(y); 2. A x = new A(); A y = new B(); 3. A x = new A(); B y = new B(); 4. B x = new B(); 5. A x = new B(); 6. B x = new B(); B y = new A(); class A{ A autre; void methode(A v){ autre = new A(); } class B extends A{ int valeur; super.methode(v); valeur++; void methode(B v){ autre = v; Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Problème du trinôme Idée Difficulté Solution
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 Programmer avec des objets © CeFIS 2004

Syntaxe Utilisation du mot-clé abstract dans la déclaration de la méthode et donc, obligatoirement, dans la déclaration de la classe public abstract class Trinome{ protected double a, b, c; ... public abstract void calculerRacines(); } Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

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{ public static void main(String [] args){ Trinome t1 = Trinome.creer(1.,2.,1.); Trinome t2 = Trinome.creer(1.,-1.,1.); Trinome t3 = Trinome.creer(1.,5.,6.); t1.calculerRacines(); t2.calculerRacines(); t3.calculerRacines(); } Programmer avec des objets © CeFIS 2004

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; Programmer avec des objets © CeFIS 2004

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); return new TrinomeAvecDeuxRacines(a,b,c,d); public abstract void calculerRacines(); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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){ System.out.println("La racine double est " + (-b/2*a)); class TrinomeAvecDeuxRacines extends Trinome{ public TrinomeAvecDeuxRacines(double a, double b, double c, Rho d){ System.out.println("Les racines sont " + (-b+Math.sqrt(d.getValeur()))/ (2*a) + " et " + (-b-Math.sqrt(d.getValeur()))/(2*a) + "."); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Autre version de la méthode main
Un paramètre a été ajouté à la méthode créer public class AppAbstract2{ public static void main(String [] args){ 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); t1.calculerRacines(); t2.calculerRacines(); t3.calculerRacines(); t4.calculerRacines(); } Programmer avec des objets © CeFIS 2004

Modification de la méthode creer
public 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); if (d.getValeur()==0){ return new TrinomeAvecRacineDouble(a,b,c,d); return new TrinomeAvecDeuxRacines(a,b,c,d); Programmer avec des objets © CeFIS 2004

Nouvelle classe Programmer avec des objets © CeFIS 2004
class 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."); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Classe implantant une interface
class Point implements Forme{ private double x, y; ... // autres champs, constructeurs et méthodes public double surface(){ return 0.0; } public double volume(){ Programmer avec des objets © CeFIS 2004

Autre exemple Programmer avec des objets © CeFIS 2004
class 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; Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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){ ... } Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

30/03/2017 import java.util.*; // pour Date import java.awt.event.*; // pour ActionEvent et ActionListener import javax.swing.*; // pour JOptionPane import javax.swing.Timer; // pour éviter le conflit avec la classe Timer de java.util public class AppChrono{ public static void main(String [] args){ ActionListener chrono = new AfficheurDeTemps(); // Usage du polymorphisme Timer 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"); JOptionPane makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something. Each Timer has a list of ActionListeners and a delay (the time between actionPerformed() calls). When delay milliseconds have passed, a Timer sends the actionPerformed() message to its listeners. This cycle repeats until stop() is called, or halts immediately if the Timer is configured to send its message just once. Using a Timer involves first creating it, then starting it using the start() method. The class Date represents a specific instant in time, with millisecond precision. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Le modèle des événements en Java
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,... Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Hiérarchies D'événements De classes graphiques
AWTEvent ActionEvent MouseEvent ... De classes graphiques Frame JFrame … Pas toujours simple de s'y retrouver ! Programmer avec des objets © CeFIS 2004

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. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Les classes utiles JFrame Container FlowLayout
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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

30/03/2017 import java.awt.*; // Container, FlowLayout import java.awt.event.*; // ActionEvent import 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 dialogue public BoiteMultiple(){ // Paramétrage de la fenêtre setTitle("Multiple de 7?"); setSize(450,80); setLocation(300,300); // Obtention d'une référence vers le conteneur Container c = getContentPane(); The JFrame class is slightly incompatible with Frame. Like all other JFC/Swing top-level containers, a JFrame contains a JRootPane as its only child. The content pane provided by the root pane should, as a rule, contain all the non-menu components displayed by the JFrame. This is different from the AWT Frame case. For example, to add a child to an AWT frame you'd write: frame.add(child); However using JFrame you need to add the child to the JFrame's content pane instead: frame.getContentPane().add(child); La méthode setTitle vient de Frame et les deux autres de Container. Un objet JFrame contient un objet JRootPane qui lui-même contient un objet Container. La méthode getContentPane permet d’obtenir la référence de cet objet. Programmer avec des objets © CeFIS 2004

30/03/2017 // Création d'un gestionnaire de mise en page pour le conteneur FlowLayout fl = new FlowLayout(); c.setLayout(fl); // Création des composants de la fenêtre JLabel ln = new JLabel("Nombre à examiner:"); jt = new JTextField(8); b = new JButton("Vérifier"); lm = new JLabel("Multiple de 7: "); // Ajout des composants au conteneur c.add(ln); c.add(jt); c.add(b); c.add(lm); // Ajout de l'objet courant à la liste des écouteurs du bouton b.addActionListener(this); } // Implantation de la méthode d'écoute public 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"); La méthode setLayout s’applique à un objet de type Container. Des composants sont créés et l’objet Container se les ajoute. Le bouton s’ajoute à la liste des écouteurs de l’objet BoiteMultiple. La méthode getSource est héritée de EventObject. Les méthodes getText et setText sont héritées de JTextComponent. Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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); } class BoiteMultiple extends JFrame implements ActionListener { JButton b; JTextField jt; JLabel lm; // Construction de la boîte de dialogue public BoiteMultiple(){ // Paramétrage de la fenêtre setTitle("Multiple de 7?"); setSize(450,80); setLocation(300,300); // Obtention d'une référence vers le conteneur Container c = getContentPane(); Programmer avec des objets © CeFIS 2004

// Création d'un gestionnaire de mise en page pour le conteneur FlowLayout fl = new FlowLayout(); c.setLayout(fl); // Création des composants de la fenêtre JLabel ln = new JLabel("Nombre à examiner:"); jt = new JTextField(8); b = new JButton("Vérifier"); lm = new JLabel("Multiple de 7: "); // Ajout des composants au conteneur c.add(ln); c.add(jt); c.add(b); c.add(lm); // Ajout de l'objet courant à la liste des écouteurs du bouton b.addActionListener(this); } // Implantation de la méthode d'écoute public 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"); class EcouteFenetre extends WindowAdapter { public void windowClosing(WindowEvent we){ System.exit(0); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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); } ); class BoiteMultiple extends JFrame implements ActionListener { JButton b; JTextField jt; JLabel lm; // Construction de la boîte de dialogue public BoiteMultiple(){ // Paramétrage de la fenêtre setTitle("Multiple de 7?"); setSize(450,80); setLocation(300,300); // Obtention d'une référence vers le conteneur Container c = getContentPane(); Programmer avec des objets © CeFIS 2004

// Création d'un gestionnaire de mise en page pour le conteneur FlowLayout fl = new FlowLayout(); c.setLayout(fl); // Création des composants de la fenêtre JLabel ln = new JLabel("Nombre à examiner:"); jt = new JTextField(8); b = new JButton("Vérifier"); lm = new JLabel("Multiple de 7: "); // Ajout des composants au conteneur c.add(ln); c.add(jt); c.add(b); c.add(lm); // Ajout de l'objet courant à la liste des écouteurs du bouton b.addActionListener(this); } // Implantation de la méthode d'écoute public void actionPerformed(ActionEvent ae){ 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: "); Programmer avec des objets © CeFIS 2004

class BoiteMultiple extends JFrame implements ActionListener, FocusListener { JTextField jt; JLabel lm; // Construction de la boîte de dialogue public BoiteMultiple(){ // Paramétrage de la fenêtre setTitle("Multiple de 7?"); setSize(450,80); setLocation(300,300); // Obtention d'une référence vers le conteneur Container c = getContentPane(); // Création d'un gestionnaire de mise en page pour le conteneur FlowLayout fl = new FlowLayout(); c.setLayout(fl); // Création des composants de la fenêtre JLabel ln = new JLabel("Nombre à examiner:"); jt = new JTextField(8); lm = new JLabel(""); // Ajout des composants au conteneur c.add(new JButton("OK")); // Bouton inutile, pour tester la perte de focus c.add(ln); c.add(jt); c.add(lm); // Ajout de l'objet courant à la liste des écouteurs du champ texte jt.addActionListener(this); jt.addFocusListener(this); } Programmer avec des objets © CeFIS 2004

// Implantation des méthodes d'écoute // Pour l'interface ActionListener public void actionPerformed(ActionEvent ae){ mettreAJour(); } // Pour l'interface FocusListener public void focusGained(FocusEvent fe){} public void focusLost(FocusEvent fe){ // 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"); catch(NumberFormatException nfe){ jt.setText(""); lm.setText(""); Programmer avec des objets © CeFIS 2004

class BoiteMultiple extends JFrame implements DocumentListener { JTextField jt; JLabel lm; // Construction de la boîte de dialogue public BoiteMultiple(){ // Paramétrage de la fenêtre setTitle("Multiple de 7?"); setSize(450,80); setLocation(300,300); // Obtention d'une référence vers le conteneur Container c = getContentPane(); // Création d'un gestionnaire de mise en page pour le conteneur FlowLayout fl = new FlowLayout(); c.setLayout(fl); // Création des composants de la fenêtre JLabel ln = new JLabel("Nombre à examiner:"); jt = new JTextField(8); lm = new JLabel(""); // Ajout des composants au conteneur c.add(ln); c.add(jt); c.add(lm); // Ajout de l'objet courant à la liste des écouteurs du "document" associé jt.getDocument().addDocumentListener(this); } Programmer avec des objets © CeFIS 2004

// Implantation des méthodes d'écoute // Pour l'interface DocumentListener public void insertUpdate(DocumentEvent de){ mettreAJour(); } public void changedUpdate(DocumentEvent de){ public void removeUpdate(DocumentEvent de){ // 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"); catch(NumberFormatException nfe){ jt.setText(""); lm.setText(""); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

Applets: les bases En Java Applications Applets méthode main
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> Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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); Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

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 Programmer avec des objets © CeFIS 2004

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 fichier package 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 Programmer avec des objets © CeFIS 2004

Identification des classes
Le compilateur utilise les noms complets. soit que le programmeur les mentionne eva.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 complet import eva.ecrans.*; importation d'une seule classe import eva.ecrans.Point possibilité de créer une arborescence de packages package eva.ecrans package eva.ecrans.saisie attention, pour importer ces 2 packages, il faut 2 instructions import eva.ecrans.saisie.*; Programmer avec des objets © CeFIS 2004

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{ public static void main(String [] args){ 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 Programmer avec des objets © CeFIS 2004

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: Programmer avec des objets © CeFIS 2004

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) Programmer avec des objets © CeFIS 2004

Programmer avec des objets

Présentations similaires

Présentation au sujet: "Programmer avec des objets"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Programmer avec des objets

Présentations similaires

Présentation au sujet: "Programmer avec des objets"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back