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