1 / 63

CSI1502 Principes fondamentaux en conception des logiciels

CSI1502 Principes fondamentaux en conception des logiciels. Chapitre 4 Classes et Objets. Objectifs du cours:. Comprendre ce qui suit: Un objet, son état et sa fonction Définitions de classe Encapsulation et modificateur d`accès Au sujet de méthodes:

julie-avery
Download Presentation

CSI1502 Principes fondamentaux en conception des logiciels

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSI1502Principes fondamentaux en conception des logiciels Chapitre 4 Classes et Objets

  2. Objectifs du cours: • Comprendre ce qui suit: • Un objet, son état et sa fonction • Définitions de classe • Encapsulation et modificateur d`accès • Au sujet de méthodes: • Déclaration de méthodes, invocation, et passage des valeurs • Surcharge de méthode • Decomposition de méthode • Relation entre objets et agrégation • Objets graphiques

  3. Que’est-ce que un objet? • Un objet à: • Un état: caractéristiques descriptives • Une fonction: ce que l`objet peut faire ou ce qui peut être fait à l`objet • Par exemple considérons une pièce de monnaie utilisé dans un pile ou face • L`état de la pièce est soit pile, soit face • La fonction de la pièce est de se faire tourner aléatoirement afin d`atteindre un nouvel état

  4. Que’est-ce que une classe? • Une classe est le plan d`un objet • C`est un modèle à partir du quel les objets sont crées • Par exemple la classe String est utilisé pour définir les objets String • Chaque objet String contient des caractères spécifiques (son état) • Chaque objet String peut performer des fonctions tel que toUpperCase • Nous pouvons aussi écrire nos propres classes qui définissent des objets dont on à besoin • L`on peut écrire une classe pièce de monnaie pour représenter un objet pièce de monnaie

  5. int x, y; char ch; Déclarations de variables Déclarations de méthodes Plus au sujet des classes • Une classe contient des déclarations de donnés et des déclarations de méthodes

  6. Exemple:Une classe pièce de monnaie • Variables: • face, un int représentant l’état courant • PILE et FACE des int constant représentant la valeur des deux états • Méthodes: • pieceDeMonnaie, un constructeur pour initialiser l`objet • tourne, une méthode pour faire tourner la pièce de monnaie • estFace, une méthode pour déterminer si l`état courant est face • toString, une méthode qui retourne un String descriptif pour afficher les résultats

  7. L`exemple de la pièce de monnaie:PileOuFace.java // Demonstration de l`utilité de classe définie par le programmeur public class CompteurDeTour { // public static void main (String[] args) { final int NOMBRE_DE_TOURS = 1000; int face = 0, pile = 0; pieceDeMonnaie maPiece = new pieceDeMonnaie(); // initialise l`objet pieceDeMonnaie Continué…

  8. L`exemple de la pièce de monnaie:PileOuFace.java (cont.) for (int compte = 1; compte <= NOMBRE_DE_TOURS; compte ++) { maPiece.tourne( ); if (maPiece.estFace()) { face++; } else { pile++; } } System.out.println(“ Nombre de tours ” + NOMBRE_DE_TOURS); System.out.println(“ Nombre de face ” + face); System.out.println(“ Nombre de pile ” + pile); } }

  9. L`exemple de la pièce de monnaie:PieceDeMonnaie.java public class pieceDeMonnaie { public final int FACE = 0; public final int PILE = 1; private int etat; // --------------------------------------------- // Crée l`état initiale de la pièce en la tournant au début. // public pieceDeMonnaie(){ tourne(); } Continué…

  10. L`exemple de la pièce de monnaie:PieceDeMonnaie.java // ----------------------------------------------- // Tourne la pièce aléatoirement. // public void tourne() { etat = (int) (Math.random() * 2); } // ----------------------------------------------------- // Retourne vrai si l`état courant et face. // public boolean estFace() { return (etat == FACE); } Continué…

  11. L`exemple de la pièce de monnaie:PieceDeMonnaie.java // --------------------------------------------------- // Retourne l’état courant de la pièce sous la forme d`un objet String // public String toString(){ String NomDeLEtat; if (etat == FACE) { NomDeLEtat = "Face"; } else { NomDeLEtat = "Pile"; } return NomDeLEtat; } }

  12. Un exemple:Exécution de PileOuFace • Première exécution: Nombre de tours 1000 Nombre de face 493 Nombre de pile 507 • Deuxième exécution: Nombre de tours 1000 Nombre de face 514 Nombre de pile 486

  13. L`outrepassement des méthodes:Un exemple (Overriding en Anglais) • En rajoutant le code suivant dans la classe pieceDeMonnaie ce code marche: public static double random() { System.out.println("Mon système aléatoire"); return 0; } • L`on ne peut ajouter cette méthode dans la classe Math • Actuellement vous pouvez être poursuivie légalement par Sun pour modification ou extension, des Paquets, APIs, Classes ou Méthodes crées par eux • Sun à les droits intellectuels sur Java

  14. Avantages et désavantages des classes et méthodes statiques • Rappel: vous n`avez pas besoin d`utiliser new pour créer un objet • Ils restent dans le système même si vous en avez pas toujours besoin • Ils ne sont pas géré d`une façon efficace par le collecteur d`ordure • Trop des classes et méthodes statiques peuvent ralentir vôtre application • Elles forment un “héritage” de C++ et n`ont pas vraiment leur place dans le paradigme orienté objet

  15. Discussion:La classe PieceDeMonnaie • Notez que le programme CompteurDeTour n`a pas utilisé la méthode toString • Un programme ne va pas toujours utiliser tous les fonctions d`un objet • Une fois que la classe pieceDeMonnaie a été définie nous pouvons dorénavant l`utiliser dans d`autres programmes

  16. La portée et les instances des variables • La portée des variables est la zone dans laquelle nous pouvons utiliser ces variables • Des variables initialisées au niveau de la classe peuvent être utilisé dans toute la classe • Des variables initialisées dans une méthode ne peuvent être utilisé que dans cette méthode

  17. Les variables d`instance • La variable etat dans la classe pieceDeMonnaie est appelé une variable d`instance car chaque instance (objet) de la classe pieceDeMonnaie à son propre état. • Une classe déclare le type de variable, mais ne réserve pas d`espace en mémoire pour la variable. • Pour chaque pieceDeMonnaie qui est crée, une variable etat est aussi crée • Les Objets d`une même classe partagent les définitions de méthodes, mais chacun garde son propre espace de variable • C`est la seule façon qui permet a deux objets d`avoir des états différents

  18. Pièce de Monnaie 1 int etat; 1 etat Pièce de Monnaie 2 etat 0 Les variables d`instance • Voir FlipRace.java (page 217)

  19. Diagramme UML • UML est le “Unified Modelling Language” • Les diagrammes UML montrent les relations entre les classes et les objets • Un diagramme UML consiste de une ou plusieurs classes avec des sections pour le noms des classes, attributs et méthodes • Les lignes entre les classes représentent les associations • Les Associations peuvent montrer la multiplicité

  20. COIN FLIP RACE 2 1 face : int main (args : String[]) : void flip() : void isHeads() : boolean toString() : String Diagramme UML de classe • Un diagramme UML pour le programme FlipRace:

  21. coin1 : Coin coin2 : Coin face = 0 face = 1 Diagramme UML • Un diagramme UML d`objet consiste d`au moins un objet initialisé • C`est un projection des objets durant l`exécution du programme, montrant les variables

  22. Propriétés des objets:Encapsulation • L’on peut voir un objet de deux façons: • Interne – Les variables de l’objet et les méthodes qui rendent l’objet utile • Externe – Les services que l’objet offre et comment l’objet interagit. • Du point de vue externe l’objet est une entité encapsulée, offrant des service spécifiques • Ces services définissent l`interface d`un objet • Nous avons dans le chapitre 2 que l`objet est une abstraction, cachant des détails au reste du système

  23. Plus au sujet de l`encapsulation • Un objet devrait être autonome • Tout changement à l`état d`un objet (ses variables) devrait être fait au travers de ses méthodes • L`on devrait rendre l`accès au variables difficile, si pas impossible, d`une autre façon qu`au travers de ses méthodes • L`utilisateur, ou client, doit être en mesure d`utiliser les services d`un objet, mais sans avoir besoin de savoir comment ceux-ci sont accomplis

  24. Méthodes Client Variables Plus au sujet de l`encapsulation • L`on doit penser à un objet encapsulée comme une boîte noire, dont le client ne connaît que les méthodes d`interface

  25. Les modificateur d`accès • En Java nous pouvons accomplir l`encapsulation au travers l`usage des modificateur d`accès • Modificateur (ou modifier en Anglais) est un terme réservé en Java qui spécifié les caractéristiques particulières d`une méthode ou de variable • Nous avons utilisé le modificateur final pour définir une constante • Java a trois modificateur d`accès: public, protected et private • Le modificateur protected implique certains aspects d`héritage, que nous allons voir plus tard

  26. Les modificateur d`accès • Les membres d`une classe avec un modificateur d`accès publicsont accessible de partout • Les variables public violent l`encapsulation • Les membres d`une classe avec un modificateur d`accès privatene sont accessible que de l`intérieur d`une classe • Les membres d`une classe sans un modificateur d`accès sont accessible sont accessible de tous les classes dans le même paquet • Les modificateurs Java sont discuté en détails dans l`appendice F

  27. Les modificateur d`accès • Les méthodes qui fournissent les services d`un objet sont usuellement déclaré avec un modificateur public de façon à être utilisé par les clients • Les méthodes publiques sont aussi appelés des méthodes de service • Une méthode crée pour aider une méthode de service est une méthode de support • Les méthodes de support ne devraient pas avoir de modificateur d`accès public

  28. public private Viole l`encapsulation Renforce l`encapsulation variables Fourni les services aux clients Supporte les autres méthodes de la classe méthodes Les modificateur d`accès

  29. Programme contrôleur • Le programme contrôleur, contrôle les autres parties plus intéressantes d`un programme • Le programme contrôleur sont souvent utilisé pour tester d`autres parties d`un programme • Le Banking class contient une méthode main, qui contrôle l`usage de la classe Account, utilisant ses services • Voir Banking.java (p. 226) • Voir Acount.java (p. 227)

  30. Programme contrôleur:Banque.java public class Banking { // crée des comptes de banque et utilise des services public static void main (String[] args) { Account acct1 = new Account("Joe Smithfield", 2341, 200.00); Account acct2 = new Account("Sue Smith", 3212, 1300.01); acct1.deposit(23.43); double smithBalance = acct2.deposit(500.00); System.out.println("Solde de Smith " + smithBalance); acct1.addInterest(); System.out.print("Nouvelle solde de Smithfield "); System.out.println(acct1.getBalance()); } }

  31. Programme contrôleur:Comptes.java public class Account { private final double RATE = 0.035; // taux d`interêt de 3.5% private long acctNumber; private double balance; private String name; // Constructeur de classe, initialise les variables public Account (String owner, long account, double initial) { name = owner; acctNumber = account; balance = initial; } Continué…

  32. Programme contrôleur:Comptes.java (cont.) public double deposit (double amount) { if (amount < 0) // si la valeur déposée est négative { System.out.println("Erreur: dépôt invalide."); } else { balance = balance + amount; return balance; } } public double addInterest() { balance += (balance * RATE); return balance; } public double getBalance() { return balance; } }

  33. Les resultats:Banque et Comptes • Solde de Smith 1800.01 • Nouvelle solde de Smithfield 231.25 Remarques: • La variable balance est private, nous ne pouvons y accéder directement, nous utilisons une méthode • Voir page 227-229 pour tout le programme • Il utilise la classe NumberFomat pour formater les resultats

  34. Déclaration de méthode • Une déclaration de méthode spécifie le code qui va être exécuté quand la méthode va être invoquée • Quand une méthode est invoquée le contrôle est passé à la méthode et le code exécuté • Une fois l`exécution terminée le contrôle retourne la d`ou la méthode à été invoquée • L`invocation peut ou ne peut pas retourner de valeur selon la façon dont la méthode a été définie

  35. Exécution MaMethode() MaMethode(); Contrôle d`une méthode • La méthode invoqué peut-être dans la même classe dans quel cas on a juste besoin de la nommer

  36. La méthode invoqué peut-être aussi dans une autre classe ou objet MaClasse main MaClasse.MaMethode(); MaMethode() AideMoi() AideMoi(); Contrôle d`une méthode

  37. Liste de paramètres La liste de paramètres spécifie le type de chaque et chacun des paramètre nom de la méthode Le nom d`un paramètre dans la déclaration d`une méthode est un argument formel Type de la Valeur retourné L`en-tête de la méthode • La déclaration d`une méthode commence avec son en-tête char calc (int num1, int num 2, String message){

  38. sum et result sont des variables locales Ils sont crées a chaque fois que la méthode Est invoqué et détruit à la fin de l`exécution La valeure retourné doit-être le même type que le type de la Valeur retourné Le corps de la méthode • L`en-tête d`une méthode est suivie par le corps { int sum = num1 + num2; char result = message.charAt (sum); return result; }

  39. La valeur de retour • Le type de la valeur retourné indique la valeur que la méthode retourne à l`origine de l`invocation • Une méthode qui ne retourne pas de valeur a un type de la valeur void • L`expression de retour spécifie ce qui est retourné: return expression; • L`expression retourné doit conformer au type de la valeur de retour

  40. Paramètres d`une méthode • Pour chaque invocation d`une méthode les paramètres de l`invocation sont copiés dans les paramètre formels resultat = obj.calc(25, count, “Allo”) char calc (int num1, int num2, String message) { int sum = num1 + num2; char result = message.charAt (sum); return result; }

  41. Variables locales d`une méthode • Variables locales peuvent être déclarées dans une méthode • Les paramètre formels de la méthode créent des variables locales automatiquement quand la méthode est invoquée • Quand la méthode a fini d`exécuter toutes les variables locales sont détruite (incluant les paramètre formels) • Il s'agit de ce rappeler que les variables d`instance crées au niveau de la classe existent tant et aussi longtemps que la classe existe • Toute méthode dans la classe peut référer au variables d`instance

  42. Retour au constructeurs • Les constructeurs sont des méthodes spéciale qui initialisent les objets nouvellement crées • En écrivant un constructeur: • Il a le même nom que la classe • Il n`y a pas de valeur de retour • Il n`y a pas de type de la valeur de retour même pas void • Typiquement initialise les variables a leur valeurs de défaut • Le programmeur ne doit pas nécessairement définir un constructeur pour un classe

  43. La surcharge d`une méthode • La surcharge d`une méthode est un processus qui consiste a utiliser le même nom d`une méthode pour différentes méthodes • La signature de chaque méthode surchargée doit être unique • La signature inclus le nombres, type, ordre des paramètre d`une méthode • Le compilateur détermine quelle version des paramètre est invoqué à partir des paramètres • Le type de la valeur retourné ne fait pas partie de la signature

  44. version 1 float testMoi(int x){ return x + .375; } version 2 float testMoi(int x, float y){ return x*y; } invocation resultat = obj.testMoi(25, 4.32); Méthodes surchargées

  45. Méthodes surchargées • Les méthodes print()/println() est surchargée println (String s) println (int i) println (double d) etc... • Le code suivant invoque plusieurs differentes versions des méthodes print()/println(): System.out.println ("Le total est: "); System.out.println (total +".");

  46. Constructeurs surchargés:SnakeEyes.java public class SnakeEyes { // Fait rouler les dés et compte les double 1 public static void main (String[] args) { final int ROLLS = 500; int snakeEyes = 0, num1, num2; Die die1 = new Die(); //creates a 6-sides die Die die2 = new Die(20); //creates a 20-sides die for (int rols = 1; rols <= ROLLS; rols++){ num1 = die1.roll(); num2 = die2.roll(); if (num1 == 1 && num2 ==1){ snakeEyes++; } System.out.println("Nombre de Snake Eyes " + snakeEyes); } }

  47. Constructeurs surchargés:Die.java public class Die { private final int MIN_FACES = 4; private int numFaces; //nombre de face sur un dé private int faceValue;// valeur courante du dé // constructeur par défaut: 6 faces, valeur initiale du dé est 1 public Die() { numFaces = 6; faceValue = 1; } Continué…

  48. Constructeurs surchargés:Die.java (cont.) // determine la taille du dé // met le défaut à 6 si valeur invalide public Die (int faces) { if (faces < MIN_FACES){ numFaces = 6; }else{ numFaces = faces; } faceValue = 1; } Continué…

  49. Constructeurs surchargés:Die.java (cont.) //fais rouler le dé et retourne le résultat public int roll() { faceValue = (int) (Math.random() * numFaces) + 1; return faceValue; } // Retourne la valeur courante du dé public int getFaceValue () { return faceValue; } }

  50. Trucs pour écrire des méthodes:Décomposition de méthode • Une méthode devrait être assez petite afin de faciliter la compréhension de sa fonction • Une méthode complexe devrait être décomposé en plusieurs petites méthodes afin de clarifier la fonction • Une méthode de service peut appeler une ou plusieurs méthodes de support pour accomplir sa fonction • Une méthode de support peut en appeler d`autre si l`on a en besoin

More Related