3. poo en java - perso.univ-mlv.frperso.univ-mlv.fr/ocure/imn/imnjava0809_cm3.pdf · olivier curé...

Olivier Curé UMLV [page 99 ]

3. POO en Java


Déclaration d'une classe

Il est préférable de définir une unique classe par fichier java. Cette classe est alors publique et donne son nom au fichier

Exemple :public class Cercle {... // définition des membres}

Le nom du fichier est nécessairement Cercle.java (respecter la casse).


Création d'un objet : new

La seule manière de créer un objet en Java est d'utiliser l'opérateur new.

Cet opérateur doit être suivi du nom de la classe à instancier.

Exemple : String chaine = new String();String salut = new String(" Bonjour ");ParserXML parserXml = new ParserXML();Syntaxe :<classe> <référence sur objet> = new <constructeur de la

classe>;


Opérateur new

L'instanciation d'une classe déclenche les actions suivantes :

● création de l'objet,● allocation mémoire nécessaire à cet objet,

● appel du constructeur de la classe.


Constructeur en Java

Toute classe possède un constructeur par défaut, implicite.

Un constructeur porte nécessairement le même nom que sa classe, sans type de retour.

Il peut y avoir plusieurs constructeurs dans une même classe. Ceux-ci diffèrent par le nombre et la nature de leurs paramètres.


Destructeur en Java

En java, la destruction des objets est prise en charge par le garbage collecteur (GC) ou ramasse-miettes.

Le GC détruit les objets pour lesquels il n'existe plus de référence.

Aucune garantie n'est apportée quant à la destruction des objets.

On peut forcer le mécanisme à l'aide de la méthode finalize.


Critéres de visibilité des membres

L'accessibilité des membres est pondérée par des critères de visibilité donnés par les modificateurs suivants :

● public : accessible hors de la classe● private : accessible uniquement dans la classe

● protected: accessible dans toutes les classes du package et ses dérivées

● (pas spécifié) : accessible dans toutes les classes du package.


Règles d'accès aux membrespublic protected package private

Classe de définition Oui Oui oui oui

Classe du même package oui oui oui non

Sous-classe dans un oui oui non non

package différent

Classe qui n'est pas une oui non non oui

sous-classe dans un

package différent

accessible à :


Réflexivité d'un objet : this

Tout objet se " voit " lui-même.Le mot clé this permet de montrer qu'une méthode accède à ses propres propriétés et/ou méthodes.


Invocation de méthodesL'invocation d'une méthode s'effectue en nommant l'instance et en la faisant suivre du nom de la méthode avec la liste des paramètres, éventuellement vide.

<objet>.methode(parametres);

Le passage de paramètres dans les méthodes dépend de la nature des paramètres :

- par référence pour les objets.- par copie pour les types primitifs.

NB : - Pour être invoquées à l'extérieur de la classe, les méthodes doivent faire partie de l'interface publique de l'instance.


Invocation des attributs

Il est possible d'accéder aux attributs à condition que la définition de la classe le permette.

<objet>.nom_attribut;

La spécification de l'objet n'est pas obligatoire si l'accès est réalisé au sein d'une méthode de la classe courante.

Le respect des principes de l'encapsulation impose de fournir des méthodes d'accès aux attributs.


Exemple invocation des attributs

public class Exemple {

public int x;

private int y;

...}

public class ExempleTest {

public static void main(String args[]) {

Exemple ex1 = new Exemple();

ex1.x = 10;

ex1.y =5;

System.out.println(ex1.x + " " + ex1.y);

} } Correct ?


Exemple: classe Cercle

public class Cercle { private double rayon; public static final double PI = 3.14159; public Cercle() { rayon = 1.0; } public Cercle(double rayon) { this.rayon = rayon; } public double circonference() { return 2*PI*rayon; } public double surface() { return PI*rayon*rayon; }}

● 4 méthodes dont 2 constructeurs.● 2 propriétés dont une constante.● Le fichier se nomme Cercle.java


Exemple: classe CercleTest

public class CercleTest { public static void main(String args[]) { Cercle c1 = new Cercle(); System.out.println(" Surface de c1 = " +c1.surface());

Cercle c2 = new Cercle(5.5); System.out.println(" Circonference de c2 = " +c2.circonference()); }}

Le fichier CercleTest.java est exécutable (il y a une méthode main).


Les tableaux en Java

En java, les tableaux sont considérés comme des objets :

- création à l'aide de l'opérateur new,- héritage des méthodes d'instances de Object.- les variables du type tableau manipulent des

références aux tableaux,- possèdent une propriété d'instance final int length qui donne la taille du tableau.


Les tableaux en Java (2)Déclaration et création

int[] monTableau = new int[10];

Déclaration, création et initialisationint[] monTableau2 = {1,2,3,4,5};

Un tableau en Java s'exploite de la même manière qu'un tableau en C.

monTableau[0] = 0; // initialisation de la 1ère cellule

Il est possible de manipuler des tableaux multi-dimensionnés.

int[][] monTableau3 = new int[][];


Membres statiques

Rappel : membres = méthodes + attributsEn java, on définir un membre de classe à l'aide du mot réservé static.

Dans la classe Cercle, PI est statique => Quelque soit le nombre d'instances de Circle, il n'y aura qu'un exemplaire de PI.

Pour accéder à un membre statique, il faut le précéder du nom de sa classe.


Membres statiques 2

Explication de "System.out.println(..)"La classe System contient une propriété de classe dont le nom est out.

L'objet System.out appelle une méthode objet de nom println().


Mot réservé : final

Le mot réservé final déclare une constante et impose à l'attribut de ne pouvoir être modifié par la suite.

Exemple : public static final double PI = 3.14159;


4. Héritage, classe abstraite, interface et

paquetage


HéritageEn java, il n'existe que de l'héritage simple.L'héritage multiple est : trop complexe et peut

provoquer des problèmes sur les références(C++).

Le parent commun à toutes les classes est : Object.

La définition d'une sous-classe est réalisée à l'aide du mot réservé extends.

Cette sous-classe hérite alors des méthodes et attributs de sa super-classe.

L'opérateur instanceOf permet de déterminer la classe d'une instance (résultat booléen).


Constructeur d'une sous-classe

Le constructeur d'une sous-classe invoque le constructeur de sa super-classe (première instruction).

Le désignateur super permet de faire référence à sa super-classe.


Exemple d'héritagepublic class Ellipse {

public double r1, r2; public Ellipse(double r1, double r2)

{this.r1 = r1; this.r2 = r2;}public double surface() {...}

} public class Cercle extends Ellipse {

public Cercle(double r) {super(r,r);}

public double rayon() {return r1;}

} Ellipse e = new Ellipse(2.0, 3.0);Cercle c = new Cercle(4.0); System.out.println(e instanceof Cercle); // false System.out.println(e instanceof Ellipse); // true System.out.println(c instanceof Cercle); // true System.out.println(c instanceof Ellipse); // true:c dérive de Ellipse System.out.println(c instanceof Object); // true

Ellipse

Cercle


Redéfinition de méthodes

Une méthode héritée peut être redéfinie dans une sous-classe : il faut alors la réécrire en conservant la même signature (paramètres et type de retour).

Exemple : Cercle peut redéfinir " surface " de Ellipse.

La méthode redéfinie peut exploiter super sur la méthode de sa super-classe.


Exemple de redéfinition de méthodes

public class Cercle extends Ellipse { public Cercle(double r)

{super(r,r);} public double rayon()

{return r1;} public double surface()

{... super.surface(); ... }}


Surcharge de méthodes

On réalise une surcharge de méthodes lorsque l'on déclare 2 méthodes de même nom mais avec des signatures différentes : par le nombre et/ les types de paramètres.

Par contre, le type de retour doit être identique.On retrouve ce mécanisme lors de la définition de

constructeurs et lors de l'implémentation de sous-classe (surcharge d'une méthode de la super-classe).


Redéfinition ≠ surcharge

On surcharge une méthode quand on garde le même nom et le même type de retour mais pas les mêmes paramètres dans la même classe ou sous-classes.


Masquage de variables

Une sous-classe peut redéfinir les variables portant le même nom que celles de sa super-classe.

Une sous-classe peut accéder aux variables de sa super-classe à l'aide de casting ou bien de super.


Retour sur le mot réservé : final

Une classe déclarée final ne peut être étendue.

De même, une méthode déclarée comme final ne peut être redéfinie.

Enfin, une variable déclarée comme finalne peut être masquée.


Classe abstraite

Elle se trouve au sommet de la hiérarchie des classes.

Elle définit l'interface des méthodes et ne peut être instanciée.

Définir des méthodes abstraites dans une classe impose que la classe soit abstraite et que les sous-classes implémentent ses méthodes pour devenir concrètes.

Une classe abstraite contient généralement au moins une méthode abstraite.

Une méthode abstraite n'est pas implémentée.


Exemple Classe abstraiteabstract class GeometriePlane {

static final double PI = 3.14159;abstract double perimetre();

abstract double surface(); }class Disque extends GeometriePlane { float rayon; public double perimetre() {return 2*GeometriePlane.PI*rayon;} public double surface() {return GeometriePlane.PI*rayon*rayon;}}class Rectangle extends GeometriePlane { float largeur, hauteur; public double perimetre() {return 2*(largeur+hauteur);} public double surface() {return largeur*hauteur;}}


Interface

Une interface Java (≠ interface graphique) est une classe où toutes les méthodes sont abstraites.

Cette notion "remplace" l'héritage multiple car une classe peut implémenter plusieurs interfaces.

Le mot clé abstract n'est pas utilisé.On ne peut pas instancier une interface.Définition d'une interface à l'aide de l'instruction interface.

La sous-classe implémente une interface à l'aide de l'instruction implements.


Exemple interfaceabstract class GeometriePlane { abstract double perimetre();} interface Dessinable { public void dessiner(); }public class Rectangle extends GeometriePlane implements Dessinable {

double largeur, hauteur; public double perimetre() {return 2*(largeur+hauteur);} public void dessiner() {....} } public class Disque extends GeometriePlane implements Dessinable {

double rayon; public double perimetre() {return 2*Math.PI*r;} public void dessiner() {....} }


Interface (2)

On peut manipuler les rectangles et les disques comme des Dessinable à l'aide du polymorphisme :

Dessinable formes[] = {new Disque(5), new Rectangle(2,3)}; for(int i = 0; i < formes.length; i++)

{ formes[i].dessiner(); } Une interface peut étendre une autre interface à

l'aide de l'instruction extends. La hiérarchie des interfaces est différente de celle des classes.

Dans la pratique, une interface ne peut contenir que des méthodes publiques et des attributs constants.


Paquetage ou package

Un paquetage regroupe un ensemble de classes (et interfaces) liées à un même domaine particulier (par exemple gestion des bases de données, accès au réseau, etc.).

Les objectifs sont :- organisation cohérente des classes et

interfaces.- facilite le développement de bibliothèques.- protection supplémentaire avec le mode

protégé.


Création d'un package

Il faut ajouter en tête de l'unité de compilation (du fichier) package NomDuPackage;

- indique à quel package appartient la (ou les) classe(s) du fichier.

Exemple d'un package d'objets graphiques :package Graphics;interface Dessinable {...}class Disque {...}class Rectangle {...}class Cercle {...}


Utilisation des classes d'un package

Les classes (ou interfaces) d'un package peuvent être utilisées (importées) individuellement ou de manière globale (le package entier) par toute autre unité de compilation désirant les utiliser.

Seules les classes déclarées publiques (public) dans le package sont accessibles.

En dehors du package, les noms des classes sont : NomDuPackage.NomDeLaClasse.

L'instruction import NomDuPackage permet d'utiliser (importer) les classes sans les préfixer par leur nom de package - si pas d'importation (import), il faut indiquer le nom complet de la classe NomDuPackage.NomDeLaClasse pour l'exploiter.


Importation des packages et des classes

4 formes pour spécifier l'importation ● pas d'import : class TestImport1 { public static void main(String args[]) { java.awt.Point p = new java.awt.Point(1,2); }

● import package.comp1...compn; import java.awt :

class TestImport2 { public static void main(String args[]) { awt.Point p = new awt.Point(1,2); }


API : Interface de programmation des

applications● Core API regroupe un ensemble de classes prédéfinies

d'usage général que l'on retrouve sur toutes les plates-formes.

● Core API est découpée en plusieurs packages : java.applet : Gestion des applets

java.awt : Gestion du fenêtrage et de son contenu (Cf. swing)

java.io : Gestion des entrées-sorties et des fichiers java.lang : Gestion des types et des éléments de base du

langage java.net : Gestion de la communication sur le réseau java.util : Structures de données et utilitaires java.rmi : Remote Method Invocation, appli. distribuée

java.security : Signatures digitales, contrôle d'accès.


Importation des packages et des classes (2)

● import package.comp1...compn.Class : import java.awt.Point; class TestImport3 { public static void main(String args[]) { Point p = new Point(1,2);

} ● import package.comp1...compn.*: import java.awt.*; class TestImport4 { public static void main(String args[]) { Point p = new Point(1,2); Rectangle r = new Rectangle(); }


Exception

En Java, le traitement de certaines erreurs est automatique.

Lorsqu'une méthode détecte une erreur, elle lève une exception. Celle-ci est équivalente à un signal ou à une interruption logicielle.

Une exception est un objet Java (instance de la classe Exception) envoyé à la JVM.


Principe des exceptions

Le principe des exceptions en java est le suivant :● toute méthode qui a un problème lève (throw)

une exception .● tout code qui appelle cette méthode doit

attraper (catch) cette exception.● la plupart des exceptions demandent à être

"attrapées" faute de quoi le programme s'arrête en cours d'exécution.

● la recherche se fait en local, puis remonte la liste des appelants - acquittement de l'exception et reprise du code.

● Structures spécialisées : try {...} catch {...}


Exploitation des exceptions

Il est nécessaire de séparer le bloc d'instructions pouvant engendrer des erreurs. Ce bloc est insérer au niveau d'un try.

Le(s) bloc(s) catch permet(tent) de récupérer la main pour traiter l'exception. On peut aussi utiliser ces blocs pour spécialiser les traitements.


Exemple de gestion d'une exception

try { x = System.in.read(); } catch (IOException e) { System.out.println("Erreur : " + e.getMessage());}


5. Collections dans Java


Présentation générale

● Une collection est un objet qui contient d'autres objets.

● Ces objets proposent une solution au stockage de données et permettent une manipulation de celles-ci

● Les classes et interfaces se trouvent dans le paquetage : java.util.


Collections et versions de Java

● Premières versions de Java :– Tableaux– Vector : tableaux dynamiques (listes)– Hashtable : tables associatives

● A partir de Java2, existence d'une infrastructure pour la gestion de collections ( dans le package java.util).


Infrastructure

● Offre une architecture unifiée pour représenter et manipuler les collections.

● Composée de 3 parties :– Une hiérarchie d'interfaces permettant de

représenter les collections sous forme de types abstraits.

– Des implémentations de ces interfaces.– Implémentation de méthodes liées aux

collections (recherche, tri, etc.).


Avantages

● Les collections permettent de :– Améliorer la qualité et la performance des

applications– Réduire l'effort lors de l'implémentation– Faciliter l'apprentissage de nouvelles API– Réduire le coût de conception de nouvelles

API– Encourager le réutilisation de logiciels.


Interfaces

● 2 hiérarchies principales :– Map : collections indexées par

des clés (Cf. Entrées d'un dictionnaire)

– Collection


Classes

● Abstraites : AbstractCollection, AbstractMap, AbstractList, ...

● Concrètes : ArrayList, HashSet, TreeSet, HashMap, ... Elles héritent des classes abstraites


Interface Collection

● Un objet qui est un groupe d'objets● Principales méthodes :

●boolean add(Object obj)

● boolean contains(Object obj)

● boolean containsAll(Collection collection)

● Iterator iterator()

● int size()

● Object[] toArray()

● Object[] toArray(Object[] tableau)


Interface Set● Un groupe d'objets n'acceptant pas 2

objets égaux (au sens de equals).● Implémentations :

– HashSet garantit un temps constant pour les opérations de base (set, size, add, remove).

– TreeSet garantit que les éléments sont rangés dans leur ordre naturel (interface Comparable) ou l'ordre d'un Comparator.


Interface List

● Un groupe d'objets repérés par des numéros (en débutant à l'indice 0).

● Classes implémentées : ArrayList (tableau à taille variable), LinkedList (listechaînée)

● En règle générale, on utilise ArrayList maisLinkedList est utile si il y a beaucoup d'opérations d'insertions/suppressions (evite les décalages).


Classe ArrayList

● Une sorte de tableau contenant un nombre quelconque d'instances de la classe Object (utiliser Integer pour ranger des entiers).

● Les emplacements sont repérés par des valeurs entières (à débutant à 0, comme un tableau).

● Les méthodes ne sont pas synchronisées (Vector).


Méthodes de ArrayList

● boolean add(Object obj)

● void add(int indice, Object obj)

● boolean contains(Object obj)

● Object get(int indice) => casting l'élément.

● int indexOf(Object obj)

● Iterator iterator()

● void remove(int indice)

● void set(int indice, Object obj)

● int size()


Exemple d'ArrayList

ArrayList liste = new ArrayList();

Personne p1 = new Personne("Toto");

liste.add(p1);

// création d'autres instances de Personne

for (int cpt=0; cpt<liste.size();cpt++)

System.out.println(((Personne)liste.get(cpt)).getNom());

}


Interface Iterator

● Une interface permettant d'énumérer les éléments contenus dans une collection.

● Toutes les collections proposent une méthode itérator renvoyant un itérateur.


Méthodes d'Iterator

● boolean hasNext()

● object next()

– Lance une exception NoSuchElementException lorsqu'il n'y a plus rien à renvoyer.


Exemple d'Iterator



liste.add(p1);


Iterator it = liste.iterator();

while(it.hasNext()) {

System.out.println(((Personne)it.next()).getNom());

}


Exemple d'Iterator (2)


Personne p1 = new Personne("Toto", "Marie");

liste.add(p1);


Iterator it = liste.iterator();

while(it.hasNext()) {

Personne tmp = (Personne)it.next();

System.out.println(tmp.getNom()+" "+tmp.getPrenom());

}


Interface Map

● Des couples clé-valeur.● Une clé repère une unique valeur.● Implémentations :

– HashMap : table de hachage avec garantie d'un accès en temps constant.

– TreeMap : arbre ordonnée* suivant les valeurs des clés (accès en log(n)).

* ordre naturel ou une instance de Comparator.


Méthodes de Map● boolean containsKey(Object clé)

● boolean containsValue(Object valeur)

● Set entrySet()

● Object get(Object clé) // null si objet n'existe pas.

● boolean isEmpty()

● Set keySet()

● int size()

● Collection values()


Table de hachage

● Une table de hachage range des éléments en les regroupant dans des sous-ensembles pour les retrouver plus rapidement.

● Le regroupement dépend de la valeur d'un calcul effectué sur les éléments.

● On retrouve l'élément en fournissant la valeur.

● Recherche efficace si répartition uniforme des éléments sur les sous-ensembles.


Classe HashMap

● Utilise la structure d'une table de hachage pour ranger les clés.

● La méthode hashCode() est exploitée pour répartir les clés dans la table de hachage.


Exemple de HashMapMap hm = new HashMap();


p1.setMatricule("p99");

hm.put(p1.getMatricule(), p1);

. . // création d'autres instances de Personne

Personne p2 = (Employe)hm.get("p101");

Collection elements = hm.values();

Iterator it = elements.iterator();

while (it.hasNext()) {

System.out.println(

((Personne)it.next()).getNom());

}


Trier une liste

import java.util.*;public class Coll1 { public static void main(String args[]) { List liste = new ArrayList(); liste.add( new Integer(9)); liste.add(new Integer(12)); liste.add(new Integer(5)); Collections.sort(liste); Iterator it = liste.iterator(); while (it.hasNext()) { System.out.println(

((Integer)it.next()).toString()); } }}


Recherche dans une liste

import java.util.*;public class ListePersonneTest {

public static void main(String[] args) {List liste = new ArrayList();Personne p1 = new Personne("Xyel","Pierre");Personne p2 = new Personne("Durand","jean");Personne p3 = new Personne("Smith","Joe");liste.add(p1);liste.add(p2);liste.add(p3);

Collections.sort(liste, new ComparatorPersonne());System.out.println("Recherche ="+ Collections.binarySearch(liste,p1,new ComparatorPersonne()));

}

}// Exécution : Rercherche = 2.


Interface Comparator

● Elle propose une méthode : – int compare(Object o1, Object o2)

Elle doit renvoyer :– Un entier positif si o1 est "plus grand" que

o2.– 0 si la valeur de o1 est identique à celle de

o2.– Une entier négatif si o1 est "plus petit" que

o2.


Exemple d'un Comparator

import java.util.Comparator;

public class ComparatorPersonne implements Comparator {

public int compare(Object o1, Object o2) {

String nom1 = ((Personne) o1).getNom();

String nom2 = ((Personne) o2).getNom();

return nom1.compareTo(nom2);

}

}


Utilisation d'un Comparator

import java.util.*

public class ListePersonneTest {

public static void main(String[] args) {

List liste = new ArrayList();

Personne p1 = new Personne("Xyel","Pierre");

Personne p2 = new Personne("Durand","jean");

Personne p3 = new Personne("Smith","Joe");

liste.add(p1);

liste.add(p2);

liste.add(p3);

Collections.sort(liste, new ComparatorPersonne())

}

}

3. poo en java - perso.univ-mlv.frperso.univ-mlv.fr/ocure/imn/imnjava0809_cm3.pdf · olivier curé...

Documents