Cours programmationoriente objet en Java - PowerPoint PPT Presentation

Loading...

PPT – Cours programmationoriente objet en Java PowerPoint presentation | free to download - id: 2a5717-ZGI4N



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Cours programmationoriente objet en Java

Description:

Classe Object, clonage, classes abstraites et interface, Classes internes et embo t es ... affichage. POO-L3 H. Fauconnier. 36. Compiler, ex cuter... Cr er un fichier Appli.java ... – PowerPoint PPT presentation

Number of Views:890
Avg rating:3.0/5.0
Slides: 419
Provided by: huguesfa
Learn more at: http://www.liafa.jussieu.fr
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: 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
About PowerShow.com