Embedded Files
Introduction à la programmation orienté objet.
Introduction à la programmation orienté objet.
Définition.
La Programmation Orienté Objet (POO), c'est tout simplement faire de son programme un ensemble d'objets qui interagissent entre eux. En d'autres termes :
tout est objet. La programmation orientée objet est l'un des outils les plus importants dans le développement logiciel.
C'est une façon de programmer qui permet une meilleure organisation de son code.
Définition d'objet et de classe.
Un objet en POO reste comme un objet du quotidien. Les objets ont des fonctionnalités et des caractéristiques.
Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les données sont appelées des méthodes. Instancier une classe
consiste à créer un objet sur son modèle. Entre classe et objet il y a, en quelque sorte, le même rapport qu'entre type et variable.
Si vous prenez une voiture, par exemple, il possède avant tout une fonctionnalité : démarrer.
Pour mener à bien cette fonctionnalité, il possède des caractéristiques : Puissance : quantité en nombre des chevaux, Capacité carburant : quantité en litres.
La représentation Graphique est la suivante :
Voiture
+puissance +carburant
Démarrer
Voiture : le nom du type de l'objet (La classe).
puissance, carburant : les caractéristiques de l'objet (les attributs).
Démarrer : les fonctionnalités de l'objet (les méthodes).
En Java, cela correspondrait à un fichier nommé voiture contenant une classe nommée elle aussi Voiture :
Classe
package pkggv;
public class Voiture {
int puissance;
int capacite_Carburant;
public void demarrer() {
System.out.println("Je cuis démarre");
System.out.println("avec ma capacité de " + capacite_carburant + " litres");
System.out.println("et ma puissance de " + puissance );
}
}
Cette classe n'est pas une voiture, mais la description d'une Voiture. C'est lorsque l'on va créer une variable de type Voiture
que l'on va réellement créer une voiture.
test_voiture
package pkggv;
public class Main {
public static void main(String[] args) {
Voiturer mavoiture = new Voiture();
mavoiture.capacite_carburant = 30;
mavoiture.puissance = 180;
mavoiture.cuire();
System.out.println("");
}
}
Il ne faut surtout pas confondre classe et objet :
La classe est la description d'un type : de quels éléments ce type est composé.
Un objet est une variable du type d'une classe. On dit aussi : une instance de classe. Pour décrire un concept, il y a une seule et unique classe, mais il peut y avoir une infinité d'instances de cette classe.
La durée de vie d'un objet.
Les objets ne sont pas des éléments statiques et leur durée de vie ne correspond pas forcément à la durée d'exécution du programme. La durée de vie d'un objet passe par trois étapes :
la déclaration de l'objet et l'instanciation grâce à l'opérateur new (Class mon_objet = new Class()).
l'utilisation de l'objet en appelant ses méthodes
la suppression de l'objet : elle est automatique en Java grâce à la machine virtuelle.
La restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire (garbage collector).
Il n'existe pas d'instruction delete comme en C++.
Les références et la comparaison d'objets
Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet.
Lorsque l'on écrit obj1 = obj2 (obj1 et obj2 sont des objets), on copie la référence de l'objet obj2 dans obj1.
c1 et c2 font référence au même objet : ils pointent sur le même objet. L'opérateur == compare ces références.
Deux objets avec des propriétés identiques sont deux objets distincts.
Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'une méthode à cet effet : la méthode equals() héritée de Object. Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la classe Object dont toutes les classes héritent.
Le littéral null :
Le littéral null est utilisable partout où il est possible d'utiliser une référenc à un objet.
Il n'appartient pas à une classe mais il peut être utilisé à la place d'un objet de n'importe quelle type ou comme paramètre.
null ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel de méthodes et aucune classe ne peut en hériter. Le fait d'affecter null une variable référençant un objet pourra permettre au ramasse-miettes de libérer la mémoire allouée
à l'objet si aucune autre référence n'existe encore sur lui.
Les variables de classes
Elles ne sont définies qu'une seule fois quel que soit le nombre d'objets instanciés de la classe. Leur déclaration est accompagnée
du mot clé static : static int compteur = 0;
La variable this
Cette variable sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation.
this est un objet qui est égal à l'instance de l'objet dans lequel il est utilisé.
private int nombre; public maclasse(int nombre) { this.nombre = nombre; // variable de classe = variable en paramètre du constructeur }
L'opérateur instanceof
L'opérateur instanceof permet de déterminer la classe de l'objet qui lui est passé en paramètre. La syntaxe est objet instanceof classe
if (o instanceof MaClasse ) System.out.println(" o est une instance de la classe MaClasse "); else System.out.println(" o n'est pas un objet de la classe MaClasse ");
Les modificateurs d'accès
Ils s'appliquent aux classes, aux méthodes et aux attributs.
Ils ne peuvent pas être utilisés pour qualifier des variables locales : seules les variables d'instances et de classes peuvent en profiter.
Ils assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de données par les autres objets.
Les mots clés qui gèrent la visibilité des entités
De nombreux langages orientés objet introduisent des attributs de visibilité pour réglémenter l'accès aux classes et aux objets, aux méthodes et aux données.
Il existe 3 modificateurs qui peuvent être utilisés pour définir les attributs de visibilité des entités (classes, méthodes ou attributs) : public, private et protected. Leur utilisation permet de définir des niveaux de protection différents (présentés dans un ordre croissant de niveau de protection offert) :
Le mot clé static
Le mot clé static s'applique aux variables et aux méthodes.
Les variables d'instance sont des variables propres à un objet. Il est possible de définir une variable de classe qui est partagée entre toutes les instances d'une même classe : elle n'existe donc qu'une seule fois en mémoire. Une telle variable permet de stocker une constante ou une valeur modifiée tour à tour par les instances de la classe. Elle se définit avec le mot clé static.
Exemple :
public class Cercle {
static float pi = 3.1416f;
float rayon;
public Cercle(float rayon) {
this.rayon = rayon; }
public float surface() { return rayon * rayon * pi;}
}
Une méthode static est une méthode qui n'agit pas sur des variables d'instance mais uniquement sur des variables de classe. Ces méthodes peuvent être utilisées sans instancier un objet de la classe. Les méthodes ainsi définies peuvent être appelées avec la notation classe.methode() au lieu de objet.methode() : la première forme est fortement recommandée pour éviter toute confusion.
Il n'est pas possible d'appeler une méthode d'instance ou d'accéder à une variable d'instance à partir d'une méthode de classe statique.
Le mot clé final
Le mot clé final s'applique aux variables de classe ou d'instance ou locales, aux méthodes, aux paramètres d'une méthode et aux classes. Il permet de rendre l'entité sur laquelle il s'applique non modifiable une fois qu'elle est déclarée pour une méthode ou une classe et initialisée pour une variable.
Une variable qualifiée de final signifie que la valeur de la variable ne peut plus être modifiée une fois que celle-ci est initialisée.
Exemple:
public class Constante2 {
public final int constante;
public Constante2() {
this.constante = 10;
}
}
Une méthode déclarée final ne peut pas être redéfinie dans une sous-classe. Une méthode possédant le modificateur final pourra être optimisée par le compilateur car il est garanti qu'elle ne sera pas sous-classée.
Lorsque le modificateur final est ajouté à une classe, il est interdit de créer une classe qui en hérite.
Pour une méthode ou une classe, on renonce à l'héritage mais ceci peut s'avérer nécessaire pour des questions de sécurité ou de performance. Le test de validité de l'appel d'une méthode est bien souvent repoussé à l'exécution, en fonction du type de l'objet appelé (c'est la notion de polymorphisme qui sera détaillée ultérieurement). Ces tests ont un coût en termes de performance.
Le mot clé abstract
Le mot clé abstract s'applique aux méthodes et aux classes.
Abstract indique que la classe ne pourra être instanciée telle quelle. De plus, toutes les méthodes de cette classe abstract ne sont pas implémentées et devront être redéfinies par des méthodes complètes dans ses sous-classes.
Abstract permet de créer une classe qui sera une sorte de moule. Toutes les classes dérivées pourront profiter des méthodes héritées et n'auront à implémenter que les méthodes déclarées abstract.
Exemple:
abstract class ClasseAbstraite {
ClasseAbstraite() { ... //code du constructeur }
void methode() { ... // code partagé par tous les descendants }
abstract void methodeAbstraite();
}
class ClasseComplete extends ClasseAbstraite {
ClasseComplete() { super(); ... }
void methodeAbstraite() { ... // code de la méthode }
// void methode est héritée
}
Une méthode abstraite est une méthode déclarée avec le modificateur abstract et sans corps. Elle correspond à une méthode dont on veut forcer l'implémentation dans une sous-classe. L'abstraction permet une validation du codage : une sous-classe sans le modificateur abstract et sans définition explicite d'une ou des méthodes abstraites génère une erreur de compilation.
Une classe est automatiquement abstraite dès qu'une de ses méthodes est déclarée abstraite. Il est possible de définir une classe abstraite sans méthodes abstraites.
Les mots clés : synchronized, volatile et native
Il permet de gérer l'accès concurrent aux variables et méthodes lors de traitements de threads (exécution « simultanée » de plusieurs petites parties de code du programme).
Le mot clé volatile s'applique aux variables.
Il précise que la variable peut être changée par un périphérique ou de manière asynchrone. Cela indique au compilateur de ne pas stocker cette variable dans des registres. A chaque utilisation, sa valeur est lue et réécrite immédiatement si elle a changé.
Une méthode native est une méthode qui est implémentée dans un autre langage. L'utilisation de ce type de méthode limite la portabilité du code mais permet une vitesse d'exécution plus rapide.
Les propriétés ou attributs
Les données d'une classe sont contenues dans des variables nommées propriétés ou attributs. Ce sont des variables qui peuvent être des variables d'instances, des variables de classes ou des constantes.
Les variables d'instances, Les variables de classes, Les constantes et Les méthodes
Une variable d'instance nécessite simplement une déclaration de la variable dans le corps de la classe.
Chaque instance de la classe a accès à sa propre occurrence de la variable.
Les variables de classes sont définies avec le mot clé static.
Chaque instance de la classe partage la même variable.
Les constantes sont définies avec le mot clé final : leur valeur ne peut pas être modifiée une fois qu'elles sont initialisées.
Les méthodes sont des fonctions qui implémentent les traitements de la classe.
La transmission de paramètres
Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui-même qui est passé mais une référence sur l'objet. La référence est bien transmise par valeur et ne peut pas être modifiée mais l'objet peut être modifié par un message (appel d'une méthode).
Pour transmettre des arguments par référence à une méthode, il faut les encapsuler dans un objet qui prévoit les méthodes nécessaires pour les mises à jour.
Si un objet o transmet sa variable d'instance v en paramètre à une méthode m, deux situations sont possibles :
si v est une variable primitive alors elle est passée par valeur : il est impossible de la modifier dans m pour que v en retour contienne cette nouvelle valeur.
si v est un objet alors m pourra modifier l'objet en utilisant une méthode de l'objet passé en paramètre.
L'émission de messages
Un message est émis lorsqu'on demande à un objet d'exécuter l'une de ses méthodes.
La syntaxe d'appel d'une méthode est : nom_objet.nom_méthode(parametre, ... ) ;
Si la méthode appelée ne contient aucun paramètre, il faut laisser les parenthèses vides.
L'enchaînement de références à des variables et à des méthodes
System.out.println("bonjour");
Deux classes sont impliquées dans l'instruction : System et PrintStream. La classe System possède une variable nommée out qui est un objet de type PrintStream. Println() est une méthode de la classe PrintStream. L'instruction signifie : « utilise la méthode println() de la variable out de la classe System ».
La surcharge de méthodes
La surcharge d'une méthode permet de définir plusieurs fois une même méthode avec des arguments différents. Le compilateur choisi la méthode qui doit être appelée en fonction du nombre et du type des arguments. Ceci permet de simplifier l'interface des classes vis à vis des autres classes.
Une méthode est surchargée lorsqu'elle exécute des actions différentes selon le type et le nombre de paramètres transmis.
Il est donc possible de donner le même nom à deux méthodes différentes à condition que les signatures de ces deux méthodes soient différentes. La signature d'une méthode comprend le nom de la classe, le nom de la méthode et les types des paramètres.
Exemple:
class affiche{
public void afficheValeur(int i) {
System.out.println(" nombre entier = " + i);
}
public void afficheValeur(float f) {
System.out.println(" nombre flottant = " + f);
}
}
Les constructeurs et le destructeur
La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode particulière appelée constructeur pour que les variables aient une valeur de départ. Elle n'est systématiquement invoquée que lors de la création d'un objet.
Le constructeur suit la définition des autres méthodes excepté que son nom doit obligatoirement correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y avoir d'instruction return dans un constructeur. On peut surcharger un constructeur.
La définition d'un constructeur est facultative. Si aucun constructeur n'est explicitement défini dans la classe, le compilateur va créer un constructeur par défaut sans argument. Dès qu'un constructeur est explicitement défini, le compilateur considère que le programmeur prend en charge la création des constructeurs et que le mécanisme par défaut, qui correspond à un constructeur sans paramètres, n'est pas mis en oeuvre. Si on souhaite maintenir ce mécanisme, il faut définir explicitement un constructeur sans paramètres en plus des autres constructeurs.
Il existe plusieurs manières de définir un constructeur :
Exemple:
public MaClasse() {}
public MaClasse() {
nombre = 5;
}
public MaClasse(int valeur) {
nombre = valeur;
}
Un destructeur permet d'exécuter du code lors de la libération, par le garbage collector, de l'espace mémoire occupé par l'objet. En Java, les destructeurs appelés finaliseurs (finalizers), sont automatiquement invoqués par le garbage collector.
Pour créer un finaliseur, il faut redéfinir la méthode finalize() héritée de la classe Object.
Les accesseurs
L'encapsulation permet de sécuriser l'accès aux données d'une classe. Ainsi, les données déclarées private à l'intérieur d'une classe ne peuvent être accédées et modifiées que par des méthodes définies dans la même classe. Si une autre classe veut accéder aux données de la classe, l'opération n'est possible que par l'intermédiaire d'une méthode de la classe prévue à cet effet. Ces appels de méthodes sont appelés « échanges de messages ».
Un accesseur est une méthode publique qui donne l'accès à une variable d'instance privée. Pour une variable d'instance, il peut ne pas y avoir d'accesseur, un seul accesseur en lecture ou un accesseur en lecture et un autre en écriture. Par convention, les accesseurs en lecture commencent par get et les accesseurs en écriture commencent par set.
Exemple:
private int valeur = 13;
public int getValeur(){
return(valeur);
}
public void setValeur(int val) {
valeur = val;
}
L'héritage.
L’héritage permet de spécialiser une classe. Par spécialisation, vous pouvez ajouter ou modifier le comportement d’une classe, étendre son fonctionnement.
L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution. Elle définit une relation entre deux classes:
une classe mère ou super-classe
une classe fille ou sous-classe qui hérite de sa classe mère
Le principe de l'héritage
Grâce à l'héritage :
les objets d'une classe fille ont accès aux données et aux méthodes de la classe parente et peuvent les étendre.
Les sous-classes peuvent redéfinir les variables et les méthodes héritées.
Pour les variables, il suffit de les redéclarer sous le même nom avec un type différent.
Les méthodes sont redéfinies avec le même nom, les mêmes types et le même nombre d'arguments, sinon il s'agit d'une surcharge.
L'héritage successif de classes permet de définir une hiérarchie de classe qui se compose de super-classes et de sous-classes. Une classe qui hérite d'une autre est une sous-classe et celle dont elle hérite est une super-classe.
Une classe peut avoir plusieurs sous-classes. Une classe ne peut avoir qu'une seule classe mère : il n'y a pas d'héritage multiple en Java.
Object est la classe parente de toutes les classes en Java. Toutes les variables et méthodes contenues dans Object sont accessibles à partir de n'importe quelle classe car par héritages successifs toutes les classes héritent d'Object.
En JAVA pour exprimer l'héritage on utilise le mot clé "extends", cela indique qu'une classe hérite d'une autre. En l'absence de ce mot réservé associé à une classe, le compilateur considère la classe Object comme classe mère.
Exemple :
class Fille extends Mere { ... }
le mot super permet d'invoquer une méthode d'une classe mère.
Il est aussi utiliser pour appeler le constructeur de la classe mère.
Le lien entre une classe fille et une classe mère est géré par la plate-forme : une évolution des règles de gestion de la classe mère conduit à modifier automatiquement la classe fille dès que cette dernière est recompilée.
En Java, il est obligatoire dans un constructeur d'une classe fille de faire appel explicitement ou implicitement au constructeur de la classe mère.
Quelques règles d’accès aux membres hérités.
Les membres définies avec le modificateur d'accès public restent publiques à travers l'héritage et toutes les autres classes.
Les membres définies avec le modificateur private est bien héritée mais elle n'est pas accessible directement mais par les méthodes héritées.
Les membres définies avec le modificateur protected sera héritée dans toutes les classes filles qui pourront y accéder librement ainsi que les classes du même package.
Polymorphisme, redéfinition et trans-typage.
Le polymorphisme est la capacité, pour un même message de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée par la machine virtuelle dynamiquement à l'exécution.
La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parente (type et nombre de paramètres, la valeur de retour et les exceptions propagées doivent être identiques).
Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge. Cette nouvelle méthode n'est pas héritée : la classe mère ne possède pas de méthode possédant cette signature.
En java l'héritage définit un cast implicite de la classe fille vers la classe mère : on peut affecter à une référence d'une classe n'importe quel objet d'une de ses sous-classes.
Casting
Exemple : la classe Employe hérite de la classe Personne
Personne p = new Personne ("Meftah", "Tarik");
Employe e = new Employe("Soukrat", "Sachat", 10000);
p = e ; // ok : Employe est une sous-classe de Personne
Objet obj;
obj = e ; // ok : Employe hérite de Personne qui elle même hérite de Object
Il est possible d'écrire le code suivant si Employe hérite de Personne
Personne[] tab = new Personne[10];
tab[0] = new Personne("Dupond","Jean");
tab[1] = new Employe("Durand", "Julien", 10000);
Les interfaces.
Les Interfaces correspondants un peu à une classe abstraite
Une interface est un ensemble de constantes et de déclarations de méthodes .
Tous les objets qui qui implémentent une interface possèdent les méthodes et les constantes déclarées dans celle-ci.
Plusieurs interfaces peuvent être implémentées dans une même classe.
Les interfaces se déclarent avec le mot clé interface et sont intégrées aux autres classes avec le mot clé implements.
Une interface est implicitement déclarée avec le modificateur abstract.
Zone de texte
Exemple : Declaration d'une interface.
[public] interface nomInterface [extends nomInterface1, nomInterface2 ... ] {
// insérer ici des méthodes ou des champs static
}
Implémentation d'une interface :
Modificateurs class nomClasse [extends superClasse]
[implements nomInterface1, nomInterface 2, ...] {
//insérer ici des méthodes et des champs
}
Exemple :
interface AfficheType {
void afficherType();
}
class Personne implements AfficheType {
public void afficherType() {
System.out.println(" Je suis une personne ");
}
}
class Voiture implements AfficheType {
public void afficherType() {
System.out.println(" Je suis une voiture ");
}
}
Toutes les méthodes d'une interface sont abstraites : elles sont implicitement déclarées comme telles.
Une interface peut être d'accès public ou package.
Si elle est publique, toutes ses méthodes sont implicitement publiques même si elles ne sont pas déclarées avec le modificateur public.
Si elle est d'accès package, il s'agit d'une interface d'implémentation pour les autres classes du package et ses méthodes ont le même accès package : elles sont accessibles à toutes les classes du packages.
Les seules variables que l'on peut définir dans une interface sont des variables de classe qui doivent être constantes : elles sont donc implicitement déclarées avec le modificateur static et final même si elles sont définies avec d'autres modificateurs.
Toute classe qui implémente cette interface doit au moins posséder les méthodes qui sont déclarées dans l'interface. L'interface ne fait que donner une liste de méthodes qui seront à définir dans les classes qui implémentent l'interface.
Les méthodes déclarées dans une interface publique sont implicitement publiques et elles sont héritées par toutes les classes qui implémentent cette interface. De telles classes doivent, pour être instanciables, définir toutes les méthodes héritées de l'interface.
Une classe peut implémenter une ou plusieurs interfaces tout en héritant de sa classe mère.
L'implémentation d'une interface définit un cast : l'implémentation d'une interface est une forme d'héritage.
Comme pour l'héritage d'une classe, l'héritage d'une classe qui implémente une interface définit un cast implicite de la classe fille vers cette interface.
Il est important de noter que dans ce cas il n'est possible de faire des appels qu'à des méthodes de l'interface.
Pour utiliser des méthodes de l'objet, il faut définir un cast explicite : il est préférable de contrôler la classe de l'objet pour éviter une exception ClassCastException à l'exécution.
Les méthodes par défaut.
En Java, il est possible d'utiliser l'héritage multiple avec les interfaces.
Les méthodes par défaut de Java 8 permettent l'héritage multiple de comportement.
Méthodes par défaut
Exemple :
public interface MonInterface {
default void maMethode() {
System.out.println("Implementation par defaut");
}
}
Les méthodes par défaut sont utilisées pour permettre l'ajout d'une méthode à une interface existante sans avoir à modifier les classes qui l'implémentent.
Les méthodes par défaut sont utilisées pour éviter d'implémenter une classe abstraite qui contient les traitements par défaut de méthodes héritées dans les classes filles concrètes. Ces implémentations peuvent directement être codées dans des méthodes par défaut de l'interface.
Les méthodes par défaut ne remplacent cependant pas complètement les classes abstraites qui peuvent avoir des constructeurs et des membres sous la forme de variables d'instance ou de classe.
L'héritage multiple de comportement permet par exemple que de mêmes méthodes par défaut, avec des signatures identiques, soient définies dans plusieurs interfaces héritées par une interface fille. Il est probable que chaque implémentation de ces méthodes soit différente : le compilateur a besoin de règles pour déterminer quelle implémentation il doit utiliser :
la redéfinition d'une méthode par une classe ou une super-classe est toujours prioritaire par rapport à une méthode par défaut
l'implémentation choisie est celle par défaut de l'interface la plus spécifique
Ainsi une interface peut être modifiée en ajoutant une méthode sans compromettre sa compatibilité ascendante sous réserve qu'elle implémente cette méthode en tant que méthode par défaut.
Les méthodes par défaut sont virtuelles comme toutes les autres méthodes mais elles proposent une implémentation par défaut qui sera invoquée si la classe implémentant l'interface ne redéfinit pas explicitement la méthode. Une classe qui implémente une interface n'a donc pas l'obligation de redéfinir une méthode par défaut. Si celle-ci n'est pas redéfinie alors c'est l'implémentation contenue dans l'interface qui est utilisée.
Test : Default methode
Exemple :
package packt;
public interface Service {
default void afficherNom() {
System.out.println("Nom du service : inconnu");
}
}
package packt;
public class MonService implements Service {
}
package packt;
public class TestMethodeParDefaut {
public static void main(String[] args) {
Service service = new MonService(){};
service.afficherNom();
}
}
Résultat :
Nom du service : inconnu
Si la classe redéfinit la méthode alors c'est l'implémentation de la méthode qui est utilisée.
Suite
package pckgt;
public class MonService implements Service {
@Override
public void afficherNom() {
System.out.println("Nom du service : mon service");
}
}
Résultat :
Nom du service : mon service
L'héritage des méthodes statiques.
Toutes les méthodes, incluant les méthodes statiques, sont héritées d'une super-classe du moment qu'elles soient accessibles par la classe fille.
Héritage methode static
Exemple :
package pckgcst;
public class MaClasseMere {
public static void maMethode() {
System.out.println("MaClasseMere");
}
}
package pckgcst;
public class MaClasseFille extends MaClasseMere {
}
package pckgcst;
public class TestHeritageStatic {
public static void main(String[] args) {
MaClasseMere.maMethode();
MaClasseFille.maMethode();
}
}
Résultat :
MaClasseMere
MaClasseMere
Dans le cas des méthodes statiques, il y a cependant une restriction qui interdit de redéfinir une méthode statique héritée. Pourtant, il est possible d'écrire :
Suite
package pckgtcst;
public class MaClasseFille extends MaClasseMere {
public static void maMethode() {
System.out.println("MaClasseFille");
}
}
Résultat de l'exécution de la méthode TestHeritageStatic :
MaClasseMere
MaClasseFille
Une méthode static ne peut pas être redéfinie (overriden) mais il est possible de définir une méthode dans la classe fille avec la même signature. Si une méthode statique définie dans une classe mère est définie de manière identique dans une classe fille, celle-ci n'est pas une redéfinition mais elle masque (hidden) la méthode de la classe mère.
La redéfinition (overriding) est une fonctionnalité offerte par les langages de POO qui permet de mettre en ouvre une forme de polymorphisme. Une sous-classe fournit une implémentation dédiée d'une méthode héritée de sa super-classe : les signatures des deux méthodes doivent être les mêmes. Le choix de la méthode à exécuter est déterminé à l'exécution en fonction du type de l'objet qui l'invoque.
La surcharge (overload) est une fonctionnalité offerte par les langages de POO qui permet de mettre en oeuvre une forme de polymorphisme. Elle permet de définir différentes méthodes ayant le même nom avec le nombre et/ou le type des paramètres différent.
Le choix de la méthode à exécuter est déterminée statiquement par le compilateur en fonction des paramètres utilisés à l'invocation.
Des conseils sur l'héritage.
Lors de la création d'une classe « mère » il faut tenir compte des points suivants :
la définition des accès aux variables d'instances, très souvent privées, doit être réfléchie entre protected et private
pour empêcher la redéfinition d'une méthode ou sa surcharge, il faut la déclarer avec le modificateur final
Lors de la création d'une classe fille, pour chaque méthode héritée qui n'est pas final, il faut envisager les cas suivants :
la méthode héritée convient à la classe fille : on ne doit pas la redéfinir
la méthode héritée convient mais partiellement du fait de la spécialisation apportée par la classe fille : il faut la redéfinir voire la surcharger. La plupart du temps une redéfinition commencera par appeler la méthode héritée (en utilisant le mot clé super) pour garantir l'évolution du code
la méthode héritée ne convient pas : il faut redéfinir ou surcharger la méthode sans appeler la méthode héritée lors de la redéfinition.
Polymorphisme
Le polymorphisme est la capacité d'une entité à posséder plusieurs formes. En informatique ce vocable s'applique aux méthodes selon leur degré d'adaptabilité, nous distinguons alors deux dénomination :
le polymorphisme statique ou la surcharge de méthode
le polymorphisme dynamique ou la redéfinition de méthode ou encore la surcharge héritée.
La surcharge de méthode (polymorphisme statique) est une fonctionnalité classique des langages orientés objet; elle consiste dans le fait qu'une classe peut disposer de plusieurs méthodes ayant le même nom, mais avec des paramètres formels différents ou éventuellement un type de retour différent. On appelle signature de la méthode l'en-tête de la méthode avec ses paramètres formels.
Le compilateur n'éprouve aucune difficulté lorsqu'il rencontre un appel à l'une des versions surchargée d'une méthode, il cherche dans la déclaration de toutes les surcharges celle dont la signature (la déclaration des paramètres formels) coïncide avec les paramètres effectifs de l'appel.
Exemple
class A
{ int a;
public A (int b )
{ a = b; }
void f ( )
{ a *=10; }
void f ( int x )
{ a +=10*x; }
int f ( int x, char y )
{ a = x+(int)y;
return a; }
}
la redéfinition de méthode (ou polymorphisme dynamique) est spécifique aux langages orientés objet. Elle est mise en oeuvre lors de l'héritage d'une classe mère vers une classe fille dans le cas d'une méthode ayant la même signature dans les deux classes. Dans ce cas les actions dûes à l'appel de la méthode, dépendent du code inhérent à chaque version de la méthode (celle de la classe mère, ou bien celle de la classe fille). Ces actions peuvent être différentes. En java aucun mot clef n'est nécessaire ni pour la surcharge ni pour la redéfinition, c'est le compilateur qui analyse la syntaxe afin de de se rendre compte en fonction des signatures s'il s'agit de redéfinition ou de surcharge.
Exemple
class ClasseMere
class ClasseFille extends ClasseMere
{
int x = 10;
void f ( int a)
{ x +=a; }
void g ( int a, int b)
{ x +=a*b; }
}
{
int y = 20;
void f ( int a) //redéfinition
{ x +=a; }
void g1 (int a, int b) //nouvelle méthode
{ ...... }
}
Mot clé : super
Nous venons de voir que le compilateur s'arrête dès qu'il trouve une méthode ayant la bonne signature dans la hiérarchie des classes, il est des cas où nous voudrions accéder à une méthode de la classe mère alors que celle-ci est redéfinie dans la classe fille. C'est un problème analogue à l'utilisation du this lors du masquage d'un attribut. Il existe un mot clef qui permet d'accéder à la classe mère (classe immédiatement au dessus): le mot super.
On parle aussi de super-classe au lieu de classe mère en Java. Ce mot clef super référence la classe mère et à travers lui, il est possible d'accéder à tous les champs et à toutes les méthodes de la super-classe (classe mère).
Exemple
class A
{
int x = 10;
void g ( int a, int b)
{ x +=a*b; }
}
class B extends A
{
int x = 20; //masque le champ x de la classe mère
void g (char b) //surcharge et redéfinition de g
{ super.x = 21; //accès au champ x de la classe mère
super.g(-8,9); //accès à la méthode g de la classe mère
}
}
Résumé
La surcharge (polymorphisme statique) consiste à proposer différentes signatures de la même méthode.
La redéfinition (polymorphisme dynamique) ne se produit que dans l'héritage d'une classe par redéfinition de la méthode mère avec une méthode fille (ayant ou n'ayant pas la même signature).
Les exceptions en java
Les exceptions représentent le mécanisme de gestion des erreurs intégré au langage Java. Il se compose d'objets représentant les erreurs et d'un ensemble de trois mots clés qui permettent de détecter et de traiter ces erreurs (try, catch et finally ) mais aussi de les lever ou les propager (throw et throws).
Lors de la détection d'une erreur, un objet qui hérite de la classe Exception est créé (on dit qu'une exception est levée) et propagé à travers la pile d'exécution jusqu'à ce qu'il soit traité.
Le bloque try, catch, finally est pour le traitement de l'exceptilon.
Throws permet de déléguer la responsabilité des erreurs à la méthode appelante.
De nombreuses méthodes des packages java indiquent dans leur déclaration qu'elles peuvent lever une exception. Cependant ceci garantit que certaines exceptions critiques seront prises explicitement en compte par le programmeur.
Exemple : Exception Non surveillée
public class TestException {
public static void main(java.lang.String[] args) {
int i = 3;
int j = 0;
System.out.println("résultat = " + (i / j));
}
}
Resultat test :
java TestException
Exception in thread "main" java.lang.ArithmeticException: /
by zero
at tests.TestException.main(TestException.java:23)
Exemple : Solution
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
} catch (Exception e) {
} catch (ArithmeticException e) {
}
}
}
Le bloc try rassemble les appels de méthodes susceptibles de produire des erreurs ou des exceptions.
Si un événement indésirable survient dans le bloc try, la partie éventuellement non exécutée de ce bloc est abandonnée et le premier bloc catch est traité. Si un bloc catch est défini pour capturer l'exception issue du bloc try alors elle est traitée en exécutant le code associé au bloc. Si le bloc catch est vide (aucune instruction entre les accolades) alors l'exception capturée est ignorée.
S'il y a plusieurs types d'erreurs et d'exceptions à intercepter, il faut définir autant de blocs catch que de types d'événements.
La clause finally définit un bloc qui sera toujours exécuté, qu'une exception soit levée ou non. Ce bloc est facultatif. Il est aussi exécuté si dans le bloc try il y a une instruction break ou continue.
La classe Throwable.
C'est la classe de base pour le traitement des erreurs.
Toutes les exceptions dérivent de la classe Throwable.
La classe Error représente une erreur grave intervenue dans la machine virtuelle Java ou dans un sous système Java. L'application Java s'arrête instantanément dès l'apparition d'une exception de la classe Error.
La classe Exception représente des erreurs moins graves. Les exceptions héritant de la classe RuntimeException n'ont pas besoin d'être détectées impérativement par des blocs try/catch.
La classe Throwable possède deux constructeurs :
Throwable() et Throwable(String)
Les principales méthodes de la classe Throwable sont :
String getMessage( ), void printStackTrace( ) et void printStackTrace(PrintStream s)
Exemple
public class TestException {
public static void main(java.lang.String[] args) {
// Insert code to start the application here.
int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
} catch (ArithmeticException e) {
System.out.println("getmessage");
System.out.println(e.getMessage());
System.out.println(" ");
System.out.println("toString");
System.out.println(e.toString());
System.out.println(" ");
System.out.println("printStackTrace");
e.printStackTrace();
}
}
}
Resultat :
C:>java TestException
getmessage
/ by zero
toString
java.lang.ArithmeticException: / by zero
printStackTrace
java.lang.ArithmeticException: / by zero
at tests.TestException.main(TestException.java:24)
Les flux d'entrée/sortie
Les programmes a souvent besoin d'échanger des informations, que ce soit pour recevoir des données d'une source ou pour envoyer des données vers un destinataire.
La source et la destination de ces échanges peuvent être de natures multiples : un fichier, une socket réseau, un autre programme, etc ...
De la même façon, la nature des données échangées peut être diverse : du texte, des images, du son, etc ...
Les flux.
Les flux (streams en anglais) permettent d'encapsuler ces processus d'envoi et de réception de données. Les flux traitent toujours les données de façon séquentielle.
En Java, les flux peuvent être divisés en plusieurs catégories :
les flux d'entrée (input stream) et les flux de sortie (output stream)
les flux de traitement de caractères et les flux de traitement d'octets
Java définit des flux pour lire ou écrire des données mais aussi des classes qui permettent de faire des traitements sur les données du flux. Ces classes doivent être associées à un flux de lecture ou d'écriture et sont considérées comme des filtres. Par exemple, il existe des filtres qui permettent de mettre les données traitées dans un tampon (buffer) pour les traiter par lots.
Toutes ces classes sont regroupées dans le package java.io.
Les classes de gestion des flux
Le nom des classes se compose d'un préfixe et d'un suffixe. Il y a quatre suffixes possibles en fonction du type de flux (flux d'octets ou de caractères) et du sens du flux (entrée ou sortie).
Pour le préfixe, il faut distinguer les flux et les filtres. Pour les flux, le préfixe contient la source ou la destination selon le sens du flux.
Pour les filtres, le préfixe contient le type de traitement qu'il effectue. Les filtres n'existent pas obligatoirement pour des flux en entrée et en sortie.
La package java.io définit ainsi plusieurs classes :
Les flux de caractères avec un fichier.
Les classes FileReader et FileWriter permettent de gérer des flux de caractères avec des fichiers.
Les flux de caractères en lecture sur un fichier
Il faut instancier un objet de la classe FileReader. Cette classe hérite de la classe InputStreamReader et possède plusieurs constructeurs qui peuvent tous lever une exception de type FileNotFoundException:
Constructeur
FileInputReader(String)
FileInputReader(File)
Rôle
Créer un flux en lecture vers le fichier dont le nom est précisé en paramètre.
Idem mais le fichier est précisé avec un objet de type File
Exemple:
FileReader fichier = new FileReader("monfichier.txt");
Il existe plusieurs méthodes de la classe FileReader qui permettent de lire un ou plusieurs caractères dans le flux. Toutes ces méthodes sont héritées de la classe Reader et peuvent toutes lever l'exception IOException.
Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().
Les flux de caractères en écriture sur un fichier
Il faut instancier un objet de la classe FileWriter qui hérite de la classe OuputStreamWriter. Cette classe possède plusieurs constructeurs :
Exemple :
FileWriter fichier = new FileWriter ("monfichier.dat");
Il existe plusieurs méthodes de la classe FileWriter héritées de la classe Writer qui permettent d'écrire un ou plusieurs caractères dans le flux.
Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().
Les flux de caractères tamponnés en lecture avec un fichier
Il faut instancier un objet de la classe BufferedReader. Cette classe possède plusieurs constructeurs qui peuvent tous lever une exception de type FileNotFoundException:
Constructeur
BufferedReader(Reader)
BufferedReader(Reader, int)
Rôle
le paramètre fourni doit correspondre au flux à lire.
l'entier en paramètre permet de préciser la taille du buffer. Il doit être positif sinon une exception de type IllegalArgumentException est levée.
Exemple :
BufferedReader fichier = new BufferedReader(new FileReader("monfichier.txt"));
Il existe plusieurs méthodes de la classe BufferedReader héritées de la classe Reader qui permettent de lire un ou plusieurs caractères dans le flux. Toutes ces méthodes peuvent lever une exception de type IOException. La classe BufferedReader définit une méthode supplémentaire pour la lecture :
Méthode
String readLine()
Rôle
lire une ligne de caractères dans le flux. Une ligne est une suite de caractères qui se termine par un retour chariot '\r' ou un saut de ligne '\n' ou les deux.
Elle possède plusieurs méthodes pour gérer le flux hérité de la classe Reader.
Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().
Exemple
import java.io.*;
public class TestBufferedReader {
protected String source;
public TestBufferedReader(String source) {
this.source = source;
lecture();
}
public static void main(String args[]) {
new TestBufferedReader("source.txt");
}
private void lecture() {
try {
String ligne ;
BufferedReader fichier = new BufferedReader(new FileReader(source));
while ((ligne = fichier.readLine()) != null) {
System.out.println(ligne);
}
fichier.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Les flux de caractères tamponnés en écriture avec un fichier
Il faut instancier un objet de la classe BufferedWriter. Cette classe possède plusieurs constructeurs :
Constructeur
BufferedWriter(Writer)
BufferedWriter(Writer, int)
Rôle
le paramètre fourni doit correspondre au flux dans lequel les données sont écrites.
l'entier en paramètre permet de préciser la taille du buffer. Il doit être positif sinon une exception IllegalArgumentException est levée.
Exemple :
BufferedWriter fichier = new BufferedWriter( new FileWriter("monfichier.txt"));
Il existe plusieurs méthodes de la classe BufferedWriter héritées de la classe Writer qui permettent de lire un ou plusieurs caractères dans le flux.
La classe BufferedWriter possède plusieurs méthodes pour gérer le flux :
Méthode
flush()
newLine()
Rôle
vide le tampon en écrivant les données dans le flux.
écrire un séparateur de ligne dans le flux
Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().
Exemple :
import java.io.*;
import java.util.*;
public class TestBufferedWriter {
protected String destination;
public TestBufferedWriter(String destination) {
this.destination = destination;
traitement();
}
public static void main(String args[]) {
new TestBufferedWriter("print.txt");
}
private void traitement() {
try {
String ligne ;
int nombre = 123;
BufferedWriter fichier = new BufferedWriter(new FileWriter(destination));
fichier.write("bonjour tout le monde");
fichier.newLine();
fichier.write("Nous sommes le "+ new Date());
fichier.write(", le nombre magique est " + nombre);
fichier.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Les flux d'octets avec un fichier.
Les classes FileInputStream et FileOutputStream permettent de gérer des flux d'octets avec des fichiers.
Les flux d'octets en lecture sur un fichier
Il faut instancier un objet de la classe FileInputStream. Cette classe possède plusieurs constructeurs qui peuvent tous lever l'exception FileNotFoundException:
Constructeur
FileInputStream(String)
FileInputStream(File)
Rôle
Ouvre un flux en lecture sur le fichier dont le nom est donné en paramètre
Idem mais le fichier est précisé avec un objet de type File
Exemple :
FileInputStream fichier = new FileInputStream("monfichier.dat");
Il existe plusieurs méthodes de la classe FileInputStream qui permettent de lire un ou plusieurs octets dans le flux. Toutes ces méthodes peuvent lever l'exception IOException.
Exemple :
int octet = 0;
while (octet != -1 ) {
octet = fichier.read();
}
Les flux d'octets en écriture sur un fichier.
Il faut instancier un objet de la classe FileOutputStream. Cette classe possède plusieurs constructeurs :
Constructeur
FileOutputStream(String)
FileOutputStream(String, boolean)
Rôle
Si le fichier précisé n'existe pas, il sera créé. Si il existe et qu'il contient des données celles-ci seront écrasées.
Le booléen permet de préciser si les données seront ajoutées au fichier (valeur true) ou écraseront les données existantes (valeur false)
Exemple :
FileOuputStream fichier = new FileOutputStream("monfichier.dat");
Il existe plusieurs méthodes de la classe FileOutputStream qui permettent d'écrire un ou plusieurs octets dans le flux.
Une fois les traitements sur le flux terminés, il faut libérer les ressources qui lui sont allouées en utilisant la méthode close().
Exemple :
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopieFichier {
public static void main(String args[]) {
try {
copierFichier("source.txt", "copie.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void copierFichier(String source, String destination) throws IOException {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
byte buffer[] = new byte[1024];
int taille = 0;
fis = new FileInputStream(source);
fos = new FileOutputStream(destination);
while ((taille = fis.read(buffer)) != -1) {
System.out.println(taille);
fos.write(buffer, 0, taille);
}
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
}
}
}
}
}
Les flux d'octets tamponnés avec un fichier.
Pour améliorer les performances des flux sur un fichier, la mise en tampon des données lues ou écrites permet de traiter un ensemble d'octets plutôt que de traiter les données octet par octet. Le nombre d'opérations est ainsi réduit.
La classe File
Les fichiers et les répertoires sont encapsulés dans la classe File du package java.io. Il n'existe pas de classe pour traiter les répertoires car ils sont considérés comme des fichiers. Une instance de la classe File est une représentation logique d'un fichier ou d'un répertoire qui peut ne pas exister physiquement sur le disque.
Si le fichier ou le répertoire existe, de nombreuses méthodes de la classe File permettent d'obtenir des informations sur le fichier. Sinon plusieurs méthodes permettent de créer des fichiers ou des répertoires.
La sérialisation
La sérialisation est un opération qui permet de rendre un objet ou un graphe d'objets persistant pour stockage ou échange et vice versa. Cet objet est mis sous une forme sous laquelle il pourra être reconstitué à l'identique. Ainsi il pourra être stocké sur un disque dur ou transmis au travers d'un réseau pour le créer dans une autre JVM.
La sérialisation binaire
Plusieurs éléments agissent pour la mise en oeuvre de la sérialisation :
le mot clé transient
l'interface Serializable qui est un marqueur indiquant que la classe peut être sérialisée
la classe ObjectOutputStream qui permet de sérialiser un objet
la classe ObjectInputStream qui permet de désérialiser un objet précédemment sérialisé
l'interface Externalizable dont l'implémentation des méthodes permet de gérer finement la sérialisation et la désérialisation d'une classe en implémentant son propre mécanisme.
L'interface Serializable de package java.io permet simplement de marquer une classe comme pouvant être sérialisée.
Exemple
public class Personne implements java.io.Serializable {
private String nom = "";
private String prenom = "";
private int taille = 0;
public Personne(final String nom, final String prenom, final int taille) {
this.nom = nom;
this.taille = taille;
this.prenom = prenom;
}
}
La classe ObjectOutputStream
La classe ObjectOutputStream permet de sérialiser un objet ou un graphe d'objets.
Elle ne possède qu'un constructeur public :
Constructeur
ObjectOutputStream(OutputStream out)
Rôle
Créer une instance qui va écrire le résultat de la sérialisation dans le flux fourni en paramètre
Le constructeur de la classe ObjectOutputStream attend en paramètre un flux de type OutputStream dans lequel les données de la sérialisation seront envoyées.
Exemple :
ObjectOutputStream oos = null;
try {
final FileOutputStream fichier = new FileOutputStream("mon_objet.ser");
oos = new ObjectOutputStream(fichier);
// ...
} catch (final java.io.IOException e) {
e.printStackTrace();
} finally {
try {
if (oos != null) {
oos.flush();
oos.close();
}
} catch (final IOException ex) {
ex.printStackTrace();
}
}
La classe ObjectOutputStream propose de nombreuses méthodes pour permettre d'ajouter au flux de la sérialisation des objets sérialisables, des types primitifs, des tableaux, des chaînes de caractères, ...
La méthode writeObject() sérialise le graphe d'objets dont l'objet racine est fourni en paramètre.
Exemple :
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SerializerPersonne {
public static void main(final String argv[]) {
final Personne personne = new Personne("Dupond", "Jean", 175);
ObjectOutputStream oos = null;
try {
final FileOutputStream fichier = new FileOutputStream("personne.ser");
oos = new ObjectOutputStream(fichier);
oos.writeObject(personne);
oos.flush();
} catch (final java.io.IOException e) {
e.printStackTrace();
} finally {
try {
if (oos != null) {
oos.flush();
oos.close();
}
} catch (final IOException ex) {
ex.printStackTrace();
}
}
}
}
La classe ObjectInputStream
La classe ObjectInputStream a pour but de désérialiser un objet précédemment sérialisé.
Elle possède de nombreuses méthodes :
La méthode readObject() renvoie une instance de type Object qu'il est nécessaire de caster vers le type présumé. Pour être sûr du type, il est possible d'effectuer un test sur le type de l'objet retourné en utilisant l'opérateur instanceof.
La JVM ne peut désérialiser un objet que si elle peut charger la classe pour en créer une instance : c'est la raison pour laquelle la méthode readObject() peut lever l'exception ClassNotFoundException.
Exemple :
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class DeSerializerPersonne {
public static void main(final String argv[]) {
ObjectInputStream ois = null;
try {
final FileInputStream fichier = new FileInputStream("personne.ser");
ois = new ObjectInputStream(fichier);
final Personne personne = (Personne) ois.readObject();
System.out.println("Personne : ");
System.out.println("nom : " + personne.getNom());
System.out.println("prenom : " + personne.getPrenom());
System.out.println("taille : " + personne.getTaille());
} catch (final java.io.IOException e) {
e.printStackTrace();
} catch (final ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (ois != null) {
ois.close();
}
} catch (final IOException ex) {
ex.printStackTrace();
}
}
}
}
Resultat :
Personne :
nom : Dupond
prenom : Jean
taille : 175
Les collections
Les collections sont des objets qui permettent de gérer des ensembles d'objets. Ces ensembles de données peuvent être définis avec plusieurs caractéristiques : la possibilité de gérer des doublons, de gérer un ordre de tri, etc. ...
Une collection est un regroupement d'objets qui sont désignés sous le nom d'éléments.
L'API Collections propose un ensemble d'interfaces et de classes dont le but est de stocker de multiples objets. Elle propose quatre grandes familles de collections, chacune définie par une interface de base :
List : collection d'éléments ordonnés qui accepte les doublons
Set : collection d'éléments non ordonnés par défaut qui n'accepte pas les doublons
Map : collection sous la forme d'une association de paires clé/valeur
Queue et Deque : collections qui stockent des éléments dans un certain ordre avant qu'ils ne soient extraits pour traitement
Une collection permet de stocker un groupe d'éléments en respectant certaines fonctionnalités selon l'implémentation : de base, elle permet d'ajouter, de supprimer, d'obtenir et de parcours ses éléments.
Les fonctionnalités des collections sont définies dans cinq interfaces de base : Collection, List, Set, Map, Queue.
Plusieurs interfaces spécialisent certaines fonctionnalités particulières :
SortedSet
NavigableSet
SortedMap
NavigableMap
ConcurrentMap
ConcurrentNavigableMap
BlockingQueue
Deque
BlockingDeque
Elle définit plusieurs classes abstraites qui sont les classes mères de plusieurs implémentations : AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList, AbstractQueue, AbstractMap.
Elle propose plusieurs implémentations à usage généraliste : HashSet, TreeSet, LinkedHashSet, ArrayList, ArrayDeque, LinkedList, PriorityQueue, HashMap, TreeMap, LinkedHashMap.
Elle propose également plusieurs implémentations pour un usage spécifique : WeakHashMap, IdentityHashMap, CopyOnWriteArrayList, CopyOnWriteArraySet, EnumSet, EnumMap.
Pour manipuller les collections java définit :
deux interfaces pour le parcours de certaines collections : Iterator et ListIterator.
une interface et une classe pour permettre le tri de certaines collections : Comparable et Comparator
des classes utilitaires : Arrays, Collections
Le framework Collections propose plusieurs implémentations possédant chacune un comportement et des fonctionnalités particulières.
Le framework de Java 2 définit 6 interfaces en relation directe avec les collections qui sont regroupées dans deux arborescences :
Le JDK ne fournit pas de classe qui implémente directement l'interface Collection.
Le tableau ci-dessous présente les différentes classes qui implémentent les interfaces de bases Set, List et Map :
Les listes chaînées : la classe LinkedList
La classe LinkedList, dans laquelle les éléments de la collection sont reliés par des pointeurs. La suppression ou l'ajout d'un élément se fait simplement en modifiant des pointeurs.
La classe LinkedList possède plusieurs constructeurs :
Constructeur
LinkedList()
LinkedList(Collection<? extends E> c)
Rôle
Créer une nouvelle instance vide
Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre triés dans l'ordre obtenu par son Iterator
Exemple :
LinkedList listeChainee = new LinkedList();
listeChainee.add("element 1");
listeChainee.add("element 2");
listeChainee.add("element 3");
Iterator iterator = listeChainee.iterator();
while (iterator.hasNext()) {
System.out.println("objet = "+iterator.next());
}
La classe HashSet
La classe HashSet, est une implémentation simple de l'interface Set qui utilise une HashMap. La clé de la HashMap est la valeur de hachage de l'élément.
La classe HashSet présente plusieurs caractéristiques :
elle ne propose aucune garantie sur l'ordre de parcours lors de l'itération sur les éléments qu'elle contient
elle ne permet pas d'ajouter des doublons mais elle permet l'ajout d'un élément null
La classe HashSet utilise en interne une HashMap dont la clé est l'élément et dont la valeur est une instance d'Object identique pour tous les éléments.
La classe HashSet possède plusieurs constructeurs :
Exemple :
import java.util.*;
public class TestHashSet {
public static void main(String args[]) {
Set set = new HashSet();
set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
La classe Hashtable
La classe Hashtable, présente depuis Java 1.0, permet d'associer dans une collection des éléments sous la forme de paires clé/valeur.
La classe Hashtable hérite de la classe Dictionary qui n'appartient pas à l'API Collections et a été modifiée, à partir de Java 1.2, pour implémenter l'interface Map et ainsi devenir une classe de l'API Collections.
La classe Hashtable présente plusieurs caractéristiques :
contrairement aux autres classes de l'API Collections, elle est thread-safe car toutes les méthodes sont synchronized.
il n'est pas possible d'utiliser la valeur null comme clé ou valeur
Exemple :
package com.jmdoudoux.test.collections;
import java.util.Hashtable;
public class TestHashtable {
public static void main(final String[] args) {
Hashtable<Integer, String> numbers = new Hashtable<Integer, String>();
numbers.put(1, "Element1");
numbers.put(2, "Element2");
numbers.put(3, "Element3");
String n = numbers.get(2);
if (n != null) {
System.out.println("2 = " + n);
}
}
}
Page updated
Google Sites
Report abuse