COURS 2 : Programmation impérative

Présentation au sujet: "COURS 2 : Programmation impérative"— Transcription de la présentation:

1 COURS 2 : Programmation impérative
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 COURS 2 : Programmation impérative Classes et objets simples Découpage structurel et fonctionnel Modularité fonctionnelle, robustesse et maintenance Classes et objets simples sans méthode Résumé du cours précédent Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

2 Accès aux attributs des objets : OID versus this
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Accès aux attributs des objets : OID versus this Domino d4 = new Domino(2,5); if ( d4.m1 != d4.m2 ) d4.m1 = d4.m2; En dehors de l’objet, on utilise l’objet Dans l’objet, on "est" l’objet classe MainDominos +$ main(String[]) + = public $ = static La méthode main voit le domino au travers de sa référence ou OID. Ici, d4. Elle ne peut faire autrement que de l’utiliser car this n’a pas de sens pour le domino d4 dans main. Vision externe classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() d4: Domino m1 = 2 m2 = 5 En NOTATION UML pour y habituer les étudiants (expliquer rapidement...) Commencer par la méthode main : on construit un domino / on garde sa référence d4 / on accède au domino avec d4 On est en vision EXTERNE : on est en dehors de l’objet On reprend la construction : à ce moment le constructeur est dans la classe Domino elle-même / il ne connaît pas d4 / il dispose de THIS. On est en vision INTERNE : effective que lorsque l’on est dans l’objet On peut ajouter que THIS dans la méthode main réfèrerait à un objet de classe MainDominos et non à un Domino ! MAIS ICI, ce n’est bien sûr pas le cas car main étant static, THIS n’est pas défini. this:Domino Vision interne this.m1 = vm1; this.m2 = vm2; Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

3 Classes et objets simples : VISION EXTERNE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes et objets simples : VISION EXTERNE + = public $ = static Quand le code en cours d’exécution se trouve classe MainDominos +$ main(String[]) { Domino d2 = new Domino(3,4); Domino d4 = new Domino(2,5); if ( d4.m1 != d4.m2 ) d4.m1 = d4.m2; } EN DEHORS de la classe d’un OBJET : (i.e. en dehors de la classe qui représente l’objet) La VISION de l’objet est EXTERNE Le code en cours d’exécution accède à l’objet à l’aide d’une référence externe à l’objet (également appelée <OID>) d4 d2 Depuis une classe, pour accéder à un objet d’une autre classe, on doit utiliser une référence sur cet objet (OID). Un domino m1 = 2 m2 = 5 Un domino m1 = 3 m2 = 4 Vision externe Ex: Quand main() de MainDominos, désire accéder à un domino dont elle possède une référence, elle utilise cette référence pour spécifier le domino auquel elle veut accéder. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

4 Classes et objets simples: VISION INTERNE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes et objets simples: VISION INTERNE + = public Quand le code en cours d’exécution se trouve classe Domino m1 : int m2 : int +Domino(int vm1,int vm2){ this.m1 = vm1; this.m2 = vm2; } +Domino(int) +Domino() DANS la CLASSE d’un OBJET : (i.e. à l’intérieur de la classe qui représente l’objet) La VISION de l’objet est INTERNE On accède aux propriétés de l’objet en cours d’exécution à l’aide de la variable d’autoréférencement : this Depuis un constructeur, pour accéder à l’objet en cours de construction, on utilise THIS. Vision interne Ex: Dans un constructeur de Domino, le « domino en cours d’exécution » est celui « en cours de construction ». (bien que d’autres puissent avoir été construits antérieurement, c’est celui en cours de construction qui est référencé par this) Dominos déjà construits m1 = 3 m2 = 4 this:Domino m1 = ? m2 = ? Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

5 Résumé des classes et objets vus en TD
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Résumé des classes et objets vus en TD Classes & Objets = ATTRIBUTS + CONSTRUCTEURS classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() classe Livre titre : String auteur : String editeur : String nbPages : int isbn : ISBN +Livre(String,String,String,int,ISBN) classe ISBN groupeA : int groupeB : int groupeC : String groupeD : String +ISBN(int,int,String,String) Objet <ISBN> en dépendance d’un livre d1 l1 un domino m1 = 2 m2 = 5 un livre titre = "Fourmis sans ombre" auteur = "Maurice COYAUD" editeur= "Phébus" nbPages = 320 isbn : ObjRéf (<ISBN>) un isbn groupeA = 2 groupeB = groupeC = "017" groupeD = "6" Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

6 Classes&Objets = ATTRIBUTS + CONSTRUCTEURS
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&Objets = ATTRIBUTS + CONSTRUCTEURS Mais, en réalité, les attributs de type String sont aussi des objets : 5 String classe Livre titre : String auteur : String editeur : String nbPages : int isbn : ISBN +Livre(String,String,String,int,ISBN) classe ISBN groupeA : int groupeB : int groupeC : String groupeD : String +ISBN(int,int,String,String) un string "Maurice COYAUD" 1 ISBN un string "Fourmis sans ombre" un string  "Phébus" l1 6 objets en dépendance d’un livre un string "017" un livre titre = ObjRéf auteur = ObjRéf editeur= ObjRéf nbPages = 320 isbn : ObjRéf un isbn groupeA = 2 groupeB = groupeC = ObjRéf groupeD = ObjRéf un string "6" Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

7 Objectifs de ce cours (I21)
Classes et objets simples Découpage structurel et fonctionnel Modularité fonctionnelle, robustesse et maintenance Classes et objets simples sans méthode Méthodes d’instance simples Maintenant ! Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

8 Classes&objets : PEUT MIEUX FAIRE !
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : PEUT MIEUX FAIRE ! Pour le moment, nos objets ne sont que de simples structures de données classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() ils ne contiennent que des attributs valués et les constructeurs capables de les initialiser mais le paradigme Orienté-Objet va bien plus loin que cela : => il permet d’inclure dans les objets les méthodes « responsables » d’agir sur leurs attributs Expliquer le mot « responsable » en montrant qu’il inclus de nombreuses facettes : en capacité de dont le rôle est de qui assure que l’usage qui est fait des attributs reste toujours correct Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

9 Classes&objets : PEUT MIEUX FAIRE !
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : PEUT MIEUX FAIRE ! Prenons un exemple (vu en TD) : La méthode : public static boolean estDouble(Domino d) (écrite dans la classe MainDominos) teste si le domino fourni en paramètre est un double et renvoie un booléen en conséquence. cette méthode n’est pas à sa place en Orienté-Objet ! classe MainDominos +$ main(String[]) { test1(); } +$ test1() { Domino d4 = new Domino(3,4); if ( estDouble(d4) ) { // faire quelque chose... } +$ boolean estDouble(Domino d) { return ( d.m1 == d.m2 ); Dans ce paradigme, on préfèrera penser que le domino est lui-même le mieux placé pour « savoir » s’il est ou non un double ! Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

10 Classes&objets : COMMENT FAIRE MIEUX ?
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : COMMENT FAIRE MIEUX ? Nous allons transférer la méthode vers la classe Domino classe MainDominos +$ main(String[]) { test1(); } +$ test1() {...} +$ boolean estDouble(Domino d) { return ( d.m1 == d.m2 ); } classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() ① le paramètre « d » a disparu ! +estDouble(): boolean ② la déclaration « static » ($) a disparu ! Le fait de vouloir que la méthode réfère maintenant au domino en cours d’exécution peut être justifié du fait qu’ON SE TROUVE MAINTENANT DANS LE DOMINO et non plus à l’extérieur. Il serait dommage de ne pas profiter du fait que la variable THIS réfère directement au domino en cours d’exécution ! cela parce que nous voulons que la méthode réfère maintenant au domino en cours d’exécution (i.e. this) et non plus à un domino qui doit lui être fourni ! le mot réservé static signifiant « réfère à la classe », il ne doit pas être utilisé ici => cela pour que la méthode réfère à l’objet ! Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

11 Classes&objets : COMMENT FAIRE MIEUX ?
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : COMMENT FAIRE MIEUX ? Finalement, nous pouvons écrire la méthode et son invocation : classe MainDominos +$ main(String[]) { test1(); } +$ test1() { Domino d4 = new Domino(3,4); } classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() this.m1 this.m2 if ( ) { // faire quelque chose... } d4.estDouble() public boolean estDouble(){ } ② invocation de la méthode sur la base de la référence à un domino (ici, d4) return ( == ); ① emploi de « this » Ici, this réfère au domino en cours d’exécution => la valeur de this.m1 est donc égale à celle de l’attribut m1 du domino en cours d’exécution Ici, l’invocation de la méthode peut maintenant être effectuée sur la base de la référence externe au domino (c’est la seule chose dont dispose la méthode test1() – on doit utiliser la notation pointée) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

12 Classes&objets : Comment this est-il mis à jour ?
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : Comment this est-il mis à jour ? classe MainDominos +$ main(String[]) { test1(); } +$ test1() { Domino d4 = new Domino(3,4); if ( ) { // faire quelque chose... } classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() this.m1 this.m2 public boolean estDouble(){ } d4.estDouble() return ( == ); invocation de la méthode exécution de la méthode Maintenant « this » réfère à d4 mise à jour de « this » ① Le fait d’utiliser d4 comme base d’invocation de la méthode estDouble() a pour effet de lier la méthode à l’objet référé par d4 ; ② C’est à ce moment que Java met à jour la variable this ! (i.e. « this » prend la valeur de « d4 ») ③ Et ce n’est qu’ensuite que Java exécute la méthode dans sa classe propre. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

13 Classes&objets : METHODES d’INSTANCE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : METHODES d’INSTANCE Autres exemples de méthodes d’instance pour la classe Domino : classe MainDominos +$ main(String[]) { test1(); } +$ test1() { Domino d4 = new Domino(3,4); } classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() if (d4.estDouble() ) { // afficher le domino } +estDouble() : boolean public String dominoToString(){ } public int valeur() { System.out.println( d4.dominoToString()); return "("+this.m1+","+this.m2+")"; if (d4.valeur() > 5){ // afficher le domino System.out.println( d4.dominoToString()); } return  this.m1 + this.m2; Quelques invocations de méthodes d’instance de la classe Domino Méthodes d’instance de la classe Domino Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

14 Classes&objets : METHODES d’INSTANCE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : METHODES d’INSTANCE Exemple de méthode d’instance avec un paramètre : classe MainDominos +$ main(String[]) { test1(); } +$ test1() { Domino d4 = new Domino(3,4); Domino d5 = new Domino(5,2); classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() +estDouble() : boolean +dominoToString() : String +valeur() : int if ( d5.plusGrandQue(d4) ){ } // afficher le plus grand domino System.out.println( d5.dominoToString() + " est plus grand que " + d4.dominoToString() ); +plusGrandQue(Domino d) : int Montrer ENSUITE ce que fait : if ( d5 > d4 ) ... cela ne fait que COMPARER LES REFERENCES ENTRE ELLES !!! Certainement PAS LES OBJETS ENTRE EUX ! Il faut maintenant écrire cette méthode Par convention : d1.plusGrandQue(d2) devra retourner : +1 quand d1 est plus grand que d2, 0 quand les 2 dominos sont égaux, -1 quand d1 est plus petit que d2. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

15 Classes&objets : METHODES d’INSTANCE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets : METHODES d’INSTANCE Par convention : d1.plusGrandQue(d2) devra retourner : +1 quand d1 est plus grand que d2, 0 quand les 2 dominos sont égaux, -1 quand d1 est plus petit que d2. Classe Domino ... public int plusGrandQue(Domino d) { } Les 2 dominos ont des valeurs différentes ! La plus grande fournit le plus grand domino. if ( this.valeur() != d.valeur() ) {   return (this.valeur() > d.valeur() ? +1 : -1); } else {   if ( this.plusGrandeMarque() != d.plusGrandeMarque() )   return (this.plusGrandeMarque() > d.plusGrandeMarque()   else   return 0; }  Les 2 dominos ont même valeur ! C’est la plus grande marque qui fournira le plus grand domino Les 2 marques sont différentes ! Ce cas ne peut arriver que lorsque les 2 dominos ont exactement les mêmes marques ou lorsque this et d sont un seul et même objet. Il restera à écrire cette méthode très simple Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

16 Classes&objets: CONSTRUCTEURS, VARIABLES et METHODES D’INSTANCE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets: CONSTRUCTEURS, VARIABLES et METHODES D’INSTANCE Classes & Objets = VARIABLES D’INSTANCES (=ATTRIBUTS) + CONSTRUCTEURS + METHODES D’INSTANCES classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() VARIABLES D’INSTANCE ATTRIBUTS ou ETAT C’est de cette manière que les objets et leurs classes doivent être conçus dans le paradigme Orienté-Objet. CONSTRUCTEURS METHODES D’INSTANCE +dominoToString(): String +estDouble(): boolean +valeur() : int +plusGrandQue(Domino d) : int +plusGrandeMarque() : int En Orienté-Objet, un objet est vu comme une entité qui encapsule un état interne (ensemble des valeurs des var. d’inst.) et qui fournit des services (méth. d’inst.) par rapport à cet état. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

17 Classes&objets: CONSTRUCTEURS, VARIABLES et METHODES D’INSTANCE
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Classes&objets: CONSTRUCTEURS, VARIABLES et METHODES D’INSTANCE classe MainDominos et classe MainBooks +$main(String[]): void +$test1(): void +$test2(): void Classes des cours et TD revisitées : classe Domino m1 : int m2 : int +Domino(int,int) +Domino(int) +Domino() +dominoToString(): String +estDouble(): boolean +valeur(): int +plusGrandQue(Domino d): int +plusGrandeMarque(): int classe ISBN (anglicisée) groupA : int groupB : int groupC : String groupD : String +ISBN(int,int,String,String) classe Book (anglicisée) title : String autor : String editor : String nbPages : int isbn : ISBN +Book(String,String,String,int,ISBN) +bookToString(): String +hasAutor(String firstname, String lastname): boolean +isFrancophone(): boolean +isEditedBy (String): boolean +isEditedBy(int): boolean +isbnToString(): String +isFrancophone(): boolean +isEditedBy (int): boolean Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde FIRST NAME : prénom / LAST NAME : nom de famille / MIDDLE NAMES : autres prénoms

18 Objectifs de ce cours (I21)
Classes et objets simples Découpage structurel et fonctionnel Modularité fonctionnelle, robustesse et maintenance Classes et objets simples sans méthode Méthodes d’instance simples Plus à propos de Java Maintenant ! Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

19 Conventions de nommage : variables, méthodes, classes
Java pose un certain nombre de conventions pour l’écriture du code et en particulier pour le nommage des entités En JAVA Classe Variable ou constante d’instance Méthode d’instance Variable « static » Constantes « static » Méthode « static » MAJUSCULE en début de nom TOUJOURS JAMAIS Minuscule en début de nom TOUT en MAJUSCULE POSSIBLE Le respect de ces conventions facilite l’apprentissage de Java et notamment celui des librairies standards associées Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

20 Conventions de nommage : préfixes de méthodes
Conventions pour le nommage des méthodes : En JAVA Préfixes de METHODES Exemples de noms de METHODES Méthode renseignant sur l’état d’un objet et retournant un booléen « PREDICAT » is has isDouble(), isEmpty(), isEditedBy(<that editor>), ... hasAutor(<that autor>), ... Méthode retournant une partie de l’état d’un objet sans le modifier « GETTER » get getMark1(), getTitle(), getEditorName(), ... Méthode modifiant une partie de l’état d’un objet « SETTER » set setMark1(<new mark>), setTitle(<new title>), setEditorName(<new name>), ... Le respect de ces conventions facilite la lisibilité du code et donc la maintenance des programmes par des équipes tierces Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

21 Plus à propos de Java (JDK, JRE, ...)
➽ « SDK » est le sigle de « Java Development Kit » publié par Sun Microsystem®. Il comprend : – le compilateur Java (javac), – la machine virtuelle java (java), – un générateur de documentation (javadoc), – un compresseur de classes Java (jar), – les librairies standards de Java en code source (packages java, javax, ...) ainsi que le JRE et de nombreux autres outils. ➽ « JRE » est le sigle pour « Java Runtime Environment » ; c’est la version exécutable minimale qui doit être installée sur une machine pour faire tourner des applications Java. ➽ Quand une application est lancée par la commande : java <MainClass>.class <paramList> Cela charge et exécute la machine virtuelle java (le programme java) qui elle-même : Instancie un gestionnaire de sécurité pour les accès locaux et distants (un SecurityManager) Instancie les flux d’entrées/sorties standards (System.in et System.out) Instancie un flux de sortie pour les erreurs systèmes (System.err) Instancie le « garbage collector » dans un processus distinct (System.gc) Instancie de nombreuses autres objets (class loader, ..., les paramètres de la ligne de commande et le tableau de la méthode main()) Et en dernier lieu, la méthode main() de la classe fournie en paramètre est exécutée dans un processus distinct Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

22 Le « garbage collector »* de Java
* « Garbage collector » signifie littéralement « collecteur d'ordures » ; on parle aussi de « ramasse miettes » mais, ici, cela prend le sens de « nettoyage de l’espace mémoire ». Le Garbage Collector est un processus dont l’exécution est « parallèle » à celle de l’application Java. Chaque application Java est lancée dans un processus. Le ramasse miette en est un au même titre que notre programme. Rq: si on lance plusieurs programmes Java sur une machine, cela lance plusieurs machines virtuelles Java (une pour chaque programme) et donc également un GC pour chacune d’elles. Rôle du GC: Le GC permet de nettoyer l’espace mémoire utilisé par la machine virtuelle Java. Pourquoi doit-on nettoyer l’espace mémoire ? Le nettoyage en question concerne les espaces de la mémoire qui ont été utilisés MAIS qui ne servent plus au programme. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

23 Le « garbage collector » de Java
Cours Java (I21) - Licence 1 Semestre 2 / Y.Laborde 01/04/2017 Le « garbage collector » de Java 1 String[ ] a) Dénombrons les objets instanciés dans ce programme (12 au total) +$ main(String[] args) { test1(); test2(); } +$ test1() { Livre l1 = new Book( "Fourmis sans ombre", "Maurice COYAUD", "Phébus", 320, new ISBN(2, 85940, "017", "6") ); +$ test2() { Domino[] miniJeu = { new Domino(0,0), new Domino(0,1), new Domino(0,2) }; ① b) Envisageons l’ordre d’exécution (avant, au début, pendant, à la fin ou après les méthodes) ④ 1 Book ⑦ ⑧ 3 String c) Simulons l’exécution tout en dénombrant, au moment considéré, les objets existants (NbE) et ceux d’entre eux qui ne sont plus accessibles par le programme (NbNA) ② 1 ISBN 2 String n° étape NbE NbNA ① 1 0 ③ 3 Domino ② 1 0 Rq: le String[] args est supposé VIDE ! ③ 8 (+7) 0 ⑤ ④ 1 (-7) 7 (+7) 1 Domino[ ] ⑤ 1 7 ⑥ ⑥ 5 (+4) 7 ⑦ 1 (-4) 11 (+4) Tout objet devenu inaccessible au programme sera, tôt ou tard, détruit par le GC. ⑧ 0 (-1) 12 (+1) Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde

24 Acta est fabula* * « La pièce est jouée. » On annonçait ainsi la fin de la représentation dans le théâtre antique. Cours JAVA (I21) -Licence 1 Semestre 2 / Y.Laborde