PROGRAMMATION ORIENTE OBJET

Chapitre 3 –Les Concepts Orientés Objets en

Java

I. Notion de classe en Java

1. Concept
 Une classe est le support de l'encapsulation : c'est un ensemble de données et de
fonctions regroupées dans une même entité.
 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.
 Java est un langage orienté objet : tout appartient à une classe sauf les variables de type
primitives.
 Pour accéder à une classe il faut en déclarer une instance de classe ou objet.
 Une classe comporte sa déclaration, des variables et la définition de ses méthodes.
 Une classe se compose en deux parties : un en-tête et un corps. Le corps peut être divisé
en 2 sections : la déclaration des données et des constantes et la définition des méthodes.
 Les méthodes et les données sont pourvues d'attributs de visibilité qui gère leur
accessibilité par les composants hors de la classe.
2. Déclaration d’une classe

Une classe se déclare de la manière suivante :

<Modificateur d'accès> class <Nom de la classe>

{
/* instructions permettant de définir les attributs de la classe*/
/* instructions permettant de définir les attributs de la classe*/
}

Ce qui donne dans notre exemple :

public class Compteur {

/* Définition des propriétés et des méthodes 1

}
PROGRAMMATION ORIENTE OBJET

Ensuite, tout ce qui est contenu entre les accolades fait partie de la classe.
L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre
d'abord la méthode A puis la méthode B, B peut être appelée sans problème dans A.
Les modificateurs de classe (Class Modifiers) sont :

Modificateur Rôle

public La classe est accessible partout

Private la classe n'est accessible qu'à partir du fichier où elle est définie

Final La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est
interdite. Les classes déclarées final ne peuvent donc pas avoir de classes
filles.

Abstract la classe contient une ou des méthodes abstraites, qui n'ont pas de définition
explicite. Une classe déclarée abstract ne peut pas être instanciée : il faut
définir une classe qui hérite de cette classe et qui implémente les méthodes
nécessaires pour ne plus être abstraite.

Les modificateurs abstract et final ainsi que public et private sont mutuellement exclusifs.
Remarque : Conventions de nommage en Java

Par convention, en Java les noms de classes commencent par une lettre majuscule,
si elle est composée de plusieurs mots, ces mots doivent être liés par « _ » et commencent par
une lettre majuscule.

II. Attributs et méthodes

1. 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 attributs définissent l’état d’un objet.

Déclaration

[< modificateur de visibilité>] <type> <nom_attribut> [=<expression>] ;

2
PROGRAMMATION ORIENTE OBJET

Ce qui donne dans notre exemple :

int position ;
protected float salaire = 1000 ;

a. Les modificateurs

Modificateur Rôle

public Un attribut déclaré public est visible par toutes les autres classes.

Dans la philosophie orientée objet aucune donnée d'une classe ne devrait être
déclarée publique : il est préférable d'écrire des méthodes pour la consulter
et la modifier

par défaut : Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut
lorsqu'aucun modificateur n'est précisé. Cette déclaration permet à un
friendly
attribut d'être visible par toutes les classes se trouvant dans le même
package

protected Si un attribut est déclaré protected, seules les méthodes présentes dans le
même package que cette classe ou ses sous classes pourront y accéder.

private C'est le niveau de protection le plus fort. Les composants ne sont visibles
qu'à l'intérieur de la classe :ils ne peuvent être modifiés que par des
méthodes définies dans la classe prévue à cet effet.

b. Les variables d'instances

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.
Exemple : class Compteur {

int position ;
}

Pour chaque instance de la classe Compteur l’attribut position sa valeur propre à l’instance

3
PROGRAMMATION ORIENTE OBJET

c. Les variables de classes

Dans certains cas, il est plus judicieux d’attacher une variable à une classe plutôt qu’aux
objets instanciant cette classe. Cette variable étant commune à tous les objets de la même
classe, elle n’est pas dupliquée dans tous ces objets. Tous les objets crées de la classe partage
cette même variable avec la même valeur.
Pour qu'une variable déclarée dans la classe soit considérée comme une variable de classe,
il faut placer le mot clef static dans sa déclaration :
Exemple

class Compteur {

static int pas = 2 ;

int position ;
}

Dans cet exemple l’attribut pas = 2 est fixé pour toutes les instances de Compteur.
L’attribut position est propre à chaque instance.
Les propriétés et des méthodes statiques sont directement associées à la classe et non aux
instances de la classe :

d. Les constantes
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.
Exemple
class Compteur {

final float pi = 3 ,14;

int position ;
}

2. Méthodes
Chaque classe possède un ensemble de méthodes qui représentent ce que l'objet sera capable
de faire (son comportement). Les méthodes sont en fait, des blocs de code, réalisant un certain
nombre d'opérations sur les différentes ressources d'une classe. Une méthode peut prendre des
arguments mais aussi renvoyer des données à l'objet appelant.

4
PROGRAMMATION ORIENTE OBJET

On distingue deux types de méthodes :

- Les accesseurs, permet de consulter la valeur d’un champ ;
- les modificateurs, qui modifient l’état en effectuant un calcul spécifique.

Déclaration
Une déclaration de méthode est de la forme suivante :

[<Modificateurs>] Type nomMéthode( paramètres ...)

/* corps de la méthode*/
}

Les méthodes sont définies par :

 Un nom constitué par un identificateur : Le nom de la méthode débute par une
minuscule ; la coutume veut qu’un accesseur débute par le mot « get » et qu’un
modificateur débute par le mot « set ».
 Des paramètres formels : ceux-ci sont séparés par des ``,''.
 Le type et le nombre d'arguments déclarés doivent correspondre au type et au nombre
d'arguments transmis.
 Du type du retour est soit void (si la méthode ne retourne aucune valeur), soit un type
primitif ou une référence vers un objet.
 du corps de la méthode.
 La valeur de retour de la méthode doit être transmise par l'instruction return. Elle
indique la valeur que prend la méthode et termine celle-ci : toutes les instructions qui
suivent return sont donc ignorées.

Exemple

/* Setters – Modificateurs : Méthodes qui modifient l’objet. */

void init(int initPos, int s) {

position = initPos ; pas = s ;
}
void compter() { position += pas ; }
/* getters – accesseurs : Méthodes permettant de consulter l’état de

l’objet. */

int getPosition() { return position ; }

5
PROGRAMMATION ORIENTE OBJET

a. Les modificateurs

Modificateur Rôle

public La méthode est accessible aux méthodes des autres classes.

private L’usage de la méthode est réservé aux autres méthodes de la même classe.

protected La méthode ne peut être invoquée que par des méthodes de la classe ou de
ses sous classes.

final La méthode ne peut être modifiée (redéfinition lors de l'héritage interdite).

static La méthode appartient simultanément à tous les objets de la classe. Il est

inutile d'instancier la classe pour appeler la méthode mais la méthode ne
peut pas manipuler de variable d'instance. Elle ne peut utiliser que des
variables de classes.

Sans La méthode peut être appelée par toutes autres méthodes des classes du
modificateur package auquel appartient la classe.

Exemple : Les propriétés et méthodes statiques

class Compteur {

static int pas ;

int position ;

Compteur(int position) {
this.position = position ; }
static void setPas(int pas) {

Compteur.pas = pas ; }

void compter() { position += pas ; }

6
PROGRAMMATION ORIENTE OBJET

b. Passage de paramètres aux méthodes :

Lors des appels aux méthodes, tous les paramètres sont passés par valeur. Le
concept de passage par adresse n'existe pas. Rappelons que les seuls types possibles de
paramètres sont les types primitifs et les références. Autrement dit :

 les types primitifs (les entiers, les booléens et les flottants) sont passées toujours par
valeur. C'est la valeur du paramètre (la copie d'une constante ou du contenu d'une
variable) qui est passée en paramètre à la méthode invoquée. Une méthode ne peut
donc jamais modifier la valeur d'une variable de type primitif du code appelant.
 les références également sont passées par valeur. Ce qui est passé ici en paramètre,
c'est la valeur de la référence et jamais l'objet lui-même. Une méthode peut donc
modifier cette copie de la valeur de la référence sans que cela modifie la valeur de la
référence du code appelant. Par contre, si la méthode modifie un champ de l'objet
référencé par cette valeur, c'est l'objet (qui lui n'est peut-être passé par valeur) qui est
modifié pour tout référence vers cet objet. Le code appelant se voit donc l'objet référencé
modifié.

c. Méthode constructeur
Chaque classe doit définir une ou plusieurs méthodes particulières appelées des
constructeurs. Un constructeur est une méthode invoquée lors de la création d’un objet.
Cette méthode, qui peut être vide, effectue les opérations nécessaires à l’initialisation d’un
objet. Chaque constructeur doit avoir le même nom que la classe où il est défini et n’a aucune
valeur de retour (c’est l’objet créé qui est renvoyé).
La définition d'un constructeur est facultative. Si elle n'est pas définie, la machine
virtuelle appelle un constructeur par défaut vide créé automatiquement. Dès qu'un constructeur
est explicitement défini, Java considère que le programmeur prenne en charge la création des
constructeurs et que le mécanisme par défaut, qui correspond à un constructeur sans paramètres,
est supprimé. Si on souhaite maintenir ce mécanisme, il faut définir explicitement un
constructeur sans paramètres.

Il existe plusieurs manières de définir un constructeur :

● Le constructeur simple : ce type de constructeur ne nécessite pas de définition explicite:

son existence découle automatiquement de la définition de la classe.

7
PROGRAMMATION ORIENTE OBJET

Exemple :

public class Compteur {

public class Compteur {
int position, pas ;
int position = 10, pas
public Compteur() {
= 1;
} position = 10 ; pas = 1 ;
}

● Le constructeur avec initialisation fixe : il permet de créer un constructeur par défaut

Exemple :
public class Compteur {

int position, pas ;

public Compteur() {

position = 10 ; pas = 1 ;
}

● Le constructeur avec initialisation des variables : pour spécifier les valeurs de données
à initialiser on peut les passer en paramètres au constructeur
Exemple :

public class Compteur {

int position, pas ;

public Compteur(int p, int pas) {

position = p ;
this.pas = pas ;
}

d. La méthode main()
Lorsqu’on invoque la machine virtuelle pour l’exécution d’un programme, celle ci part à
la recherche d'un sous-programme particulier appelé main de la classe principale pour
l’exécuter en premiers.

public class Test {

public static void main(String arg[]) {

Compteur cmp1 = new Compteur();
Compteur cmp2 = cmp1 ; 8
}
PROGRAMMATION ORIENTE OBJET

Le nom de l’argument args peut être quelconque c’est un tableau de chaines de

caractères représentant les arguments de la ligne de commande.

e. Les destructeurs
En JAVA, lorsqu’un objet ne sert plus à rien, il n’est pas nécessaire de l’effacer de la
mémoire. En effet, un outil très efficace nommé le garbage collector s’occupe de vérifier
l’utilité de garder en vie les objets et les supprime le cas échéant. La conséquence directe est
que le développeur ne se soucie plus de cet aspect tant redouté par les programmeurs C++ qu’est
la destruction des objets.

Compteur c = new Compteur(); ...; c = null ;

// La mémoire utilisée pour l'objet peut être libérée

// Le Garbage collector peut supprimer les objets devenus
innaccessibles :

III. Objet et instanciation en java

1. Instanciation
Un objet est une instance d’une classe et est référencé par une variable ayant un état
(l’ensemble des valeurs de ses attributs à un instant donné). Pour créer un objet, il est nécessaire
de déclarer une variable dont le type est la classe à instancier, puis de faire appel à un
constructeur de cette classe. Pour chaque instance d'une classe, le code est le même, seules
les données sont différentes à chaque objet.
Un objet se caractérise par :
 Un état : Caractérise l'état dans lequel est l'objet (Le moteur de la voiture est-il
démarré ? La voiture est-elle à l'arrêt ?
 Un comportement : Caractérise ce que l'objet est capable de faire
 Une identité unique : Précise son caractère unique. Un objet possède une identité
propre,ce qui permet de le distinguer parmi les autres (Comme les humains).
Syntaxe

Classe nom_Objet = new Classe() ; // nom_Objet est une référence

9
PROGRAMMATION ORIENTE OBJET

Exemple

Compteur cmp1 = new Compteur();

A l’exécution, la machine virtuelle va donc stocker cet objet quelque part dans la
mémoire puis créer a une référence pointant sur cet objet :

Figure 5: Référencement d'un objet

L’opération suivante aura pour effet de créer une nouvelle référence mais pas un nouvel
objet :
Compteur cmp2 = cmp1;

Le schéma précédent devient alors :

Figure 6:deux références pour un même objet

L'opérateur new est un opérateur de haute priorité qui permet d'instancier des objets et
d'appeler une méthode particulière de cet objet : le constructeur. Il fait appel à la machine
virtuelle pour obtenir l'espace mémoire nécessaire à la représentation de l'objet puis appelle le
constructeur pour initialiser l'objet dans l'emplacement obtenu. Il renvoie une valeur qui

10
PROGRAMMATION ORIENTE OBJET

référence l'objet instancié. Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire, il
lève l'exception OutOfMemoryError.
Exemples

Compteur c1 = new Compteur(2,10);

Compteur c2 = new Compteur();

Remarque : un objet String est automatiquement créé lors de l'utilisation d'une constante
chaîne de caractères sauf si celle-ci est déjà utilisée dans la classe. Ceci permet une
simplification lors de la compilation de la classe.
Exemple

public class TestChaines {

public static void main(String[] args) {
String chaine1 = "bonjour";
String chaine2 = new String("bonjour");
System.out.println("(chaine1 == chaine2) = " +
(chaine1 == chaine2) );
}
}

2. L'objet null
L'objet null est utilisable partout. Il n'appartient pas à une classe mais il peut être utilisé
à la place d'un objet de n'importe quelle classe 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'initialiser une variable référant un objet à null permet
au Garbage collector de libérer la mémoire allouée à l'objet.

3. Accès aux attributs et méthodes

a. Accès aux attributs et méthodes d’instance
Pour accéder à un attribut associée à un objet, il faut préciser la référence vers l’objet qui
la contient suivi du symbole ’.’ (qui sert à séparer l’identificateur de l’objet de l’identificateur
de la variable) suivi du nom de l’attribut.

11
PROGRAMMATION ORIENTE OBJET

Exemple

Compteur Compteur1 = new Compteur();

Compteur Compteur2 = new Compteur();

Compteur1.position = 10 ;

Compteur2.position=20;

if (Compteur1.position !=Compteur2.position)

System.out.println("différent");
La même syntaxe est utilisée pour appeler une méthode d’un objet.

Par Exemple : On invoque les méthodes avec l’opérateur “.” (point) :

class Compteur { Compteur cmp = new Compteur();

int position, pas ; cmp.init(4, 8+12);
void init(int initPos, int s) { cmp.compter();
position = initPos ; pas = s ; cmp.compter();
} System.out.println(cmp.position);
void compter() { position += pas ; }
}

Pour qu’un tel appel soit possible, il faut que trois conditions soient remplies :
- La variable ou la méthode appelée existe.
- Une variable désignant l’objet visé existe et soit instanciée.
- L’objet, au sein duquel est fait cet appel, ait le droit d’accéder à la méthode
ou à la variable.

b. Le mot clé « this »

Pour référencer l’objet “courant” (celui dans lequel se situe la ligne de code), le langage
Java fournit le mot-clé this. Celui-ci n’a pas besoin d’être instancié et s’utilise comme une
variabledésignant l’objet courant. Le mot-clé this est également utilisé pour faire appel à un
constructeurde l’objet courant. Ces deux utilisations possibles de this sont illustrées dans
l’exemple suivant :

12
PROGRAMMATION ORIENTE OBJET
class Compteur { class Compteur {

int position, pas ; int position, pas ;

Compteur(int position, int pas) { Compteur(int position, int pas) {

this.position = position ; this.position = position ;

this.pas = pas ; this.pas = pas ;
} }
void compter() { Compteur(int position) {

int position = this.position ; /* mot-clé this permet également

position += pas ; d’appeler un constructeur*/
this.position = position ; this(position, 1);
} }
} }

c. Accès aux attributs et méthodes de classe

Les attributs statiques sont des attributs marqués par le mot clé « static », ils désignent
les attributs communs entre tous les objets.
On accède à un attribut statique via :
- Une instance quelconque de la classe.
- Le nom de la classe directement.

Si on souhaite sauvegarder le nombre des objets crées et attribuer à chaque objet son
numéro d’ordre. Pour satisfaire à cet objectif, on a certainement besoin d’un attribut de type
statique qui est commun à tous les objets et qui sauvegarde le nombre d’objets déjà crées.

Exemple
class Compteur {

static int pas;

int position ;
Compteur(int position) {

this.position = position ;
}
static void setPas(int pas) {

Compteur.pas= pas ;
}
void compter() {
13
position += pas ; }

}
PROGRAMMATION ORIENTE OBJET

Les méthodes de classe, désignent les méthodes dont les actions concernent la classe
entière et non pas un objet particulier. De même, l’accès à ces méthodes ne nécessite pas la
création d’un objet de la classe, car on peut appeler directement la méthode à travers le nom
de la classe. On peut utiliser aussi ces méthodes statiques pour manipuler des données statiques.
L’accès à cette méthode peut se faire de deux façons :
 Nom_classe.nom_méthode(paramètres).
 Nom_objet.nom_méthode(paramètres).

Comme les propriétés et méthodes statiques sont associées à la classe, il n’est pas nécessaire de
posséder une instance pour les utiliser :

public class Test {

public static void main(String[] arg) {

Compteur.setPas(3);
Compteur Compteur1 = new Compteur(2);
Compteur Compteur2 = new Compteur(3);
Compteur1.compter();
Compteur2.compter();
System.out.println(Compteur1.position);
System.out.println(Compteur2.position);
Compteur.setPas(4);
Compteur1.compter();

Compteur2.compter();

System.out.println(Compteur1.position);

System.out.println(Compteur2.position);
}

4. Clonage d’un objet

On peut créer une copie d’un objet à travers la méthode clone (). Cette méthode permet
de créer un deuxième objet indépendant mais identique à l’original. Cette méthode est héritée
de la classe Object qui est la classe mère de toutes les classes en Java.
Exemple

Day b = new Day (1959, 6, 16);

Day d = b;
d.advance (100); // modifie d ET b
Ici, d et b référencent la même instance (le même objet)
Day d = (Day) b.clone ( ); // clone retourne un objet de classe Object
=> conversion explicite 14
d.advance (100); // b reste inchangé
PROGRAMMATION ORIENTE OBJET

IV. Les classes internes

Une classe Java peut contenir, outre des primitives, des objets (du moins leurs
références) et des définitions de méthodes, des définitions de classe. Nous allons maintenant
nous intéresser de plus près à cette possibilité.
L’intérêt d’avoir une telle classe interne réside dans la modularité que cela apporte : le nom de
la classe interne est purement local et cette classe peut même être rendue invisible depuis
l’extérieur de la classe englobante si on la déclare avec l’attribut private.
À l’extérieur de la classe englobante, on peut citer une classe interne (non privée) sous la forme
: classe englobante.classe interne

Exemple :

Class Animal {

boolean vivant ;

int âge ;

Coordonnées position ;

// classe imbriquée

Class Coordonnées {

int x = 0;

int y = 0;

...}

Animal() {

position = new Coordonnées() ;}

...}

- Les classes internes sont visibles uniquement par les méthodes de la classe dans laquelle
sont définies.

15
PROGRAMMATION ORIENTE OBJET

- Elles ont accès à tous les éléments de la classe qui les englobe (même privé).
- On ne peut pas accéder directement aux attributs et aux méthodes de la classe interne.
Toutefois, on peut les appeler indirectement à travers la classe externe qui l’englobe.
- Une classe interne statique ne peut accéder qu’aux membres statiques de la classe
externe.

V. Les Packages
1. Création :

En java, il existe un moyen de regrouper des classe voisines ou qui couvrent un même
domaine : ce sont les packages. Un package peut être considéré comme une bibliothèque des
classes : il permet de regrouper un certain nombre des classes relativement liées. Les packages
peuvent être organisés d’une manière hiérarchique en sous-packages et ainsi de suite. Les
classes d’un même paquetage sont dispersées dans plusieurs fichiers sources dont la première
ligne est :

Package nom-de-paquetage

Exemple

------------- Fichier Exemple.java ----------

Package gestion_examen; // 1ere

instruction

class Note {…}

class Etudiant {…}

public class Matiere {// blabla suite du code

...}

------------- Fin du Fichier ----------------

Ainsi par cette opération nous venons d'assigner toutes les classes du fichier Exemple.java
au paquetage gestion_examen. Si l'instruction package était absente du fichier, alors c'est
le paquetage par défaut qui est pris en considération. Ainsi toutes les classes du fichier vont
appartenir au paquetage par défaut.
Après la création du package il faut enregistrer le fichier dans un répertoire portant le même
nom que le package ensuite il faut ajouter le chemin du package dans la variables
d’environnement classpath.

16
PROGRAMMATION ORIENTE OBJET

Un paquet (package) :
▶ est une collection de classes
▶ peut contenir des sous-paquets

2. Utilisation:
Si on instancie un objet d'une classe donnée, le compilateur va chercher cette classe dans le
fichier où elle a été appelée, nous dirons que cette recherche a eu lieu dans le paquetage par
défaut même si ce dernier porte un nom. Si notre appel fait référence à une classe appartenant
à un autre paquetage, on doit aider le compilateur à retrouver le chemin d'accès vers cette classe
en procédant comme suit:
A. En mentionnant le chemin complet d'accès à la classe : En citant les noms complets des
paquetages nécessaires:
Exemple

Gestion_examen.Etudiant etd1 = new gestion_examen.Etudiant ();

 C’est une opération fastidieuse si on a affaire à une arborescence de paquetages ou bien

à un nombre important de classes dans un même paquetage. Source d'erreurs donc.
B. En important les paquetages utiles : Vous devez utiliser pour cela l'instruction import
comme suit:
import nom-de-paquetage.nom-de-classe

Ou

import nom-de-paquetage.*

Exemple

------------- Fichier Test.java ------------

import gestion_examen.Etudiant;

public class Test {

// code qq ...

Etudiant etd1 = new Etudiant ();

// code qq .... 17

----------------Fin Fichier-----------------
PROGRAMMATION ORIENTE OBJET

Remarques
- Le paquetage java.lang est importé automatiquement par le compilateur.
- Import gestion_examen.*; Cette instruction ne va pas importer de manière récursive
les classes se trouvant dans gestion_examen et dans ses sous paquetages. Elle va
uniquement se contenter de faire un balayage d'un seul niveau. Elle va importer donc
que les classes du paquetage gestion_examen.
Exemple

Import java.awt.*;
Import java.awt.event.*;

La première instruction importe toutes les classes se trouvant dans le paquetage

awt. Elle ne va pas importer par exemple les classes se trouvant dans le sous
paquetage event. Si on a besoin d’utiliser les classes de event, on doit les importer
aussi.
- Si deux paquetages contiennent le même nom de classe il y a problème! Par
exemple la classe Date des paquetagesjava.util et java.sql etc. Pour corriger ce
problème on doit impérativement spécifier le nom exact du paquetage à importer (ou
à utiliser).
java.util.Date

(ou)

java.sql.Date

Exemple

import java.util.Date;
public class DateMain {
public static void main(String[] args) {
Date today = new Date();
System.out.println(”Nous␣sommes␣le␣” + today.toString());
}
}

Java utilise l’arborescence de fichier pour retrouver les fichiers .class :

▶ Une classe (ou une interface) correspond à un fichier .class
▶ Un dossier correspond à un paquet
18
PROGRAMMATION ORIENTE OBJET

Les .class du paquet java.util doivent :

▶ être dans le sous-dossier java/util
▶ le dossier java doit être dans un des dossiers du ClassPath
Le ClassPath inclut :
▶ le répertoire courant ;
▶ les dossiers de la variable d’environnement CLASSPATH ;
▶ des archives JAR
▶ des dossiers précisés sur le ligne de commande de java ;

Utilisation d’une classe à partir d’un autre paquet

Dans un package l’accès aux classes dépond du modificateur qui les précède. Ces
modificateurs sont :
 Public : l’accès est possible partout.
 Sans modificateurs : accès possible depuis les classes du même paquetage
uniquement.
Accessibilité :
▶ Seules les classes publiques sont utilisable à partir d’un autre paquet
▶ Un fichier ne peut contenir qu’une seule classe publique
On peut désigner une classe qui se trouve dans un autre paquet :

package com.my_project ; package com.my_project ;

public class Main { import com.univ_amu.MyClass ;
public static void main(String[] args) { public class Main {
com.univ_amu.MyClass myClass = public static void main(String[] args) {
new com.univ_amu.MyClass(); MyClass myClass = new MyClass();
} }
} }

Nommage des paquets :

▶ Les noms de paquets sont écrits en minuscules

19
PROGRAMMATION ORIENTE OBJET

Quelques packages prédéfinis les plus utilisés

java.applet Classes de base pour les applets

java.awt Classes d'interface graphique AWT

java.io Classes d entrées/sorties

java.lang Classes de support du langage

java.math Classes permettant la gestion de grands

nombres.

java.net Classes de support réseau (URL, sockets)

java.rmi Classes pour les méthodes invoquées à partir

de machines virtuelles non locales

java.security Classes et interfaces pour la gestion de la

sécurité.

java.sql Classes pour l'utilisation de JDBC.

java.text Classes pour la manipulation de textes, de

dates et de nombres dans plusieurs langages

java.util Classes d utilitaires (vecteurs, hashtable)

javax.swing Classes d interface graphique

3. Avantages
- Facilite le développement des bibliothèques et des modules autonomes.
- Les classes d’un même package travaillent conjointement sur un même domaine.
- Facilite la réutilisabilité.

20