Chapitre 4 Classes et objets (II)

Sommaire ● Notion de classe et d’objet ● Notion de constructeur ● Portée des données et encapsulation ● Diagrammes UML ● Notion de méthode

Objectifs Définition d’une classe: structure et contenu État d’un objet – Données d’instance Effet de la visibilité (méthodes et données) Structure des méthodes Structure des constructeurs Cœur de la POO: Écriture des classes et définition des objets.

Notion de classe et d’objet Selon les concepts de base de la POO: la notion de classe généralise celle du type la notion d’objet (instance) généralise celle de la variable Du point de vue de la POO, la notion de classe joue le rôle de moule à partir duquel on peut créer (instancier) des objets (ou instances) Chaque classe est définie ainsi: public class Essai // le mot clé public est un spécificateur d’accès { //définition des attributs (champs de données ou variables d’instances) // définition des méthodes }

Notion de classe et d’objet Exemple: Public class Etudiant { //définition des champs String name, adresse; // définition des méthodes void setAdresse (…) {…} void setname(…) {…..} } La classe Etudiant représente le concept général et l’ objet représente un étudiant en particulier (Louis, Alexandre, Mamadou, Ammar, etc.)

Examples de classes Copyright © 2017 Pearson Education, Inc.

Notion de classe et d’objet Un objet est caractérisé par un état et un comportement L’état d’un objet correspond à l’ensemble des valeurs des différents attributs définis au niveau de sa classe d’appartenance L’ensemble des méthodes définies au niveau de sa classe d’appartenance correspondent à son comportement Exemple: Objet Louis représenté par son état: Hamel, 135 Saint-Honoré

Notion de constructeur et création d’objets Tel que spécifié auparavant, un constructeur est une méthode définie au sein de la classe portant le même nom que celle-ci Un constructeur, comme son nom l’indique, permet la création d’un objet Il permet également l’initialisation automatique d’un objet Un constructeur ne renvoie aucun résultat même pas un void (sans valeur de retour) Il peut disposer de plusieurs paramètres Si la classe ne dispose pas de constructeur, c’est le constructeur par défaut qui sera appelé (constructeur sans d’arguments) Public class Etudiant { //définition des champs String name, adress; // définition des méthodes public Etudiant (String nom, String adr) // constructeur de la classe { name= nom; adress= adr;} void setAdress (…) {…} void setName(…) {…} }

Notion de constructeur et création d’objets La création d’un objet entraîne les opérations suivantes: Initialisation par défaut de tous les champs de l’objet Initialisation explicite lors de la déclaration du champ Exécution des instructions du constructeur Exemple: - Etudiant etudiant1; //référence à un objet de type Etudiant - etudiant1= new Etudiant(¨Louis¨, ¨135 saint-honoré¨); // crée un objet de type Etudiant et place sa référence // (adresse) dans etudiant1 et initialise les deux champs: nom et adresse

VOIR EX15 //******************************************************************** // RollingDice.java Author: Lewis/Loftus // // Demonstrates the creation and use of a user-defined class. public class RollingDice { //----------------------------------------------------------------- // Creates two Die objects and rolls them several times. public static void main(String[] args) Die die1, die2; int sum; die1 = new Die(); die2 = new Die(); die1.roll(); die2.roll(); System.out.println("Die One: " + die1 + ", Die Two: " + die2); continue Copyright © 2017 Pearson Education, Inc.

System.out.println("Die One: " + die1 + ", Die Two: " + die2); continue die1.roll(); die2.setFaceValue(4); System.out.println("Die One: " + die1 + ", Die Two: " + die2); sum = die1.getFaceValue() + die2.getFaceValue(); System.out.println("Sum: " + sum); sum = die1.roll() + die2.roll(); System.out.println("New sum: " + sum); } Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Die.java Author: Lewis/Loftus // // Represents one die (singular of dice) with faces showing values // between 1 and 6. public class Die { private final int MAX = 6; // maximum face value private int faceValue; // current value showing on the die //----------------------------------------------------------------- // Constructor: Sets the initial face value. public Die() faceValue = 1; } continue Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Rolls the die and returns the result. public int roll() { faceValue = (int)(Math.random() * MAX) + 1; return faceValue; } // Face value mutator. public void setFaceValue(int value) faceValue = value; // Face value accessor. public int getFaceValue() Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Returns a string representation of this die. public String toString() { String result = Integer.toString(faceValue); return result; } Copyright © 2017 Pearson Education, Inc.

Sample Run Die One: 5, Die Two: 2 Die One: 1, Die Two: 4 Sum: 5 New sum: 6 continue die1.roll(); die2.setFaceValue(4); System.out.println("Die One: " + die1 + ", Die Two: " + die2); sum = die1.getFaceValue() + die2.getFaceValue(); System.out.println("Sum: " + sum); sum = die1.roll() + die2.roll(); System.out.println("New sum: " + sum); } Copyright © 2017 Pearson Education, Inc.

Notion de constructeur et création d’objets La méthode toString: La classe Objet dont dérive toutes les classes simples (que nous définissons et utilisons) dispose de certaines méthodes très utiles qu’on peut utiliser telles quelles ou les modifier selon nos besoins (redéfinition, qu’on verra plus tard) Parmi ces méthodes, on retrouve la méthode toString et equals La méthode toString telle que présentée dans l’exemple (après redéfinition) retourne un objet de type String Elle est invoquée automatiquement en cas de besoin d’une conversion implicite en String ou dans le cas de l’opérateur + lorsque l’un de ses opérandes est de type String

Portée des données et Encapsulation La déclaration des données au sein d’une classe peut se faire à deux niveaux: - En dehors des méthodes définies au niveau d’une classe (1) - Ou bien à l’intérieur de la méthode (2) Exemple: Public Class Die { private int faceValue; // définie en dehors des méthodes ….. public String toString() String result; // définie à l’intérieur de la méthode Result= Integer.toString(faceValue); Return result; }

Portée des données et encapsulation Dans le premier cas (1), on parle de variable d’instance locale à la classe, visible (accessible) par toutes les méthodes de la classe Die On parle de portée limitée à la classe (private- on verra par la suite ce spécificateur) – non visible en dehors de cette classe Chaque objet (die1, die2) créée à partir de cette classe aura ses propres valeurs pour ces variables d’instances – ce qui correspond à son état die1 5 faceValue die2 2

Portée des données et encapsulation Dans le second cas, on parle de variables locales à la méthode Autrement dit, elles ne sont pas accessibles (ou visibles) par les autres méthodes – (result) on parle de portée limitée à la méthode Leur durée de vie est limitée à la durée de vie de la méthode Encapsulation de données dans la POO: masquage de données (informations) Le mécanisme d’encapsulation signifie qu’il n’est pas possible d’agir directement sur les données d’un objet (état) sans passer par l’une des méthodes définies au niveau de son interface et qui correspondent à son comportement

Portée des données et encapsulation Un objet est représenté par deux parties: 1. Une partie visible ou interface: ensemble des services offerts par l’objet et qui correspondent à son comportement (ensemble de méthodes d’instance) 2. Partie non visible ou implémentation: cette partie correspond à la déclaration des variables d’instance et des méthodes et à l’implémentation de celles-ci. Le mécanisme d’encapsulation signifie en POO qu’il n’est pas possible d’agir directement sur les données d’un objet (état) sans passer par l’une des méthodes définies au niveau de son interface. Methods Data Client Copyright © 2017 Pearson Education, Inc.

Portée des données et encapsulation Le concept d’encapsulation, s’il est bien utilisé, offre plusieurs avantages: facilite la mise au point, la maintenance, le test, etc. Il permet en terme général d’améliorer la qualité des programmes OO A cet effet, Java propose plusieurs spécificateurs d’accès . public: s’il est précédé par ce mot clé, le membre est accessible partout (au sein du package et en dehors) . private: s’il est précédé par ce mot clé, le membre est local à la classe . sans spécificateur: s’il n’y a rien, le membre est local au package . Protected: ce spécificateur est lié à la notion d’héritage (on le verra plus tard)

Portée des données et encapsulation Utilisation des spécificateurs d’accès au sein d’une classe: Les méthodes représentant les services offerts par la classe (objet) doivent être déclarées en public si la classe doit être visible en dehors du package, dans le cas contraire (local au package) aucun spécificateur n’est nécessaire Les méthodes supportant les services offerts et les variables d’instances doivent être déclarées en private Les constantes peuvent être déclarées en public, car elles ne sont pas modifiables

Spécificateurs d’accès public private Variables Methods Violate encapsulation Enforce encapsulation Support other methods in the class Provide services to clients Copyright © 2017 Pearson Education, Inc.

Portée des données et encapsulation Dans une classe, outre le constructeur, on peut définir d’autres méthodes permettant la manipulation des variables d’instance Ces méthodes sont: 1. les accesseurs ou méthodes d’accès fournissant les informations relatives à certains champs 2. les mutateurs ou méthodes d’altération modifiant l’état de l’objet – les var d’instances Notation getxxx pour les méthodes d’accès // retourne la valeur de la var d’instance xxx setxxx pour les méthodes d’altération // modifie la valeur de la var d’instance xxx Exemple : setFaceValue(int value) getFaceValue()

Diagrammes UML RollingDice Die UML – langage de modélisation unifiée (Unified Modeling Language) Comme son nom l’indique, il permet de représenter sous forme graphique les classes d’une application avec les informations nécessaires On parle alors de diagramme de classes RollingDice main (args : String[]) : void Die faceValue : int roll() : int setFaceValue (int value) : void getFaceValue() : int toString() : String Copyright © 2017 Pearson Education, Inc.

Notion de méthodes myMethod(); myMethod compute Flot de contrôle La méthode appelée appartient à la même classe que la méthode appelante, seul son nom suffit pour l’appeler (l’utiliser) myMethod(); myMethod compute Copyright © 2017 Pearson Education, Inc.

Notion de méthodes La méthode appelée est définie dans une autre classe - pour l’utiliser, il faut précéder son nom par celui de l’objet (on parle de message adressé à l’objet) obj.doIt(); main doIt helpMe helpMe(); Copyright © 2017 Pearson Education, Inc.

Notion de méthodes: règles d’écriture des méthodes Une méthode est composée : 1. d’une entête qui comporte char calc(int num1, int num2, String message) Nom de la méthode Liste des paramètres formels Type de la valeur de retour

Notion de méthodes: règles d’écriture des méthodes 2. d’un bloc- corps de la méthode – ensemble d’instructions char calc(int num1, int num2, String message) { int sum = num1 + num2; char result = message.charAt(sum); return result; } sum and result are local data They are created each time the method is called, and are destroyed when it finishes executing The return expression must be consistent with the return type Copyright © 2017 Pearson Education, Inc.

Notion de méthodes: règles d’écriture des méthodes La méthode peut être de type void: la méthode dans ce cas ne retourne aucune valeur Exemple: public void instructions(int count) La méthode est précédée par un type de retour (autre que void): la méthode dans ce cas retourne (via l’instruction return) une valeur du même type ou d’un type compatible à celui précisé dans l’entête Dans l’exemple précédent : char calc(int num1, int num2, String message) {…… return result; // result est de type char} Rappel: Le constructeur est une méthode qui ne renvoie rien, même pas void

Notion de méthodes: règles d’écriture des méthodes Paramètres formels ou arguments muets: ce type de paramètres figurent dans l’entête de la méthode sont initialisés lors de l’appel de la méthode en question Ces paramètres ont une portée locale à la méthode (la même que celle des var locales de la méthode) char calc(int num1, int num2, String message) // num1, num2, message sont des paramètres formels

Notion de méthodes: règles d’écriture des méthodes Paramètres ou arguments effectifs: ce sont les arguments fournis lors de l’appel ch = obj.calc(25, count, "Hello"); char calc(int num1, int num2, String message) { int sum = num1 + num2; char result = message.charAt(sum); return result; } Copyright © 2017 Pearson Education, Inc.

Notion de méthodes: règles d’écriture des méthodes Remarque: Important- les paramètres effectifs doivent être de même type que les paramètres formels ou de type compatible (chapitre 2- conversion de données) Les variables locales d’une méthode et les paramètres ont une durée de vie limitée à celle de la méthode (exécution) Les variables d’instance ont une durée de vie égale à celle de l’objet auquel elles sont liées

VOIR EX16 //******************************************************************** // Transactions.java Author: Lewis/Loftus // // Demonstrates the creation and use of multiple Account objects. public class Transactions { //----------------------------------------------------------------- // Creates some bank accounts and requests various services. public static void main(String[] args) Account acct1 = new Account("Ted Murphy", 72354, 102.56); Account acct2 = new Account("Jane Smith", 69713, 40.00); Account acct3 = new Account("Edward Demsey", 93757, 759.32); acct1.deposit(25.85); double smithBalance = acct2.deposit(500.00); System.out.println("Smith balance after deposit: " + smithBalance); continue Copyright © 2017 Pearson Education, Inc.

System.out.println("Smith balance after withdrawal: " + continue System.out.println("Smith balance after withdrawal: " + acct2.withdraw (430.75, 1.50)); acct1.addInterest(); acct2.addInterest(); acct3.addInterest(); System.out.println(); System.out.println(acct1); System.out.println(acct2); System.out.println(acct3); } Copyright © 2017 Pearson Education, Inc.

//******************************************************************** // Account.java Author: Lewis/Loftus // // Represents a bank account with basic services such as deposit // and withdraw. import java.text.NumberFormat; public class Account { private final double RATE = 0.035; // interest rate of 3.5% private long acctNumber; private double balance; private String name; //----------------------------------------------------------------- // Sets up the account by defining its owner, account number, // and initial balance. public Account(String owner, long account, double initial) name = owner; acctNumber = account; balance = initial; } continue Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Deposits the specified amount into the account. Returns the // new balance. public double deposit(double amount) { balance = balance + amount; return balance; } // Withdraws the specified amount from the account and applies // the fee. Returns the new balance. public double withdraw(double amount, double fee) balance = balance - amount - fee; Copyright © 2017 Pearson Education, Inc.

//----------------------------------------------------------------- continue //----------------------------------------------------------------- // Adds interest to the account and returns the new balance. public double addInterest() { balance += (balance * RATE); return balance; } // Returns the current balance of the account. public double getBalance() // Returns a one-line description of the account as a string. public String toString() NumberFormat fmt = NumberFormat.getCurrencyInstance(); return (acctNumber + "\t" + name + "\t" + fmt.format(balance)); Copyright © 2017 Pearson Education, Inc.

Output Smith balance after deposit: 540.0 Smith balance after withdrawal: 107.55 72354 Ted Murphy $132.90 69713 Jane Smith $111.52 93757 Edward Demsey $785.90 continue System.out.println("Smith balance after withdrawal: " + acct2.withdraw (430.75, 1.50)); acct1.addInterest(); acct2.addInterest(); acct3.addInterest(); System.out.println(); System.out.println(acct1); System.out.println(acct2); System.out.println(acct3); } Copyright © 2017 Pearson Education, Inc.

Bank Account Example acct1 acctNumber 72354 balance 102.56 name "Ted Murphy" acct2 69713 acctNumber 40.00 balance name "Jane Smith" Copyright © 2017 Pearson Education, Inc.