Chapitre 5 Les Modificateurs d’accès,les packages et les interfaces. A. Nejeoui

POO Java / Modificateurs, packages et interfaces Introduction Dans les 3 premiers chapitres sur le langage java, vous avez appris à construire des classes, créer des objets instances de ces classes et manipuler les variables et méthodes d’instances / de classes. Dans ce chapitre vous allez approfondir vos connaissances concernant les classes. On va couvrir les points suivants : Contrôler l’accès aux variables et méthodes en dehors de la classe Le mot clef final (variable, méthode et classe) Les méthodes et classes abstraites Regroupement des classes en packages Les interfaces 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Définition Les modificateurs de contrôle d’accès : public, private et protected (classe, interface, méthode et variable) Le modificateur static pour déclarer une méthode ou une variable de classe. Le modificateur final (classe, interface, méthode ou variable) Le modificateur abstract pour créer des classes et des méthodes abstraites. Les modificateurs synchronized et volatile qui sont utilisés avec les threads. Un modificateur (ou qualifieur) est un mot clef que vous ajoutez devant l’identificateur d’une classe, méthode, variable ou interface pour modifier sa signification. Java définit une variété de modificateurs dont on peut citer : 22/11/2017 POO Java / Modificateurs, packages et interfaces

Utilisation des modificateurs Pour utiliser un modificateur, vous le placez devant l’élément qu’il modifie que ce soit une classe, une interfaces, une méthode ou une variable. Le modificateur doit être placé avant le reste de l’instruction. Exemple : public class Test{ private final int n=0; } Dans le cas ou vous avez à utiliser plusieurs modificateurs avec le même élément. Vous pouvez les mettre dans n’importe quel ordre tant qu’ils sont tous placés devant l’élément qu’ils modifient. Attention Le type de retour d’une méthode n’est pas un modificateur, les modificateurs sont optionnels ! 22/11/2017 POO Java / Modificateurs, packages et interfaces

Les modificateurs de contrôle d’accès Les modificateurs de contrôle d’accès sont : private, protected, public et « package lorsque aucun des trois autres modificateurs ni mentionné». Ils permettent de contrôler la visibilité d’une classe, d’une interface, d’une méthode ou d’une variable ». Modificateur d’accès par défaut « package »: Lorsque vous déclarez une classe, une interface, une variable ou une méthode sans aucun modificateur d’accès , dans ce cas c’est le modificateur de contrôle d’accès par défaut qui appliqué  « package ». un élément modifié avec le modificateur de contrôle d’accès par défaut est visible dans toutes les classes qui appartiennent au même package de cet l’élément. Exemples : class A{ String nom="Ahmed" int fct(){return 0;} } 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces private Remarques : vous ne pouvez modifier l’accès à un élément avec plus q’un seul modificateur de contrôle d’accès. Ainsi l’instruction public protected int n; //est invalide Une classe ou interface ne peut être déclarée protected ni private. private Le modificateur de contrôle d’accès private est utilisé pour limiter l’accès aux méthodes et aux variables membres d’une classe. Une variable ou méthode déclarée private est visible seulement dans le corps de sa classe, aucune autre classe ne peut y accéder. Une méthode/variable peut être déclarée private dans les cas suivants: Lorsque les autres classes n’ont aucune raison pour l’utiliser. Lorsque l’accès à cette méthode/variable affecte la sécurité du système. Pour séparer la spécification de la réalisation. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces private Dans cet exemple le nom est une variable privé de la classe Test . Donc aucune autre classe ne peut y accéder ni en lecture ni en écriture. Pour la manipuler on a défini deux méthodes publiques getNom et setNom. Notez bien : les méthodes setNom et setZipcode contrôlent la manière dont on peut modifier les variables nom et zipcode. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces public Dans certains cas on a besoins de rendre un élément (classe, interface, méthode ou variable) accessible à toutes les autres classes. Dans ce cas on doit déclarer cet élément avec le modificateur public. Protected Le modificateur de contrôle d’accès protected utilisé avec une méthode ou variable membre limite l’accès cette dernière aux deux groupes suivants : 1- les sous classes qui possèdent la méthode ou la variable membre. 2- les classes dans le même package Ces deux groupes sont distincts car on peut avoir une sous classe déclarée dans un package autre que celui de sa superclasse exemple : javax.swing.Japplet java.applet.Applet Ce genre de modificateur d’accès est utile lorsque vous voulez tirer profit de l’héritage sans toutefois déclarer une méthode/variable public. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Modificateur de contrôle d’accès et l’héritage Avant d’appliquer un modificateur de contrôle d’accès à une méthode redéfinie il faut considérer la règle suivante: En général vous ne pouvez pas redéfinir une méthode et lui assigné un modificateur de contrôle d’accès plus restrictif, ainsi : Les méthodes déclarées public dans la superclasse doivent être redéfinies public dans les sous-classes. Les méthodes déclarées protected dans la superclasse doivent être redéfinies soit protected soit public dans les sous-classes. Les méthodes déclarées sans modificateur de contrôle d’accès dans la superclasse peuvent être déclarées soit package soit protected soit public dans les sous-classes. Les méthodes private ne sont pas visibles donc ils ne sont pas héritées. Si vous essayer de réduire la visibilité d’une méthode vous aurez une erreur de compilation du type : " Cannot reduce the visibility of the inherited method " 22/11/2017 POO Java / Modificateurs, packages et interfaces

Résumé sur les modificateurs de contrôle d’eccès class c1 { public int A; protected int B; int C; private int D; } class c3 { ... class c5 { A B C D Accessible par c1 o o o o Accessible par c2 o o o - Accessible par c3 o o o - Accessible par c4 o o - - Accessible par c5 o - - - Package P1 Package P2 class c4 extends c1 { class c2 extends c1 { 22/11/2017 POO Java / Modificateurs, packages et interfaces

Le modificateur static On a déjà étudié ce modificateur dans les chapitre précédents, il sert à déclarer une variable ou une méthode de classe. Exemple: L’exemple suivant montre l’intérêt des modificateurs private protected et static. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces 22/11/2017 POO Java / Modificateurs, packages et interfaces

utilisation de static avec la redéfinition et la surcharge static et la redéfinition Une méthode de classe ne peut redéfinir une méthode d’instance Une méthode d’instance ne peut redéfinir une méthode de classe static et la surcharge : Une méthode de classe peut surcharger une méthode d’instance Une méthode d’instance peut surcharger une méthode de classe 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Le modificateur final Le modificateur final peut être utilisé avec une classe, méthode ou variable pour indiquer qu’elle ne peut pas changer. Ce modificateur a plusieurs significations selon l’élément qu’il modifie : Une classe final ne peut être sous classée Une méthode final ne peut être redéfinie Une variable(membre ou locale) final ne peut changer de valeur. Remarques: On ne peut pas déclarer une classe abstraite final. On ne peut pas déclarer une interface final. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces final Notez bien : Le modificateur final peut modifier, une classe, une méthode, une variable membre, un argument d’une méthode ou encore une variable locale. une variable membre déclarée final doit être initialisé lors de la déclaration. une variable locale déclarée final peut être initialisée après la déclaration. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces final Quand on utilise final avec des objets références plutôt qu'avec des types primitifs la signification devient un peu confuse. Avec un type primitif, final fait de la valeur une constante, mais avec un objet référence, final fait de la « référence » une constante. Une fois la référence liée à un objet, elle ne peut jamais changer pour pointer vers un autre objet. Quoiqu'il en soit, l'objet lui même peut être modifié ; Java ne fournit pas de moyen de rendre un objet arbitraire une constante. On peut quoiqu'il en soit écrire notre classe de manière que les objets paraissent constants. Cette restriction inclut les tableaux, qui sont également des objets. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Le modificateur abstract Dans la hiérarchie des classes, plus une classe est placée en haut plus il devient plus abstraite car elle factorise des éléments d’état et de comportement plus généraux. Parfois à force de la diversité de l’implémentation d’un comportement donné par les différentes sous classes candidates, le développeur se trouve devant une situation où l’intersection entre les différents comportements est réduit à l’ensemble vide. Dans ce cas, pour tirer profit des bénéfices du polymorphisme java fournit la notion de méthode abstraite. Définition : Une abstraite est déclarée suivant la syntaxe : abstract typeRetour nomMethode(type1 arg1, type2 arg2,…); Exemple: Une méthode abstraite est une méthode sans code (seulement sa signature). 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces abstract Le nom en italique définition Remarques Une méthode abstraite ne peut être final ni private. Une classe est automatiquement abstraite dès qu'une de ses méthodes est déclarée abstraite. Une classe abstraite est une classe qui ne peut pas être instanciée 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces abstract Une classe contenant des méthodes abstraites est appelée une classe abstraite. Si une classe contient une ou plusieurs méthodes abstraites, la classe doit être qualifiée comme abstract. (Autrement, le compilateur signale une erreur.) Si vous héritez d'une classe abstraite et que vous voulez fabriquer des objets du nouveau type, vous devez fournir des définitions de méthode correspondant à toutes les méthodes abstraites de la classe de base. Si vous ne le faites pas (cela peut être votre choix ), alors la classe dérivée est aussi abstraite et le compilateur vous forcera à qualifier cette classe avec le mot clé abstract. Remarque : Vous pouvez définir une classe abstraite qui ne contient aucune méthode abstraite. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Les interfaces

POO Java / Modificateurs, packages et interfaces Introduction Une interface est un protocole de communication entre objets. Le langage Java support les interfaces que vous utiliser pour définir un protocole de comportement qui peut être implémenté par toute classe dans la hiérarchie des classe. Une interface définit un ensemble de méthodes mais ne donne pas leurs implémentation. Chaque classe qui implémente cette interface accepte d’implémenter toutes les méthodes définies dans l’interface, par conséquent accepter un certain comportement. Définition: une interface est une collection « nommée » de définitions de méthodes (sans implémentations). Une interface peut aussi déclarer des constantes. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Différence entre Interface et Classe Abstraite Parce que une interface est simplement une liste de méthodes sans implémentation, cela génère une confusion avec les classes abstraites. Mais ces deux notions sont largement distincts: Une interface ne peut implémenter aucune méthode. Mais une classe abstraite le peut. Une classe peut implémenter plusieurs interfaces mais ne peut avoir plus qu’une seule superclasse. Une interface ne fait pas partie de l’hiérarchie des classes. Des classes qui n’ont aucune relation d’héritage peuvent implémenter la même interface. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Déclaration d’une interface Les constantes Les définitions de méthodes 22/11/2017 POO Java / Modificateurs, packages et interfaces

Déclaration d’une interface access interface nom extends SuperInterface1, SuperInterface2… { ret-type nom-method-1(liste-param); ret-type nom-method-2(liste-param); type var1 = valeur; type var2 = valeur; // ... ret-type nom-method-N(liste-param); type varN = valeur; } 22/11/2017 POO Java / Modificateurs, packages et interfaces

Héritage multiple entre interfaces 22/11/2017 POO Java / Modificateurs, packages et interfaces

Conflit lors de l’héritage multiple Parfois une classe implémente deux interfaces qui définissent la même méthode. Vous pouvez gérer ce conflit par trois manières : - Si les deux méthode ont la même signature. Vous implémentez une méthode dans votre classe et cette implémentation satisfait les deux interfaces - Si les deux méthode ont le même type de retour et deux listes d’arguments différentes, il s’agit d’un simple cas de surcharge. Vous implémenter les deux méthodes avec les deux signatures, chacune satisfait respectivement sa définition dans l’interface. - Si les deux méthode n’ont pas le même type de retour. Dans ce cas il faut revoir la conception de l’une des deux interfaces. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Déclaration d’une interface Access est public ou non utilisé pour « package ou freindly », lorsque access est absent donc la visibilité est celle par défaut et l’interface sera visible seulement dans le package en cours. Lorsque access est déclaré public l’interface peut être utiliser n’import où dans la hérarchie des classes, dans ce cas l’interface doit être déclaré dans un fichier portant son nom avec l’extension .Java Le nom représente le nom de l’interface est peut être tout identificateur valide. Les méthodes sont déclarées seulement avec leurs nom, type retourné et la liste des paramètres (signature) sans spécifier aucun accesseur, ce sont implicitement des méthodes abstraites et publiques. Aucune méthode ne doit être implémentée dans l’interface. Toutes les méthodes déclarées au sein d’une interface sont implicitement public abstract. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Déclaration d’une interface Par conséquent, toute classe implémentant une interface doit s’engager de fournir l’implémentation de toutes les méthodes déclarées dans cette interfaces ainsi que ceux-ci déclarées dans ses super-Interfaces. Les Variables déclarées dans une interface ne sont pas des variables d’instances, mais ils sont implicitement des variables static, public et final, et ils doivent êtres initialisées dans le corps de l’interface. Ce sont essentiellement des constantes. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Implémentation d’une interface Une fois une interface définit, il peut être implémentée par une ou plusieurs classes. Pour implémenter une interface il suffit d’ajouter le mot-clé implements dans la définition de la classe, et créer dans le corps de la classe l’implémentation de toutes les méthodes définit dans l’interface .La forme générale d’un eclasse implémentant une interface est la suivante : access class classname extends superclass implements interface1, interface2 …{ // class-body } Ici access est soit public soit non utilisé. La clause extends est optionnelle. pour implémenter plusieurs interfaces, séparer les par des vergules. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Implémentation d’une interface Les méthodes déclarées dans l’interfaces doivent être implémentées dans la classe et doivent impérativement être déclarées public. Aussi la signature et le type retourné des méthodes doit correspondre exactement au signature et type retourné déclaré dans la définition de l’interface. Par convention le mot clé extends (s’il existe) précède le mot clé implements. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Attention! Les Interfaces n’évoluent pas Supposons que vous voulez ajouter quelques fonctionnalités à l’interface I dans l’exemple précedent comme suit: 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces 22/11/2017 POO Java / Modificateurs, packages et interfaces

Attention! Les Interfaces n’évoluent pas Cependant tout changement effectuer sur l’interface va affecter toutes les classe qui l’implémentent. Ces classes n’implémentent plus cette interface. Pour résoudre ce problème essayer d’anticiper toutes les utilisations possibles de votre interface dès le départ. Or dans la plupart des cas cela est impossible, la seule solution qui reste c’est l’héritage. Dans l’exemple précedent vous pouvez créer SubI une sous interface de I et y ajouter la signature de la méthode comme suit: interface SubI extends I { int getSize(String s); } Ainsi les classes implémentant I sont intactes et les nouvelles classes peuvent choisir entre implémenter I ou SubI 22/11/2017 POO Java / Modificateurs, packages et interfaces

Exemple d’implémentation d’interface public interface Series { int getNext(); // return next number in series void reset(); // restart void setStart(int x); // set starting value } class SerieParDeux implements Series { int start; int val; SerieParDeux() { start = 0; val = 0;} public int getNext() { val += 2; return val; } public void reset() { start = 0; val = 0;} public void setStart(int x) { start = x; val = x; } } 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Exemple Notez bien que les méthodes getNext( ), reset( ), et setStart( ) sont déclarées avec le modificateur de contrôle d’acces public. C’est obligatoire. À chaque fois que vous implémentez une méthode définie dans une interface vous devez la déclarer public car tous les membres d’une interface sont implicitement public. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Exemple class SeriesDemo { public static void main(String args[]) { SerieParDeux ob = new SerieParDeux (); for(int i=0; i < 5; i++) System.out.println( " La valeur suivante est " + ob.getNext()); System.out.println("\nResetting"); ob.reset(); System.out.println(" La valeur suivante est " + ob.getNext()); System.out.println("\nStarting at 100"); ob.setStart(100); } } 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces class SerieParTrois implements Series { int start; int val; SerieParTrois() { start = 0; val = 0;} public int getNext() { val += 3; return val;} public void reset() { start = 0; val = 0;} public void setStart(int x) { start = x; val = x;} } 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Conversion implicite 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Notez bien: Si une classe implémente une interface mais n’implémente pas toutes les méthode définies dans cette interface, alors cette classe doit être déclarée abstraite. Par conséquent aucun objet ne peut être instancié de cette classe. Ce mécanisme donne la possibilité aux sous classes de donner l’implémentation complète de l’interface. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Transtypage (type référence) Pour les type référence, le type devient plus large lorsque vous naviguez vers le haut dans la hiérarchie. C’est une règle générique pour tout les trois type de références.(classe, interface, tableau) Plus large 22/11/2017 POO Java / Modificateurs, packages et interfaces

Transtypage : Type interface Un objet instance d’une classe peut être converti en un objet de type toute interface implémenté par sa classe. Ainsi : le code suivant est valide Series ob; SerieParDeux twoOb = new SerieParDeux(); ob = twoOb; SerieParTrois threeOb = new SerieParTrois(); ob = threeOb ; Un autre exemple : 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Type interface Un objet de type interface peut être converti en un type d’une autre interface, si cette dernière est une super interface de la première. Notez bien qu’une interface peut avoir plusieurs superinterface, par contre une classe ne peut avoir plus qu’une seule superclasse. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Transtypage : Type tableau Les tableaux sont aussi des objet, mais la conversion des références à des tableau est traitée différemment : Dans le cas d’un tableau de primitifs, il peut être converti seulement en type java.lang.Object aux interfaces Serializable et Cloneable ou à un tableau de primitifs du même type. int[] intArray = new int[5]; java.io.Serializable aSerializableObj = intArray;     //Valide Cloneable aCloneableObj = intArray;                   //Valide Object anObject = intArray;                           //Valide Notez bien que les règle de conversion des type primitifs ne sont pas applicable dans le cas des tableaux par exemple l’instruction : long[] longArray = intArray;   // génère une erreur! 22/11/2017 POO Java / Modificateurs, packages et interfaces

Transtypage : Type tableau Dans le cas d’un tableau d’objets, il peut être converti en un autre tableau d’objets si le 1er type d’objet est convertible au 2ième. Exemple : class A{} class B extends A{} A[] a=new A[5] ; B[] b=new B[9]; a=b; // valide tableau d’objets être converti en un objet de type java.lang.Object aux interfaces Serializable et Cloneable. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Transtypage Explicite (type référence) Vous pouvez transtyper un objet plus petit vers un objet de type plus large moyennant un opérateur de transtypage explicite. Java effectue de sorte de vérification lors du transtypage explicite pour les type références. 1- une vérification lors de la compilation 2- une vérification au cours de l’exécution 22/11/2017 POO Java / Modificateurs, packages et interfaces

Transtypage explicite (type référence) Vérification lors de la compilation pour le transtypage explicite : 1- vous pouvez transtyper un type-classe vers un autre type-classe si l’un des deux et une superclasse de l’autre. 2- vous pouvez toujours transtyper un type-interface vers tout type-classe non final. Exemple: Date date = new Date(); Auditable auditable = (Auditable) date; // ou n’importe quelle interface 3- Vous ne pouvez jamais convertir un tableau de type primitif vers un tableau d’un autre type primitif. 4- vous pouvez transtyper un tableau de type référence vers un tableau d’un autre type référence si leurs éléments acceptent le transtypage. RQ: le compilateur permet le transtypage dans la règle 2, par anticipation que peut être une sous classe du type-classe Date implémentera l’interface Auditable. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Transtypage explicite (type référence) Vérification à l’exécution pour le transtypage explicite : À l’exécution java effectue une vérification plus stricte. Ce genre de vérification est justifié puisque java ne peut pas décider du type d’un objet que lors de l’exécution (voir l’exemple dans le chapitre 4). La règle de la vérification à l’exécution est simple : A a; B b; b=(B) a; // valide si l’objet référencé par a accepte la conversion implicite vers le type B. Voir l’exemple suivant : 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces 22/11/2017 POO Java / Modificateurs, packages et interfaces

Résumé sur les Interfaces Une interface définit un protocole de communication entre objets. La définition d’une interface se compose d’une déclaration et d’un corps. Le diapos N° 24 montre tous les composantes possibles de la déclaration d’une interface. Le corps d’une interface contient les déclarations, sans implémentation, d’un ensemble de méthodes. Une interface peut aussi comprendre des définitions de constantes. Une classe qui implémente une interface doit impérativement implémenter toutes les méthodes déclarées dans cette interface sinon il faut la déclarer abstract. Une variable de type interface peut être utilisée n’import où une classe implémentant cette interface est attendue. Toutes les méthodes déclarées au sein d’une interfaces sont public par défaut et non « friendly ou package ». Une interface ne peut être déclarée private ou protected (une classe aussi). 22/11/2017 POO Java / Modificateurs, packages et interfaces

Les packages

POO Java / Modificateurs, packages et interfaces Introduction Définition Un package est un groupe de classes associées à une fonctionnalité ou qui coopèrent. L’utilisation des packages permet d’organiser un groupe de classes qui réalisent une fonctionnalité donnée sous un nom. Exemples : org.apache.myfaces, javax.faces , com.sun.faces.util, java.awt.images … Les packages offrent plusieurs avantages : 1- ils facilitent l’organisation des classes. Juste comme les répértoires facilitent l’organisation des fichiers.(la recherche d’une classe devient plus facile : exemple ma.ensam.nomprjet.backoffice et ma.ensam.nomprjet.frontoffice 2- Ils offrent un mécanisme supplémentaire de protection de classes, méthodes et attributs(le modificateur de contrôle d’accès par défaut) 3- ils résolvent les problèmes de conflit de nom exemple : java.util.Date et java.sql.Date 4- ils permettent d’identifier votre travail d’une manière unique. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Utilisation des package Pour définir le package auquel est attaché une classe vous utiliser l’instruction: package nompackage; Exemple: package ma.ensam.td; class Test {} Si l’instruction de déclaration du package est présente elle doit être la première instruction du fichier sinon vous aurez une erreur de compilation. Si vous n’avez pas défini un package pour les classes de votre fichier, ces classes seront associé au package par défaut (sans nom et correspond au répertoire courant). Lorsque vous compilez le fichier Test.java, la classe Test.class sera rangée dans le repertoire c:\javawork\ma\ensam\td\Test.class 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces import Pour pouvoir utiliser une classe définie dans un autre package vous devez l’ importer ( c-à-d indiquer sans chemin au compilateur) moyennant l’instruction : Import nompackage.nomsouspackage.NomClasse; Exemple : package ma.ensam; Import java.util.*; import org.apache.tomcat.*; import com.sun.faces.util.Timer; Public class Compte{…} Remarque : Le compilateur cherche les packages dans tous les dossier et fichier .jar inclus dans la variable d’environnement classpath. L’IDE Eclipse facilite la gestion des packages : les répertoires src et bin remplacent respectivement les variables sourcepath et classpath. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces import import ma.ensam.cours.C; Si vous utiliser la ligne de commande C:\javac Si par exemple votre variable classpath=c; c:\javawork; d:\lib; Alors la classe C est cherchée dans C:\ma.ensam.cours.C.class Puis dans c:\javawork\ ma.ensam.cours.C.class Puis dans d:\lib\ ma.ensam.cours.C.class La première classe rencontrée sera importé (si par exemple C.class se trouve à deux chemins différents. 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Attention Le nom du package fait partie du nom de la classe. Si vous essayez de copier une classe d’un répertoire qui représente un package donné(ou bien du package par défaut) vers un autre cela ne signifie pas que cette classe appartient à ce nouveau package. Exemple On définit la classe : public class A{} dans le fichier C:\javawork\A.java C:\javawork\javac A.java On obtient C:\javawork\A.class On copie le fichier dans le répertoir C:\javawork\ma.ensam\A.class L’instruction : import ma.ensam.A; va générer une erreur de compilation car la classe A n’appartient pas au package ma.ensam. 22/11/2017 POO Java / Modificateurs, packages et interfaces

Accès à une classe d’un package Pour pouvoir utiliser une classe issue d’un autre package il faut signifier son origine au compilateur, il y’a trois manière de faire cela: en important la classe en important tout le package où est définie la classe en indiquant le nom complet de la classe (Fully Qualified Name). 22/11/2017 POO Java / Modificateurs, packages et interfaces

Accès à une classe d’un package L’instruction import nomPackage.*; ne concerne que les classes du package indiqué. Elle ne s’applique pas aux classes des sous packages Pas besoin d’import les classes du package java.lang 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Import static Jusqu'à la version 1.4 de Java, pour utiliser un membre statique d'une classe, il faut obligatoirement préfixer ce membre par le nom de la classe qui le contient Java 1.5 propose une solution pour réduire le code à écrire concernant les membres statiques en proposant une nouvelle fonctionnalité concernant l'importation de package : l'import statique (static import). 22/11/2017 POO Java / Modificateurs, packages et interfaces

POO Java / Modificateurs, packages et interfaces Conclusion 22/11/2017 POO Java / Modificateurs, packages et interfaces