Cours programmationoriente objet en Java

1
Cours programmation-orientée objet en Java

• Licence dinformatique
• Hugues Fauconnier
• hf_at_liafa.jussieu.fr

2
Plan du cours

• Introduction
• programmation objet pourquoi? Comment? Un exemple
  en Java
• Classes et objets
• Méthode et variables, constructeurs, contrôle
  daccès
• Héritage
• Extension de classe, méthode et héritage,
  variables et héritage, constructeurs et héritage
• Héritage compléments
• Classe Object, clonage, classes abstraites et
  interface, Classes internes et emboîtées
• Exceptions
• Exceptions, assertions
• Divers
• Enumeration, tableaux, conversions, noms
• Généricité
• Généralités, types génériques imbriqués, types
  paramètres bornés, méthodes génériques
• Types de données
• String et expressions régulières, Collections,
  Conteneurs, itérations
• Entrée-sortie
• Introduction à Swing
• Threads

3
Bibliographie

• De nombreux livres sur java (attention java gt
  1.5)
• En ligne
• http//mindview.net/Books/TIJ4
• Thinking in Java, 4th edition Bruce Eckel
• http//java.sun.com/docs/index.html
• Livre conseillé
• The Java Programming language fourth edition AW
  Ken Arnold, James Gosling, David Holmes

4
Chapitre I

• Introduction

5
A) Généralités

• Problème du logiciel
• Taille
• Coût développement et maintenance
• Fiabilité
• Solutions
• Modularité
• Réutiliser le logiciel
• Certification
• Comment?

6
Typage

• Histoire
• Fonctions et procédures (60 Fortran)
• Typage des données (70) Pascal Algol
• Modules données fonctions regroupées (80) ada
• Programmation objet classes, objets et héritage

7
B) Principes de base de la POO

• Objet et classe
• Classe définitions pour des données (variables)
  fonctions (méthodes) agissant sur ces données
• Objet élément dune classe (instance) avec un
  état
• (une méthode ou une variable peut être
• de classe commune à la classe ou
• dinstance dépendant de linstance
• )

8
Principes de bases (suite)

• Encapsulation et séparation de la spécification
  et de limplémentation
• Séparer limplémentation de la spécification.
• Ne doit être visible de lextérieur que ce qui
  est nécessaire, les détails dimplémentation sont
   cachés 
• Héritage
• Une classe peut hériter des propriétés dune
  autre classe un classe peut être une extension
  dune autre classe.

9
Principes de bases de la POO

• Mais surtout notion de polymorphisme
• Si une classe A est une extension dune classe B
• A doit pouvoir redéfinir certaines méthodes
  (disons f())
• Un objet a de classe A doit pouvoir être
  considéré comme un objet de classe B
• On doit donc accepter
• B b
• ba (a a toutes les propriétés dun B)
• b.f()
• Doit appeler la méthode redéfinie dans A!
• Cest le transtypage
• (exemple méthode paint des interfaces graphiques)

10
Principes de bases

• Polymorphisme
• Ici lassociation entre le nom f() et le code
  (code de A ou code de B) a lieu dynamiquement (à
  lexécution)
• Liaison dynamique
• On peut aussi vouloir  paramétrer  une classe
  (ou une méthode) par une autre classe.
• Exemple Pile dentiers
• Dans ce cas aussi un nom peut correspondre à
  plusieurs codes, mais ici lassociation peut
  avoir lieu de façon statique (au moment de la
  compilation)

11
C) Comment assurer la réutilisation du logiciel?

• Type abstrait de données
• définir le type par ses propriétés
  (spécification)
• Interface, spécification et implémentation
• Une interface et une spécification (les
  propriétés à assurer) pour définir un type
• Une (ou plusieurs) implémentation du type
  abstrait de données
• Ces implémentations doivent vérifier la
  spécification

12
Comment assurer la réutilisation du logiciel?

• Pour lutilisateur du type abstrait de données
• Accès uniquement à linterface (pas daccès à
  limplémentation)
• Utilisation des propriétés du type abstrait
  telles que définies dans la spécification.
• (Lutilisateur est lui-même un type abstrait avec
  une interface et une spécification)

13
Comment assurer la réutilisation du logiciel?

• Mais en utilisant un type abstrait lutilisateur
  n'en connaît pas limplémentation
• il sait uniquement que la spécification du type
  abstrait est supposée être vérifiée par
  l'implémentation.
• Pour la réalisation concrète, une implémentation
  particulière est choisie
• Il y a naturellement polymorphisme

14
Notion de contrat (Eiffel)

• Un client et un vendeur
• Un contrat lie le vendeur et le client
  (spécification)
• Le client ne peut utiliser lobjet que par son
  interface
• La réalisation de lobjet est cachée au client
• Le contrat est conditionné par lutilisation
  correcte de lobjet (pré-condition)
• Sous réserve de la pré-condition le vendeur
  sengage à ce que lobjet vérifie sa
  spécification (post-condition)
• Le vendeur peut déléguer lobjet délégué doit
  vérifier au moins le contrat (héritage)

15
D) Un exemple

• Pile abstraite et diverses implémentations

16
Type abstrait de données
NOM pileX FONCTIONS vide pileX -gt
Boolean nouvelle -gt pileX empiler X
x pileX -gt pileX dépiler pileX -gt X x
pileX PRECONDITIONS dépiler(s pileX) ltgt
(not vide(s)) AXIOMES forall x in X, s in
pileX vide(nouvelle())
not vide(empiler(x,s))
dépiler(empiler(x,s))(x,s)
17
Remarques

• Le type est paramétré par un autre type
• Les axiomes correspondent aux pré conditions
• Il ny pas de représentation
• Il faudrait vérifier que cette définition
  caractérise bien un pile au sens usuel du terme
  (cest possible)

18
Pile abstraite en java

• package pile
• abstract class Pile ltTgt
• abstract public T empiler(T v)
• abstract public T dépiler()
• abstract public Boolean estVide()

19
Divers

• package regroupement de diverses classes
• abstract signifie quil ny a pas
  dimplémentation
• public accessible de lextérieur
• La classe est paramétrée par un type (java 1.5)

20
Implémentations

• On va implémenter la pile
• avec un objet de classe Vector (classe définie
  dans java.util.package) en fait il sagit dun
  ListArray
• Avec un objet de classe LinkedList
• Avec Integer pour obtenir une pile de Integer

21
Une implémentation

• package pile
• import java.util.EmptyStackException
• import java.util.Vector
• public class MaPileltTgt extends PileltTgt
• private VectorltTgt items
• // Vector devrait être remplacé par ArrayList
• public MaPile()
• items new VectorltTgt(10)
• public Boolean estVide()
• return items.size()0
• public T empiler(T item)
• items.addElement(item)
• return item
• //

22
Suite

• //
• public synchronized T dépiler()
• int len items.size()
• T item null
• if (len 0)
• throw new EmptyStackException()
• item items.elementAt(len - 1)
• items.removeElementAt(len - 1)
• return item

23
Autre implémentation avec listes

• package pile
• import java.util.LinkedList
• public class SaPileltTgt extends PileltTgt
• private LinkedListltTgt items
• public SaPile()
• items new LinkedListltTgt()
• public Boolean estVide()
• return items.isEmpty()
• public T empiler(T item)
• items.addFirst(item)
• return item
• public T dépiler()
• return items.removeFirst()

24
Une pile de Integer

• public class PileInteger extends PileltIntegergt
• private Integer items
• private int top0
• private int max100
• public PileInteger()
• items new Integermax
• public Integer empiler(Integer item)
• if (this.estPleine())
• throw new EmptyStackException()
• itemstop item
• return item
• //

25
Suite

• public synchronized Integer dépiler()
• Integer item null
• if (this.estVide())
• throw new EmptyStackException()
• item items--top
• return item
• public Boolean estVide()
• return (top 0)
• public boolean estPleine()
• return (top max -1)
• protected void finalize() throws Throwable
• items null super.finalize()

26
Comment utiliser ces classes?

• Le but est de pouvoir écrire du code utilisant la
  classe Pile abstraite
• Au moment de lexécution, bien sûr, ce code
  sappliquera à un objet concret (qui a une
  implémentation)
• Mais ce code doit sappliquer à toute
  implémentation de Pile

27
Un main

• package pile
• public class Main
• public static void vider(Pile p)
• while(!p.estVide())
• System.out.println(p.dépiler())
• public static void main(String args)
• MaPileltIntegergt p1 new
  MaPileltIntegergt()
• for(int i0ilt10i)
• p1.empiler(i)
• vider(p1)
• SaPileltStringgt p2 new SaPileltStringgt()
• p2.empiler("un")
• p2.empiler("deux")
• p2.empiler("trois")
• vider(p2)

28
E) java quelques rappels

• Un source avec le suffixe .java
• Une classe par fichier source (en principe) même
  nom pour la classe et le fichier source (sans le
  suffixe .java)
• Méthode
• public static void main(String)
• main est le point dentrée
• Compilation génère un .class
• Exécution en lançant la machine java

29
Généralités

• Un peu plus quun langage de programmation
• gratuit!
• Indépendant de la plateforme
• Langage interprété et byte code
• Portable
• Syntaxe à la C
• Orienté objet (classes héritage)
• Nombreuses bibliothèques
• Pas de pointeurs! (ou que des pointeurs!)
• Ramasse-miettes
• Multi-thread
• Distribué (WEB) applet, servlet etc
• url http//java.sun.com
• http//java.sun.com/docs/books/tutorial/index.html
  

30
Plateforme Java

• La compilation génère un .class en bytecode
  (langage intermédiaire indépendant de la
  plateforme).
• Le bytecode est interprété par un interpréteur
  Java JVM

Compilation javac interprétation java
31
Langage intermédiaire et Interpréteur

• Avantage indépendance de la plateforme
• Échange de byte-code (applet)
• Inconvénient efficacité

32
Plateforme Java

• La plateforme java software au-dessus dune
  plateforme exécutable sur un hardware (exemple
  MacOs, linux )
• Java VM
• Java application Programming Interface (Java
  API)

33
Tout un environnement

• Java 2 sdk JRE (java runtime environment
  outils de développements compilateur, debogueurs
  etc)

34
Trois exemples de base

• Une application
• Une applet
• Une application avec interface graphique

35
Application

• Fichier Appli.java
• /
• Une application basique...
• /
• class Appli
• public static void main(String args)
• System.out.println("Bienvenue en L3...")
  //affichage

36
Compiler, exécuter

• Créer un fichier Appli.java
• Compilation
• javac Appli.java
• Création de Appli.class (bytecode)
• Interpréter le byte code
• java Appli
• Attention aux suffixes!!!
• (il faut que javac et java soient dans PATH)
• Exception in thread "main" java.lang.NoClassDefFou
  ndError
• Il ne trouve pas le main -gt vérifier le nom!
• Variable CLASSPATH ou option -classpath

37
Remarques

• Commentaires / / et //
• Définition de classe
• une classe contient des méthodes (fonctions) et
  des variables
• Pas de fonctions ou de variables globales
  (uniquement dans des classes ou des instances)
• Méthode main
• public static void main(String arg)
• public
• static
• Void
• String
• Point dentrée

38
Remarques

• Classe System
• out est une variable de la classe System
• println méthode de System.out
• out est une variable de classe qui fait référence
  à une instance de la classe PrintStream qui
  implémente un flot de sortie.
• Cette instance a une méthode println

39
Remarques

• Classe définit des méthodes et des variables
  (déclaration)
• Instance dune classe (objet)
• Méthode de classe fonction associée à (toute la)
  classe.
• Méthode dinstance fonction associée à une
  instance particulière.
• Variable de classe associée à une classe
  (globale et partagée par toutes les instances)
• Variable dinstance associée à un objet
  (instancié)
• Patience

40
Applet

• Applet et WEB
• Client (navigateur) et serveur WEB
• Le client fait des requêtes html, le serveur
  répond par des pages html
• Applet
• Le serveur répond par une page contenant des
  applets
• Applet byte code
• Code exécuté par le client
• Permet de faire des animations avec interfaces
  graphiques sur le client.
• Une des causes du succès de java.

41
Exemple applet

• Fichier MonApplet.java
• /
• Une applet basique...
• /
• import java.applet.Applet
• import java.awt.Graphics
• public class MonApplet extends Applet
• public void paint(Graphics g)
• g.drawString("Bienvenue en en L3...", 50,25)

42
Remarques

• import et package
• Un package est un regroupement de classes.
• Toute classe est dans un package
• Package par défaut (sans nom)
• classpath
• import java.applet.
• Importe le package java.applet
• Applet est une classe de ce package,
• Sans importation il faudrait java.applet.Applet

43
Remarques

• La classe Applet contient ce quil faut pour
  écrire une applet
• extends Applet
• La classe définie est une extension de la classe
  Applet
• Elle contient tout ce que contient la classe
  Applet
• (et peut redéfinir certaines méthodes (paint))
• Patience!!

44
Remarques

• Une Applet contient les méthodes paint start et
  init. En redéfinissant paint, lapplet une fois
  lancée exécutera ce code redéfini.
• Graphics g argument de paint est un objet qui
  représente le contexte graphique de lapplet.
• drawString est une méthode (dinstance) qui
  affiche une chaîne,
• 50, 25 affichage à partir de la position (x,y) à
  partir du point (0,0) coin en haut à gauche de
  lapplet.

45
Pour exécuter lapplet

• Lapplet doit être exécutée dans un navigateur
  capable dinterpréter du bytecode correspondant à
  des applet.
• Il faut créer un fichier HTML pour le navigateur.

46
Html pour lapplet

• Fichier Bienvenu.html
• ltHTMLgt
• ltHEADgt
• ltTITLEgt Une petite applet lt/TITLEgt
• ltBODYgt
• ltAPPLET CODE'MonApplet.class' WIDTH200
  Height50gt
• lt/APPLETgt
• lt/BODYgt
• lt/HTMLgt

47
Html

• Structure avec balises
• Exemples
• ltHTMLgt lt/HTMLgt
• url
• lta target"_blank" href"http//www.liafa.jussieu.
  f/hf"gtpage de hflt/agt
• Ici
• ltAPPLET CODE'MonApplet.class' WIDTH200
  Height50gt
• lt/APPLETgt

48
Exemple interface graphique

• Fichier MonSwing.java
• /
• Une application basique... avec interface
  graphique
• /
• import javax.swing.
• public class MonSwing
• private static void creerFrame()
• //Une formule magique...
• JFrame.setDefaultLookAndFeelDecorated(true
  )
• //Creation d'une Frame
• JFrame frame new JFrame("MonSwing")
• frame.setDefaultCloseOperation(JFrame.EXIT
  _ON_CLOSE)
• //Afficher un message
• JLabel label new JLabel("Bienvenue en
  L3...")
• frame.getContentPane().add(label)
• //Afficher la fenêtre
• frame.pack()
• frame.setVisible(true)

49
Remarques

• Importation de packages
• Définition dun conteneur top-level JFrame,
  implémenté comme instance de la classe JFrame
• Affichage de ce conteneur
• Définition dun composant JLabel, implémenté
  comme instance de JLabel
• Ajout du composant JLabel dans la JFrame
• Définition du comportement de la Jframe sur un
  click du bouton de fremeture
• Une méthode main qui crée la JFrame

50
Pour finir

• Java 1.5 et 6 annotations, types méthodes
  paramétrés par des types
• Très nombreux packages
• Nombreux outils de développement (gratuits)
• eclipse, netbeans..

51
En plus
52
Entrée-sortie

• public static void main(String args)
• // sortie avec printf ou
• double a 5.6d
• double b 2d
• String mul "multiplié par"
• String eq"égal"
• System.out.printf(Locale.ENGLISH,
• "3.2f X 3.2f 6.4f \n", a ,b
  , ab)
• System.out.printf(Locale.FRENCH,
• "3.2f s 3.2f s 6.4f \n", a, mul,b
  eq,ab)
• System.out.format(
• "Aujourd'hui 1tA, 1te 1tB,"
• " il est 1tH h 1tM min 1tS \n",
• Calendar.getInstance())
• // System.out.flush()

53
Sortie

• 5.60 X 2.00 11.2000
• 5,60 multiplié par 2,00 égal 11,2000
• Aujourd'hui mardi, 10 octobre, il est 15 h 31
  min 01

54
Scanner

• Scanner sc new Scanner(System.in)
• for(boolean faitfalse faitfalse)
• try
• System.out.println("Répondre o ou O")
• String s1 sc.next(Pattern.compile("0o"
  ))
• faittrue
• catch(InputMismatchException e)
• sc.next()
• if (sc.hasNextInt())
• int i sc.nextInt()
• System.out.println("entier lu "i)
• System.out.println("next token "sc.next())
• sc.close()

55
Scanner

• if (sc.hasNextInt())
• int i sc.nextInt()
• System.out.println("entier lu "i)
• System.out.println("next token "sc.next())
  sc.close()
• String input "1 stop 2 stop éléphant gris stop
  rien"
• Scanner s new(Scanner(input).useDelimiter("\\ss
  top\\s")
• System.out.println(s.nextInt())
• System.out.println(s.nextInt())
• System.out.println(s.next())
• System.out.println(s.next())
• s.close()

56
Sortie

• next token o
• 1
• 2
• éléphant gris
• rien

57
Les classes

• System
• System.out variable (static) de classe
  PrintStream
• PrintStream contient print (et printf)
• System.in variable (static) de classe InputStream
• Scanner

58
Chapitre IIClasses et objets

• (mais pas dhéritage)

59
Classes et objets

• I) Introduction
• II) Classe membres et modificateurs
• III) Champs modificateurs
• IV) Vie et mort des objets, Constructeurs
• V) Méthodes
• VI) Exemple

60
I) Introduction

• Classe
• Regrouper des données et des méthodes
• Variables de classe
• Méthodes de classe
• Classeslt-gttype
• Objet (ou instance)
• Résultat de la création dun objet
• Variables dinstance
• Variables de classe
• Toute classe hérite de la classe Object

61
II) Classes

• Membres d une classe sont
• Champs données
• Méthodes fonctions
• Classes imbriquées

62
Modificateur de classe

• Précède la déclaration de la classe
• Annotations (plus tard)
• public (par défaut package)
• abstract(incomplète, pas dinstance)
• final(pas dextension)
• Strictfp (technique)

63
III) Champs

• Modificateurs
• annotations
• Contrôle daccès
• private
• protected
• public
• package
• static (variables de classe)
• final (constantes)
• transient
• Volatile
• Initialisations
• Création par opérateur new

64
IV) Vie et mort des objets, constructeurs

• Création dune instance opérateur new
• Objet mort plus de référence à cet objet -gt
  garbage collector
• on peut exécuter du code spécifique quand un
  objet est détruit protected void finalize()
  throws Throwable

65
Références

• Une variable est (en général) une référence à un
  objet
• Type primitif directement une valeur
• Type référence une référence à un objet
  (existant ou créé par new)
• null référence universelle
• conséquences
• dans le passage par valeur un type référence
  correspond à un passage par référence
• a b teste si les a et b référencent le même
  objet
• Méthode equals qui peut être redéfinie (défaut
  thisobj)

66
Exemple

• int i0
• int j0
• (ij) // vrai
• class A
• int i0
• A a
• A bnew A()
• ab
• (ab) // vrai
• bnew A()
• (ab) // faux

67
Constructeurs

• Appelés par lopérateur new pour créer un objet
• Peuvent avoir des paramètres (avec surcharge)
• Initialisent les objets
• Constructeur par défaut (si aucun constructeur
  nest défini)
• Constructeur de copie

68
Exemple

• public class Astre
• private long idNum
• private String nom "ltpasdenomgt"
• private Astre orbite null
• private static long nextId 0
• / Creation dune nouvelle instance of Astre
  /
• private Astre()
• idNum nextId
• public Astre(String nom, Astre enOrbite)
• this()
• this.nomnom
• orbiteenOrbite
• public Astre(String nom)
• this(nom,null)
• //

69
Exemples

• Copie
• public Astre(Astre a)
• idNum a.idNum
• noma.nom
• orbitea.orbite

70
Statique - dynamique

• Statique lt-gt à la compilation
• Dynamique lt-gt à lexécution
• Le type dune variable est déterminé à la
  compilation (déclaration et portée)
• Avec la possibilité de lhéritage une variable
  peut être une référence sur un objet dun autre
  type que le type de sa déclaration

71
Static

• Une variable (une méthode) déclarée static est
  une variable (méthode) de classe elle est
  associée à la classe (pas à une instance
  particulière).
• Statique parce quelle peut être créée au moment
  de la compilation (pas de new()).
• Statique -gt les initialisations doivent avoir
  lieu à la compilation.

72
Initialisations

• private static long nextId 0
• Bloc dinitialisation
• private static long netxId 0
• idNum nextId

73
Initialisation static

• public class Puissancedeux
• static int tab new int12
• static
• tab01
• for(int i0 ilt tab.length-1i)
• tabi1 suivant(tabi)
• static int suivant(int i)
• return i2

74
V) Méthodes

• Modificateurs
• Annotations
• Contrôle daccès (comme pour les variables)
• abstract
• static na pas accès aux variables dinstances
• final ne peut pas être remplacée
• synchronized
• native (utilisation de fonctions  native )
• strictfp

75
Passage par valeur

• public class ParamParVal
• public static void parVal(int i)
• i0
• System.out.println("dans parVal i"0)
• //
• int i 100
• System.out.println("Avant i"i)
• ParamParVal.parVal(i)
• System.out.println("Avant i"i)
• ---------------
• Avant i100
• dans parVal i0
• Avant i100

76
Mais

• Comme les variables sont de références (sauf les
  types primitifs)
• public static void bidon(Astre a)
• anew Astre("bidon", null)
• System.out.println("bidon a"a)
• public static void bidonbis(Astre a)
• a.setNom("bidon")
• a.setOrbite(null)
• System.out.println("bidonbis a"a)

77
Méthodes

• Contrôler laccès
• //
• public void setNom(String n)
• nomn
• public void setOrbite(Astre a)
• orbitea
• public String getNom()
• return nom
• public Astre getOrbite()
• return orbite

78
Méthodes, remplacement

• public String toString()
• String stidNum "("nom")"
• if (orbite ! null)
• st "en orbite " orbite
• return st
• Remplace la méthode toString de la classe Object

79
Nombre variable darguments

• public static void affiche(String ... list)
• for(int i0iltlist.lengthi)
• System.out.print(listi" ")
• //
• affiche("un", "deux","trois")

80
Méthodes main

• public static void main(String args)
• for(int j 0 jltargs.lengthj)
• System.out.print(argsj " ")
  
• Le main est le point daccès et peut avoir des
  arguments

81
VI) exemple Les astres

• package exempleclasses
• /
• _at_author sans
• /
• public class Astre
• private long idNum
• private String nom "ltpasdenomgt"
• private Astre orbite null
• private static long nextId 0
• / Creates a new instance of Astre /
• private Astre()
• idNum nextId

82
Suite

• public Astre(String nom, Astre enOrbite)
• this()
• this.nomnom
• orbiteenOrbite
• public Astre(String nom)
• this(nom,null)
• public Astre(Astre a)
• idNum a.idNum
• noma.nom
• orbitea.orbite
• //

83

• public void setNom(String n)
• nomn
• public void setOrbite(Astre a)
• orbitea
• public String getNom()
• return nom
• public Astre getOrbite()
• return orbite
• public String toString()
• String stidNum "("nom")"
• if (orbite ! null)
• st "en orbite " orbite
• return st

84
Chapitre IIIHéritage
85
Chapitre III Héritage

• A) Extensions généralités
• Affectation et transtypage
• B) Méthodes
• Surcharge et signature
• C) Méthodes (suite)
• Redéfinition et liaison dynamique
• D) Conséquences
• Les variables
• E) Divers
• Super, accès, final
• F) Constructeurs et héritage

86
A) Extension généralités

• Principe de la programmation objet
• un berger allemand est un chien
• il a donc toutes les caractéristiques des chiens
• il peut avoir des propriétés supplémentaires
• un chien est lui-même un mammifère qui est
  lui-même un animal hiérarchie des classes
• On en déduit
• Hiérarchie des classes (Object à la racine)
• et si B est une extension de A alors un objet de
  B est un objet de A avec des propriétés
  supplémentaires

87
Extension généralités

• Quand B est une extension de la classe A
• Tout objet de B a toutes les propriétés dun
  objet de A ( dautres)
• Donc un objet B peut être considéré comme un
  objet A
• Donc les variables définies pour un objet de A
  sont aussi présentes pour un objet de B (
  dautres). Mais elles peuvent être occultées
• Idem pour les méthodes Les méthodes de A sont
  présentes pour B et un objet B peut définir de
  nouvelles méthodes.
• Mais B peut redéfinir des méthodes de A

88
Extension de classe

• Si B est une extension de A
• pour les variables
• B peut ajouter des variables (et si le nom est
  identique cela occultera la variable de même nom
  dans A)
• (occulter continuer à exister mais "caché")
• Les variables de A sont toutes présentes pour un
  objet A, mais certaines peuvent être cachées
• pour les méthodes
• B peut ajouter de nouvelles méthodes
• B peut redéfinir des méthodes (même signature)

89
Remarques

• pour les variables
• c'est le nom de la variable qui est pris en
  compte (pas le type ni les droits accès).
• dans un contexte donné, à chaque nom de variable
  ne correspond qu'une seule déclaration.
• (l'association entre le nom de la variable et sa
  déclaration est faite à la compilation)
• pour les méthodes
• c'est la signature (nom type des paramètres)
  qui est prise en compte
• on peut avoir des méthodes de même nom et de
  signatures différentes (surcharge)
• dans un contexte donné, à un nom de méthode et à
  une signature correspondent une seule définition
• (l'association entre le nom de la méthode et sa
  déclaration est faite à la compilation, mais
  l'association entre le nom de la méthode et sa
  définition sera faite à l'exécution)

90
Extension (plus précisément)

• Si B est une extension de A(class B extends A)
• Les variables et méthodes de A sont des méthodes
  de B (mais elles peuvent ne pas être accessibles
  private)
• B peut ajouter de nouvelles variables (si le nom
  est identique il y a occultation)
• B peut ajouter des nouvelles méthodes si la
  signature est différente
• B redéfinit des méthodes de A si la signature est
  identique

91
Remarques

• Java est un langage typé
• en particulier chaque variable a un type celui
  de sa déclaration
• à la compilation, la vérification du typage ne
  peut se faire que d'après les déclarations
  (implicites ou explicites)
• le compilateur doit vérifier la légalité des
  appels des méthodes et des accès aux variables
• a.f() est légal si au moment de la déclaration de
  a il existe une méthode f() qui peut s'appliquer
• a.m est légal si au moment de la déclaration de a
  il existe une variable m qui peut s'appliquer

92
En conséquence

• Une variable déclarée comme étant de classe A
  peut référencer un objet de classe B ou plus
  généralement un objet dune classe dérivée de A
• un tel objet contient tout ce quil faut pour
  être un objet de classe A
• Par contre une variable déclarée de classe B ne
  peut référencer un objet de classe Ail manque
  quelque chose!

93
Affectation downcast/upcast

• class A
• public int i
• //...
• class B extends A
• public int j
• //...
• public class Affecter
• static void essai()
• A a new A()
• B b new B()
• //ba impossible que signifierait b.j??
• ab // a référence un objet B
• // ba
• b(B)a // comme a est un objet B ok!!

94
Upcasting

• Si B est une extension de A, alors un objet de B
  peut être considéré comme un objet de A
• A anew B()
• On pourrait aussi écrire
• A a(A) new B()
• l'upcasting permet de considérer un objet d'une
  classe dérivée comme un objet d'une classe de
  base
• Upcasting de spécifique vers moins spécifique
  (vers le haut dans la hiérarchie des classes)
• l'upcasting peut être implicite (il est sans
  risque!)
• attention
• il ne s'agit pas réellement d'une conversion
  l'objet n'est pas modifié

95
Downcasting

• Si B est une extension de A, il est possible
  qu'un objet de A soit en fait un objet de B. Dans
  ce cas on peut vouloir le considérer un objet de
  B
• A anew B()
• B b(B)a
• Il faut dans ce cas un cast (transtypage)
  explicite (la "conversion" n'est pas toujours
  possible l'objet considéré peut ne pas être d'un
  type dérivé de B)
• A l'exécution, on vérifiera que le cast est
  possible et que l'objet considéré est bien d'un
  type dérivé de B
• downcasting affirme que l'objet considéré est
  d'un type plus spécifique que le type
  correspondant à sa décalration (vers le bas dans
  la hiérarchie des classes)
• le downcasting ne peut pas être implicite (il
  n'est pas toujours possibles!)
• attention
• il ne s'agit pas réellement d'une conversion
  l'objet n'est pas modifié

96
Casting

• On peut tester la classe avant de faire du
  "downcasting"
• Base sref
• Derive dref
• if(sref instanceof Derive)
• dref(Derive) sref

97
B) Méthodes Surcharge

• Méthodes et signature
• Signature le nom et les arguments et leur types
  (mais pas le type de la valeur retournée)
• Seule la signature compte
• int f(int i)
• char f(int i)
• Les deux méthodes ont la même signature c'est
  interdit
• Surcharge possible
• Plusieurs signatures pour des noms différents
• int f(int i)
• int f(double f)
• Le compilateur détermine par le type des
  arguments quelle fonction est utilisée (on verra
  les règles)

98
Surcharge

• Un même nom de fonction pour plusieurs fonctions
  qui sont distinguées par leur signature
• (Java, C, Ada permettent la surcharge
• En C / est surchargé
• 3/2 division entière -gt 1
• 3.0/2 division réelle -gt 1,5

99
Surcharge

• public int f(int i)
• return i
• // public double f(int i)
• // return Math.sqrt( i)
• //
• public int f(double i)
• return (int) Math.sqrt( i)
• public int f(char c)
• return c

100
Remarques

• La résolution de la surcharge a lieu à la
  compilation
• La signature doit permettre cette résolution
• (quelques complications du fait du transtypage
• Exemple un char est converti en int
• Exemple upcasting
• )

101
C) Méthodes Redéfinition

• Un classe hérite des méthodes des classes
  ancêtres
• Elle peut ajouter de nouvelles méthodes
• Elle peut surcharger des méthodes
• Elle peut aussi redéfinir des méthodes des
  ancêtres.

102
Exemple

• class Mere
• void f(int i)
• System.out.println("f("i") de Mere")
• void f(String st)
• System.out.println("f("st") de Mere")

103
Exemple (suite)

• class Fille extends Mere
• void f() //surcharge
• System.out.println("f() de Fille")
• // char f(int i)
• // même signature mais type de retour différent
• //
• void g() //nouvelle méthode
• System.out.println("g() de Fille")
• f()
• f(3)
• f("bonjour")
• void f(int i) // redéfinition
• System.out.println("f("i") de Fille")
  

104
Exemple

• public static void main(String args)
• Mere mnew Mere()
• Fille fnew Fille()
• m.f(3)
• f.f(4)
• mf
• m.f(5)
• //m.g()
• ((Fille)m).g()
• f.g()

105
Résultat

• f(3) de Mere
• f(4) de Fille
• f(5) de Fille
• g() de Fille
• f() de Fille
• f(3) de Fille
• f(bonjour) de Mere
• g() de Fille
• f() de Fille
• f(3) de Fille
• f(bonjour) de Mere

106
D) Conséquences

• Et les variables?
• Principe
• Une méthode (re)définie dans une classe A ne peut
  être évaluée que dans le contexte des variables
  définies dans la classe A.

107
Exemple

• class A
• public int i4
• public void f()
• System.out.println("f() de A, i"i)
• public void g()
• System.out.println("g() de A, i"i)
• class B extends A
• public int i3
• public void f()
• System.out.println("f() de B, i"i)
• g()

108
Exemple suite

• A anew B()
• a.f()
• System.out.println("a.i"a.i)
• System.out.println("((B) a).i"((B)a).i)
• Donnera
• f() de B, i3
• g() de A, i4
• a.i4
• ((B) a).i3

109
Remarques

• La variable i de A est occultée par la variable i
  de B
• La variable i de A est toujours présente dans
  tout objet de B
• Le méthode g de A a accès à toutes les variables
  définies dans A (et uniquement à celles-là)
• La méthode f de B redéfinit f. f() redéfinie a
  accès à toutes les variables définies dans B

110
E) Divers

• super
• Le mot clé super permet daccéder aux méthodes de
  la super classe
• En particulier super permet dans une méthode
  redéfinie dappeler la méthode dorigine
• (exemple super.finalize() appelé dans une
  méthode qui redéfinit le finalize permet
  d'appeler le finalize de la classe de base)

111
Exemple

• class Base
• protected String nom()
• return "Base"
• class Derive extends Base
• protected String nom()
• return "Derive"
• protected void print()
• Base maref (Base) this
• System.out.println("this.name()"this.nom
  ())
• System.out.println("maref.name()"maref.n
  om())
• System.out.println("super.name()"super.n
  om())
• -------------
• this.name()Derive
• maref.name()Derive
• super.name()Base

112
Contrôle daccès

• protected accès dans les classes dérivées
• Le contrôle daccès ne concerne pas la signature
• Une méthode redéfinie peut changer le contrôle
  daccès mais uniquement pour élargir laccès (de
  protected à public)
• Le contrôle daccès est vérifié à la compilation

113
Interdire la redéfinition

• Le modificateur final interdit la redéfinition
  pour une méthode
• (Bien sûr une méthode de classe ne peut être
  redéfinie! Elle peut être surchargée)
• Une variable avec modificateur final peut être
  occultée

114
E) Constructeurs et héritage

• Le constructeurs ne sont pas des méthodes comme
  les autres
• le redéfinition na pas de sens.
• Appeler un constructeur dans un constructeur
• super() appelle le constructeur de la super
  classe
• this() appelle le constructeur de la classe
  elle-même
• Ces appels doivent se faire au début du code du
  constructeur

115
Constructeurs

• Principe
• Quand une méthode dinstance est appelée lobjet
  est déjà créé.
• Création de lobjet (récursivement)
• Invocation du constructeur de la super classe
• Initialisations des champs par les
  initialisateurs et les blocs dinitialisation
• Une fois toutes ces initialisations faites, appel
  du corps du constructeur (super() et this() ne
  font pas partie du corps)

116
Exemple

• class X
• protected int xMask0x00ff
• protected int fullMask
• public X()
• fullMask xMask
• public int mask(int orig)
• return (orig fullMask)
• class Y extends X
• protected int yMask 0xff00
• public Y()
• fullMask yMask

117
Résultat
118
La classe Objet

• Toutes les classes héritent de la classe Object
• méthodes
• public final Classlt? extends Objectgt getClass()
• public int hashCode()
• public boolean equals(Object obj)
• protected Object clone() throws
  CloneNotSupportedException
• public String toString()
• protected void finalize() throws Throwable
• (wait, notify,notfyall)

119
Exemple

• class A
• int i
• int j
• A(int i,int j)
• this.iithis.jj
• class D ltTgt
• T i
• D(T i)
• this.ii

120
Suite

• public static void main(String args)
• A anew A(1,2)
• A bnew A(1,2)
• A ca
• if (ab)
• System.out.println("ab")
• else
• System.out.println("a!b")
• if (a.equals(b))
• System.out.println("a equals b")
• else
• System.out.println("a not equals b")
• System.out.println("Objet a "a.toString()"
  classe "a.getClass())
• System.out.println("a.hashCode()"a.hashCode()
  )
• System.out.println("b.hashCode()"b.hashCode()
  )
• System.out.println("c.hashCode()"c.hashCode()
  )
• D ltIntegergt xnew DltIntegergt(10)
• System.out.println("Objet x "x.toString()"
  classe "x.getClass())

121
Résultat

• a!b
• a not equals b
• Objet a A_at_18d107f classe class A
• a.hashCode()26022015
• b.hashCode()3541984
• c.hashCode()26022015
• Objet x D_at_ad3ba4 classe class D

122
En redéfinissant equals

• class B
• int i
• int j
• B(int i,int j)
• this.iithis.jj
• public boolean equals(Object o)
• if (o instanceof B)
• return i((B)o).i j((B)o).j
• else return false

123
Suite

• B dnew B(1,2)
• B enew B(1,2)
• B fe
• if (de)
• System.out.println("ed")
• else
• System.out.println("d!e")
• if (d.equals(e))
• System.out.println("d equals e")
• else
• System.out.println("a not equals b")
• System.out.println("Objet d
  "d.toString())
• System.out.println("Objet e
  "e.toString())
• System.out.println("d.hashCode()"d.hashCo
  de())
• System.out.println("e.hashCode()"e.hashCo
  de())

124
Résultat

• d!e
• d equals e
• Objet d B_at_182f0db
• Objet e B_at_192d342
• d.hashCode()25358555
• e.hashCode()26399554

125
Chapitre IV

• Interfaces, classes imbriquées, Object

126
Chapitre IV

• Interfaces
• Classes imbriquées
• Objets, clonage

127
classes abstraites

• abstract class Benchmark
• abstract void benchmark()
• public final long repeat(int c)
• long start System.nanoTime()
• for(int i0iltci)
• benchmark()
• return (System.nanoTime() -start)
• class MonBenchmark extends Benchmark
• void benchmark()
• public static long mesurer(int i)
• return new MonBenchmark().repeat(i)

128
suite

• public static void main(String st)
• System.out.println("temps"
• MonBenchmark.mesurer(1000000))
• Résultat
• temps6981893

129
Interfaces

• Il n'y a pas d'héritage multiple en Java une
  classe ne peut être l'extension que d'une seule
  classe
• Par contre une classe peut implémenter plusieurs
  interfaces (et être l'extension d'une seule
  classe)
• Une interface ne contient (essentiellement) que
  des déclarations de méthodes
• Une interface est un peu comme une classe sans
  données membres et dont toutes les méthodes
  seraient abstraites

130
Héritage "multiple" en java
131
Exemple

• interface ComparableltTgt
• int compareTo(T obj)
• class Couple implements ComparableltCouplegt
• int x,y
• //
• public int compareTo(Couple c)
• if(xltc.x)return 1
• else if (c.xx)
• if (c.yy)return 0
• return -1

132
Remarques

• Pourquoi, a priori, l'héritage multiple est plus
  difficile à implémenter que l'héritage simple?
• Pourquoi, a priori, implémenter plusieurs
  interfaces ne pose pas (trop) de problèmes?
• (Comment ferait-on dans un langage comme le C?)

133
Quelques interfaces

• Cloneable est une interface vide(!) un objet qui
  l'implémente peut redéfinir la méthode clone
• Comparable est une interface qui permet de
  comparer les éléments (méthode compareTo)
• runnable permet de définir des "threads"
• Serializable un objet qui l'implémente peut être
  "sérialisé" converti en une suite d'octets pour
  être sauvegarder.

134
Déclarations

• une interface peut déclarer
• des constantes (toutes les variables déclarées
  sont static public et final)
• des méthodes (elles sont implicitement abstract)
• des classes internes et des interfaces

135
Extension

• les interfaces peuvent être étendues avec
  extends
• Exemple
• public interface SerializableRunnableextends
  Serializable, Runnable
• (ainsi une interface peut étendre de plusieurs
  façons une même interface, mais comme il n'y a
  pas d'implémentation de méthodes et uniquement
  des constantes ce n'est pas un problème)

136
Exemple

• interface X
• int val0
• interface Y extends X
• int val1
• int sommevalX.val
• class Z implements Y
• public class InterfaceHeritage
• public static void main(String st)
• System.out.println("Z.val"Z.val"
  Z.somme"Z.somme)
• Z znew Z()
• System.out.println("z.val"z.val
• " ((Y)z).val"((Y)z).val
• " ((X)z).val"((X)z).val)
• ---------------

137
Redéfinition, surcharge

• interface A
• void f()
• void g()
• interface B
• void f()
• void f(int i)
• void h()
• interface C extends A,B
• Rien n'indique que les deux méthodes void f() ont
  la même "sémantique". Comment remplir le double
  contrat?

138
Chapitre IV

• Interfaces
• Classes internes et imbriquées
• Object, clonage

139
Classes imbriquées (nested classes)

• Classes membres statiques
• membres statiques d'une autre classe
• Classes membres ou classes internes (inner
  classes)
• membres d'une classe englobante
• Classes locales
• classes définies dans un bloc de code
• Classes anonymes
• classes locales sans nom

140
Classe imbriquée statique

• membre statique d'une autre classe
• classe ou interface
• mot clé static
• similaire aux champs ou méthodes statiques n'est
  pas associée à une instance et accès uniquement
  aux champs statiques

141
Exemple

• class PileChainee
• public static interface Chainable
• public Chainable getSuivant()
• public void setSuivant(Chainable
  noeud)
• Chainable tete
• public void empiler(Chainable n)
• n.setSuivant(tete)
• teten
• public Object depiler()
• Chainable tmp
• if (!estVide())
• tmptete
• tetetete.getSuivant()
• return tmp
• else return null

142
exemple (suite)

• class EntierChainable implements
  PileChainee.Chainable
• int i
• public EntierChainable(int i)this.ii
• PileChainee.Chainable next
• public PileChainee.Chainable getSuivant()
• return next
• public void setSuivant(PileChainee.Chainable
  n)
• nextn
• public int val()return i

143
et le main

• public static void main(String args)
• PileChainee p
• EntierChainable n
• pnew PileChainee()
• for(int i0 ilt12i)
• nnew EntierChainable(i)
• p.empiler(n)
• while (!p.estVide())
• System.out.println(
• ((EntierChainable)p.depiler()).val())
  

144
Remarques

• Noter l'usage du nom hiérarchique avec '.'
• On peut utiliser un import
• import PileChainee.Chainable
• import PileChainee
• (Exercice réécrire le programme précédent sans
  utiliser de classes membres statiques)

145
Classes membres

• membre non statique d'une classe englobante
• peut accéder aux champs et méthodes de l'instance
• une classe interne ne peut pas avoir de membres
  statiques
• un objet d'une classe interne est une partie d'un
  objet de la classe englobante

146
Exemple

• class CompteBanquaire
• private long numero
• private long balance
• private Action der
• public class Action
• private String act
• private long montant
• Action(String act, long montant)
• this.actact
• this.montant montant
• public String toString()
• return numero"""act" "montant

147
Suite

• //
• public void depot(long montant)
• balance montant
• dernew Action("depot",montant)
• public void retrait(long montant)
• balance - montant
• dernew Action("retrait",montant)

Slide 148