Post on 03-Jan-2016
description
CSI1502Principes fondamentaux en conception des logiciels
Chapitre 4Classes 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:
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
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
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
Plus au sujet des classes Une classe contient des déclarations de donnés et des
déclarations de méthodes
int x, y;char ch;
Déclarations de variables
Déclarations de méthodes
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
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é…
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);
}
}
L`exemple de la pièce de monnaie:PieceDeMonnaie.javapublic 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é…
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é…
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;
}
}
Un exemple:Exécution de PileOuFace
Première exécution:Nombre de tours 1000Nombre de face 493Nombre de pile 507
Deuxième exécution:Nombre de tours 1000Nombre de face 514Nombre de pile 486
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
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
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
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
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
Les variables d`instance
Voir FlipRace.java (page 217)
int etat;
etat
etat 0
1
Pièce de Monnaie 1
Pièce de Monnaie 2
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é
Diagramme UML de classe Un diagramme UML pour le programme
FlipRace:
FLIP RACE COIN
main (args : String[]) : void flip() : voidisHeads() : booleantoString() : String
face : int1 2
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
coin1 : Coinface = 0
coin2 : Coinface = 1
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
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
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
Méthodes
Variables
Client
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
Les modificateur d`accès Les membres d`une classe avec un
modificateur d`accès public sont accessible de partout
Les variables public violent l`encapsulation Les membres d`une classe avec un
modificateur d`accès private ne 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
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
Les modificateur d`accès
public private
variables
méthodes
Viole l`encapsulation
Renforcel`encapsulation
Supporte les autresméthodes de la classe
Fourni les services aux clients
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)
Programme contrôleur:Banque.javapublic 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());
}
}
Programme contrôleur:Comptes.javapublic 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é…
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;
} }
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
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
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
MaMethode();
Exécution MaMethode()
Contrôle d`une méthode La méthode invoqué peut-être aussi dans une
autre classe ou objet
MaClasse.MaMethod
e();
main
AideMoi();
AideMoi()
MaClasse
MaMethode()
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){
Type de la Valeur retourné
nom de la méthode
Liste de paramètres
La liste de paramètres spécifie le type de chaque et chacun des paramètre
Le nom d`un paramètre dans la déclaration d`une méthode est un argument formel
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;
} La valeure retournédoit-être le même type que letype de la Valeur retourné
sum et result sont des variables localesIls sont crées a chaque fois que la méthodeEst invoqué et détruit à la fin de l`exécution
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
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;
}
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
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
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
Méthodes surchargées
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 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 +".");
Constructeurs surchargés:SnakeEyes.javapublic 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 dieDie die2 = new Die(20); //creates a 20-sides diefor (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);
} }
Constructeurs surchargés:Die.javapublic 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é…
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é…
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; }
}
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
Exemple de “pig latin”:“happy” devient “appyhay” Par exemple le processus de transformer une
phrase en anglais en “pig latin” peut-être décomposé en processus de traduire chaque mot individuellement
Le processus de traduire chaque mot peut-être décomposé en le processus de traduire les mots qui :
commencent avec des voyelles commencent avec des consonantes etc…
Voir PigLatin.java (p.238) et PigLatinTranslator.java (p.240)
Dans un diagramme UML les méthodes publiques peuvent être précédé par un +
De même les méthodes privées peuvent être précédé par un –
Un diagramme UML du programme PigLatinTranslator.java
Retour aux diagrammes de classe
PigLatin PigLatinTranslator
+ main (args : String[]) : void
1 1
+ translate (sentence : String) : String- translateWord (word : String) : String- beginsWithVowel (word : String) : boolean- beginsWithBlend (word : String) : boolean
Relations entre Objets Les objets ont différents types de
relations entre l`un et l`autre Une association générale tel que dans les
diagrammes UML et une relation d`utilité Une association générale indique qu`un
objet (ou classe) utilise ou relie à un autre objet (ou classe) d`une certaine façon
L`on devrait annoter la relation dans les diagrammes UML pour indiquer la nature de la relation
Auteur Livreécrit
Relations entre Objets:Exemple des chiffres rationnels
Une association peut arriver entre deux objets de la même classe
Par exemple considérons certains objets de chiffres rationnels
Rational r1 = new Rational(6, 8);Rational r2 = new Rational(1, 3);Rational r3, r4, r5;
r3 = r1.add(r2);r4 = r1. subtract(r2);R5 = r1.divide(r2);
L`objet r1 exécute une méthode et l`autre objet r2 est passé comme paramètre
Relations entre Objets:Comment ”add” marche public int getDenominator() {
return denominator; }
public Rational add (Rational op2) {// le calculint commonDenominator = demonimator * ops.getDenominator();int numerator1 = numerator + ops.getDenominator();int numerator2 = op2.getNumerator() * denominator;int sum = numerator1 + numerator 2;return new Rational (sum, commonDenominator);
}
Agrégation Un objet agrégé est un objet qui
contient des références à d`autre objets Par exemple un objet compte contient
une référence à un objet String (le nom du propriétaire)
Un objet agrégé représente une relation a-un(e) (en anglais has-a)
Un compte de banque a un nom De même un étudiant peut avoir une ou
plusieurs adresses
Agrégation:Adresse étudiantepublic class StudentBody {
public static void main(String[] args) {Address school = new Address(“Smithstreet 1”, “Ottawa”, “ON”, 1KN2);Address jHome = new Address(“Mytown 23”, Quebec”, “QC”, 231G);Student john = new Student(“John”, “Doe”, jHome, school);System.out.println(john); // utilise toString pour l`impression
}}
Voir page 250 à 253Le Résultat
John Doe Hometown 23 Quebec QC 231 Smithstreet 1 Ottawa ON 12312
Agrégation:Etudiant.javapublic class Student{ private String firstName, lastName;private Address homeAddress, schoolAddress;
// initialise l`objet student public Student(String first, String last, Address home, Address school) {
firstName = first;lastName = last;homeAddress = home;schoolAddress = school;
}
public String toString() // retourne l`objet student en tant que String {String result;result = firstName + “ “ + lastName + “ “ + homeAddress + “ “ +schoolAddress;return result;
} }
Agrégation:Adresse.javapublic class Address { private String streetAddress, city, province;private long zipCode;
// initialise l`objet address public Address(String street, String town, String st, long zip) {
streetAddress = street;city = town;province = st;zipCode = zip;
}
public String toString() // retourne l`objet address en tant que String {String result;result = streetAddress + “ “ + city + “ “ + province + “ “ + zipCode;return result;
} }
Une association d`agrégation et montré par un diamant ouvert dans un diagramme UML
Agrégation en UML
StudentBody Student
+ main (args : String[]) : void
1 2
- firstName : String- lastName : String- homeAddress : Address- schoolAddress : Address
+ toString() : String
Address
- streetAddress : String- city : String- province : String- zipCode : long
+ toString() : String
Méthodes Applet Dans des exemples précédents nous avons
utilisé la méthode paint de la classe applet afin de tracer sur un applet
La classe applet a plusieurs méthodes qui sont invoquées automatiquement à un certain point dans la vie d`un applet
La méthode init ne se fait qu`exécuter une seule fois quand l`applet et lancé initialement
La méthode start et stop se font invoquer quand l`applet devient actif ou inactif
La classe applet contient aussi d`autres méthodes qui assistent en générale à l`exécution de l`applet
Objets Graphiques Tout objet défini en écrivant une classe
peut avoir des éléments graphiques Ces objets doivent simplement avoir un
contexte graphique (un objet Graphics) dans lequel l`on peut tracer les éléments graphiques
Un Applet peut passer son contexte graphique a n`importe quel autre objet tout comme l`on peut passer des paramètres
Voir LineUp.java (p. 257) et StickFigure.java (p. 259) comment tracer un “Stick Figure”
En résumé:Ecrire vos propres classes 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