CSI1502: Introduction au g

1
CSI1502Introduction au génie logiciel

• Chapitre 5
• Classes améliorées

2
Objectifs du coursClasses améliorées

• Comprendre les implications de
• Références et alias dobjets différents
• Passer des objets (par référence) comme
  paramètres
• Le mot clé static Variables et méthodes
  statiques
• Classes encapsulant les types de données
  primitifs
• Classes incorporées et classes internes
• Interfaces en génie logiciel
• Composants de la GUI, boite de dialogue,
  événements et listeners .

3
Plus dinfos sur les références

• Rappelez-vous (chapitre 2) quune référence
  dobjet contient ladresse mémoire de lobjet.
• Plutôt que de considérer des adresses
  arbitraires, nous décrivons graphiquement les
  références comme des pointeurs vers des objets.
• ChessPiece bishop1 new ChessPiece()

4
La référence null.

• Une référence dobjet ne pointant vers aucun
  objet est appelée une référence nulle.
• Essayer daccéder à lobjet dune telle référence
  cause la levée dune exception NullPointerExceptio
  n .
• Par exemple
• String name
• déclare une référence vers un objet (de type
  String) mais ne crée pas dobjet String.Ainsi
  cette référence ne référe à aucun objet. Donc la
  variable name contient une référence nulle.

5
La référence this

• La référence this permet à un objet de
  sautoréférer.
• A lintérieur dune méthode, la référence this
  référe à lobjet en train dêtre exécuté.
• Par exemple
• if(this.position piece2.position)
• result false
• précise quelle variable position est en train
  dêtre manipulée.
• La référence this référe à lobjet par
  lintermédiaire duquel la méthode contenant le
  code a été appelée.

6
La référence this

• La référence this peut aussi servir à distinguer
  les paramètres dun constructeur des variables
  correspondantes de lobjet avec des noms
  semblables.
• A éviter pour cause de problèmes de lisibilité.

Public Account (Sring name, long acctNumber,
double balance) this.name
name this.acctNumber acctNumber this.balance
balance
7
Affectations reparcourues

• Affecter consiste à copier une valeur et à
  stocker cette copie dans une variable.
• Pour les types de données primitifs num2 num1

8
Object Reference Assignment

• Pour les références dobjets, laffectation copie
  dadresse mémoire bishop2 bishop1

9
Que sont les alias?

• Plusieurs références pointant vers le même objet
  sont des alias du même objet.
• Un objet et ses données peut donc être accédés
  grâce aux différents alias de lobjet.
• Les alias sont utiles, mais doivent être gérés
  avec précautions.
• Modifier létat dun objet affecte létat de tous
  ses alias !

10
Test dégalité pour les objets

• Lopérateur compare les références dobjets et
  retourne true si les références sont des alias
  dun même objet.
• Une méthode est définie pour tous les objets,
  mais à moins davoir été redéfinie lors de
  lécriture dune classe, cette méthode demeure
  identique en action à lopérateur .
• bishop1.equals(bishop2)
• retourne true si les deux références pointent
  vers le même objet.
• On peut redéfinir la méthode equals pour toutes
  conditions dégalité jugées pertinentes.

11
Le Ramasse-miettes en Java

• Quand un objet nest plus référencé par aucune
  référence, celui-ci ne peut plus être accéder par
  le programme.
• Il est donc inutile et peut être considéré comme
  un déchet (garbage).
• Java effectue efface périodiquement de sa mémoire
  ces déchets. Ce processus, appelé
  ramasse-miettes, permet de recycler la mémoire
  des objets déréférencés.

12
Passage dobjets en tant que paramètres

• Les paramètres de méthode en Java sont passés par
  valeur.
• Ceci signifie quune copie du vrai paramètre
  (valeur passée) est stockée dans le paramètre
  formel (argument de la méthode).
• Passer des paramètres revient essentiellement à
  effectuer des affectations.
• Quand un objet est passé à une méthode, le
  paramétre réel et le paramètre formel deviennent
  des alias du même objet.

13
Passer des objets aux méthodes

• Ce que vous effectuez avec un paramètre à
  lintérieur dune méthode peut éventuellement
  avoir des conséquences permanentes (en dehors de
  la méthode).
• ParameterPassing.java (page 277)
• ParameterTester.java (page 279)
• Num.java (page 281)
• Remarquez la différence entre modifier la
  référence et modifier lobjet pointé par la
  référence.

14
ParameterPassing.java

• public class ParameterPassing // sets up 3
  variables and illustrate parameter passing
  public static void main (String
  args) ParameterTester tester new
  ParameterTester() int a1 111 Num a2 new
  Num (222) Num a3 new Num (333) System.out.p
  rintln("Before ChangeValues ") System.out.print
  ln("a1 a2 a3 " a1 " " a2 " "
  a3) tester.changeValues(a1, a2,
  a3) System.out.println("After ChangeValues
  ") System.out.println("a1 a2 a3 " a1 " "
  a2 " " a3)

15
ParameterTester.java

• public class ParameterTester public void
  changeValues(int f1, Num f2, Num
  f3) System.out.println("Before changing the
  values ") System.out.println("f1 f2 f3 "
  f1 " " f2 " " f3) f1
  999 f2.setValue(888) f3 new
  Num(777) System.out.println("After changing
  the values ") System.out.println("f1 f2 f3
  " f1 " " f2 " " f3)

16
Num.java

• public class Num
• private int value // Constructorpublic Num
  (int update) value update
• // set up a valuepublic void setValue(int
  update) value update
• // toStringpublic String toString() return
  value " "

17
Les résultats passage de paramètres

• Avant ChangeValues
• a1 a2 a3 111 222 333
• Before changing the values
• f1 f2 f3 111 222 333
• After changing the values
• f1 f2 f3 999 888 777
• Après ChangeValues
• a1 a2 a3 111 888 333

18
Que sont les variables statiques?

• Associées à une classe et non à un objet.
• Les variables statiques peuvent être appelées
  variables de classe.
• Normalement chaque objet a son propre espace
  mémoire
• Si une variable est déclarée statique, une seule
  copie de la variable existe.
• private static float price
• Lespace mémoire pour une variable statique est
  créé quand la classe la déclarant est
  chargée.Tous les objets de la classe ont accès
  aux variables statiques de la classe ?
• Modifier la valeur dune variable statique
  modifie sa valeur dans toutes les instances de la
  classe.

19
Plus dinfos sur les méthodes statiques

• Les méthodes statiques aussi nommées méthodes de
  classe sont appelées par lintermédiaire du nom
  de classe plutôt quà travers un objet
  particulier.
• Par exemple , les méthodes de la classe Math sont
  statiques.
• Pour créer une méthode statique, nous définissons
  la méthode à laide du mot clé static .
• Les méthodes statiques ne peuvent utiliser des
  variables dinstance, les variables dinstance
  nétant créées quune fois les objets instanciés.

public static int abs(int num)
20
Plus dinfos sur les méthodes statiques un
exemple
Puisquétant statique, la méthode peut être
appelée ainsi
value Helper.triple (5)
21
Méthodes statiques and variables
CountInstances.java
public class CountInstances public static void
main ( String args) Slogan obj obj
new Slogan("Hello world") obj new
Slogan("Talk is cheap.") obj new
Slogan("Don't worry, be happy.") System.out.pr
intln("Slogans created " Slogan.getCount())

22
Méthodes statiques and variables Slogan.java

• public class Slogan
• private String phrase public static int
  count 0
• // the constructor public Slogan (String
  str) phrase str count //
  returns the number of objects of this class
  created public static int getCount() return
  count

23
Que sont les classes encapsulantes?

• Une classe encapsulante représente un certain
  type de données primitif.
• Par exemple
• Integer ageObj new Integer (20)
• utilise la classe Integer pour créer un objet
  représentant lentier 20.
• Pourquoi ceci ?
• Ceci est utile lorsque le programme requiert un
  objet et non un type de données primitif
• Chaque type de données primitif (TDP) est
  encapsulé par de telles classes. Ces classes sont
  situées dans le package Java.lang, voir Figure
  5.4

TDP Wrapper Class byte Byte int Integer char
Character, etc. pour les autres TDPs
24
Quelques méthodes de la classe Integer voir
p.287

• Integer (int value) // constructeur crée un
  nouveau objet Integer
• byte byteValue ()
• double doubleValue ()
• // retourne la valeur de cette objet dans le TDP
  correspondant
• static int ParseInt (String str)
• // retourne lint correspondant à la valeur
  stockée dans la chaîne de caractères.
• static String toBinaryString (int num)
• // retourne une chaîne de caractères
  représentant lentier dans la base correspondant
  à num.

25
Java I/O

• Les entrées / sorties sont effectués en java par
  lintermédiare dobjets représentant des flux de
  données.
• Un flux est une suite ordonnée doctets
• Lobjet System.out représente un flux standart de
  sortie, qui est par défaut lécran.
• Lire à partir du clavier est plus compliqué
  ?chapitre 8.

26
Entrées à partir du clavier

• Les entrées peuvent être lues à partir du clavier
  sans avoir à utiliser les classes Keyboard et
  Wrapper.
• Voir Wages2.java (page 289) Plus au chapitre 8
• import java.io.
• BufferedReader in
• new BufferedReader(new InputStreamReader(System.i
  n))
• String name in.Readline()
• int hours Integer.parseInt(in.readLine())

27
Classes imbriquées
Enclosing Class
Nested Class

• En plus de contenir des données et méthodes, les
  classes peuvent contenir dautres classes dite
  imbriquées.
• Une classe imbriquée a accès aux variables et
  méthodes de la classe dans laquelle elle se
  trouve, même si celles-ci sont déclarées privées.
• Ceci est une relation spéciale et doit être
  utilisé de manière adéquate.

28
Classes Imbriquées

• Une classe imbriquée produit son propre bytecode
  .
• Si une classe nommée Inside est déclarée dans une
  classe nommée Outside, 2 bytecodes seront
  produits
• Outside.class
• OutsideInside.class
• Les classes imbriquées peuvent être déclarées
  statiques, dans lequel cas elles ne peuvent
  référer aux variables et méthodes dinstance.

29
Classes internes classes imbriquées non statiques

• Une classe interne est associée à chaque instance
  de la classe dans laquelle elle est imbriquée, et
  ne peut exister que le temps dinstanciation de
  cette dernière.
• public class TestInner // create and
  manipulate an outer object public static void
  main (String args) Outer out new
  Outer() System.out.println(out) out.changeM
  essage() System.out.println(out)

30
Classes imbriquéesOuter.java

• public class Outer private int num private
  Inner in1, in2 public Outer() num
  2365 in1 new Inner ("Hello") in2 new
  Inner ("Hello again") public void
  changeMessage() in1.message "Eat desert
  first" in2.message "Another
  miracle" public String toString() retur
  n in1 "\n" in2 Continued

31
Classes imbriquées Outer.java

• // The inner class private class Inner
  public String message public Inner
  (String str) message str public
  String toString() num return message
  "\nOuter number " num

32
Classes imbriquées En sortie

• Hello
• Outer number 2366
• Hello again
• Outer number 2367
• Eat desert first
• Outer number 2368
• Another miracle
• Outer number 2369

33
Les interfaces une utilité architecturale pour
le programme
Aucune de ces méthodes naété définie (corps de
fonction)
public interface Doable public void
doThis() public int doThat() public void
doThis2 (float value, char ch) public boolean
doTheOther (int num)
34
Interfaces

• Une interface Java est un ensemble de méthodes
  abstraites et de constantes
• Une méthode abstraite est une méthode dont ne
  figure que la déclaration.
• Une méthode abstraite peut être déclarée en
  utilisant le mot-clé abstract, mais ceci reste
  facultatif dans une interface (une interface ne
  comprenant par définition que des méthodes
  abstraitres)
• Une interface est utilisée pour définir
  formellement un ensemble de méthode quune classe
  devra implémenter.

35
Interfaces Un exemple
public class CanDo implements Doable public
void doThis () // whatever
public void doThat () // whatever
// etc.
36
Plus dinfos sur les interfaces

• Une interface ne peut être instanciée.
• Les méthodes dune interface sont par défaut
  publiques.
• Une classe implémente formellement une interface
  en
• Lq déclarant dans len-tête de la classe.
• Fournissant les implémentations de chaques
  méthodes déclarées dans linterface.
• Si une classe déclare implémenter une interface,
  toutes les méthodes de linterface doivent être
  implémentées, sinon il y aura des erreurs de
  compilation.
• En plus de méthodes abstraites, une interface
  peut contenir des constantes.
• Quand une classe implémente une interface, elle a
  accès à toutes les constantes de cette dernière.

37
Interfaces

• Une classe implémentant une interface peut
  toujours implémenter dautres méthodes
• Une classe peut implémenter de plusieurs
  interfaces
• class ManyThings implements interface 1,
  interface2, interface3
• // all methods of all interfaces
• Les interfaces implémentées sont listées dans la
  clause suivant implements, séparées par des
  virgules.
• La classe doit implémenter obligatoirement toute
  les méthodes de toutes les interfaces listées.

38
Interfaces suite

• La bibliothèque standard Java contient plusieurs
  interfaces utiles.
• Linterface Comparable contient une méthode
  abstraite nommée compareTo, qui est utilisée pour
  comparer des objets.
• La classe String implémente Comparable, ce qui
  nous permet de classer les chaînes de caractères
  en ordre alphabétique.
• Linterface Iterator contient des méthodes
  permettant à lutilisateur de parcourir aisément
  un ensemble dobjets.

39
Linterface comparable

• Linterface Comparable fournit un mécanisme
  commun pour comparer 2 objets
• if (obj1.compareTo(obj2) lt 0)
• System.out.println (obj1 is less than obj2)
• Le résultat est négatif si obj1 est inférieur à
  obj2, 0 sils sont égaux et positif si obj1 est
  supérieur à obj2.

40
L interface iterator

• Linterface Iterator fournit un moyen de
  parcourir un ensemble dobjets un par un.
• La méthode hasNext renvoie un résultat booléen
  (true sil reste des éléments à traiter)
• La méthode next renvoie un objet.
• La méthode remove supprime lobjet renvoyé par la
  méthode next.

41
GUIs et fenêtres de dialogue (approfondissements
au Chapitre 9)

• Une interface graphique utilisateur -Graphical
  User Interface (GUI)- est créée avec au moins
  trois sortes dobjets.
• Composants
• Événements
• listeners
• Un composant GUI définit un élément décran pour
  afficher une information ou pour permettre à
  lutilisateur dinteragir avec le programme
  (boutons à presser, champs textuels,etc).
• Le package Swing contient une classe nommée
  JOptionPane qui simplifie la création,
  lutilisation de fenêtres de dialogues
  élémentaires.

42
Quest-ce quune fenêtre de dialogue?

• Un composant graphique utilisé pour intéragir
  avec lutilisateur.
• Une fenêtre de message affiche une chaîne de
  caractères.
• Une fenêtre de dialogue affiche une invite de
  commande et un espace de saisie.
• Une fenêtre de confirmation présente une question
  oui-ou-non à lutilisateur.

PUSH ME!
43
Au sujet des Events et Listeners
Quand un événement est créé, le générateur
appelle la méthode appropriée du listener,
passant en paramètre un objet décrivant
lévénement.
44
Les interfaces Listener

• On peut créer un objet listener en écrivant une
  classe implémentant une interface listener
  donnée.
• Pour exemple, linterface MouseListener contient
  des méthodes correspondant aux événements souris.
• Après avoir créé le listener, nous ajoutons
  celui-ci au composant qui pourrait générer un
  événement pour lier formellement la source
  dévénements au listener.
• Voir PushCounter.java à la p.305

45
Un event listener PushCounter.java (un extrait)

• import hava.awt.
• import java.awt.event.
• import javax.swing.
• public class PushCounter extends JApplet
• private int pushes
• public void int ()
• pushes 0
• push new JButton(PUSH ME!)
• push.AddActionListener(new ButtonListener())

PUSH ME!
46
SommaireClasses améliorées

• Comprendre les implications de
• Références et alias dobjet différents
• Passer des objets (par référence) comme
  paramètres
• Le mot clé static Variables et méthodes
  statiques
• Classes encapsulant les types de données
  primitifs
• Classes incorporées et classes internes
• Interfaces en génie logiciel
• Composants de la GUI, boite de dialogue,
  événements et listeners .