Chapitre 1

Classes et Objets en Java

 Historique
• Java est développé par James Gosling et
Patrick Naughton, deux développeur chez
SUN. L’idées était d’améliorer le langage C++:
• Java a été d’abord surnommé C++ -- (C++ sans
ses défauts) puis OAK
• Finalement, en 1991 est né le langage Java
Programmation Orientée Objet (POO)
Le concept de base de la programmation orientée objet
est de regrouper dans une même entité appelée objet les
données et les traitements sur ces données. La POO
présente plusieurs avantages :
• Encapsulation : Les données sont cachées; on leur
accède à travers des messages appelés méthodes. Java
dispose de plusieurs niveaux d’encapsulation : privée,
paquetage, protégé , publique.
• Héritage : une application en java peut être réutilisée
• Polymorphisme : un même traitement peut retourner
différente message suivant la nature de l objet
Classes et Objets
 Objet
• Un objet est caractérisé par
– une adresse en mémoire (identifie l’objet)
– un comportement
– un état interne
• L’état interne est donné par les valeurs des
données de l’objet
• Le comportement est donné par des fonctions
ou procédures, appelées méthodes.
 Les Classe
• Une classe est un modèle de définition pour des
objets décrivant le même ensemble de
données, et ayant le même ensemble
d’opérations.
• Une classe est la description de données
appelées Variables d’instances (Attributs ou
champs ), et d’opérations appelées méthodes
• A partir d’une classe on peut créer un ou
plusieurs objets par instanciation ; chaque objet
est une instance ou occurrence d’une seule
classe.
 Eléments d’une classe
• Les variables d’instances, on les appelle aussi
champs ou attributs: décrivent les données
des objets
• Les constructeurs: Permettent de créer
(instancier) un objet.
• Les méthodes décrivent le comportement de
l’objet à la réception du message.
• D’autre éléments qu’on va aborder dans la
suite du cours…
 Exemple d’une classe
public class Livre {
//Variables d’instances (attributs ou champs)
private String titre, auteur;
private int nbPages;
// Constructeur
public Livre(String unTitre, String unAuteur) {
titre = unTitre;
auteur = unAuteur;}
//Méthodes
public String getAuteur() { // accesseur
return auteur;
}
public void setNbPages(int nb) { // modificateur
nbPages = nb;
}
}
 Rôles d’une classe
• Une classe est
– un type qui décrit une structure (variables
d’instances) et un comportement (méthodes)
– un module pour décomposer une application en
entités plus petites
– un générateur d’objets (par ses constructeurs)
• Une classe permet d’encapsuler les objets : les
membres public sont vus de l’extérieur mais
les membres private sont cachés …
 Conventions de nommage
• Le nom d’une classe commencent par une
majuscule : Cercle, Object, Livres
• Le nom d’un identificateur commence par une
minuscule
• Les mots contenus dans un identificateur
commencent par une majuscule : UneClasse,
uneMethode, dateDeNaissance
• Les constantes sont en majuscules avec les mots
séparés par le caractère souligné « _ » : MAX,
CONSTANTE_PLANK,
 Les constructeurs d’une classe
• Une classe a un ou plusieurs constructeurs qui
servent à créer et initialiser les instances
• Un constructeur a le même nom que la classe
et n’a pas de type retour
• L’instanciation d’un objet et réaliser par
l’operateur « new »
 Exemple de création d’un objet
public class Employe {
private String nom, prenom;
private double salaire;
// Constructeur
public Employe(String n, String p) {
nom = n;
prenom = p;
}
...
public static void main(String[] args) {
Employe e1;
e1 = new Employe("Dupond", "Pierre");
...
}
}
 Constructeur par défaut
• Lorsque le code d’une classe ne comporte pas de
constructeur, un constructeur sera
automatiquement ajouté par Java
• Example:
class Point{double x,y;
}
…
Point pt;
pt= new Point();// Utilisation de constructeur par
//défaut
 surcharge des constructeurs
• Une classe peut posséder plusieurs
constructeurs. Dans ce cas, le constructeur par
défaut n’existe plus et il est préférable de
définir un constructeur sans paramètres.
 Exemple de surcharge de
constructeurs
public class Employe {
private String nom, prenom;
private double salaire;
// 2 Constructeurs
public Employe(String n, String p) {
nom = n; prenom = p;
}
public Employe(String n, String p, double s) {
nom = n; prenom = p; salaire = s;
}
//constructeur sans paramètre
public Employe(){ nom = « »; prenom = « »; salaire = 0.0;
}
...
e1 = new Employe("Dupond", "Pierre");
e2 = new Employe("Durand", "Jacques", 1500);
 Le constructeur par this()
• this() permet, dans la même classe, d’appeler un
constructeur par un autre constructeur surchargé.
• Exemple:
// Ce constructeur appelle l'autre constructeur
public Employe(String n, String p) {
this(n, p, 0);}// this(..) doit etre la premiere ligne du code
public Employe(String n, String p, double s) {
nom = n; prenom = p; salaire = s;}
…..
e1 = new Employe("Dupond", "Pierre");
e2 = new Employe("Durand", "Jacques", 1500);
 Méthodes: Les accesseurs
• Deux types de méthodes servent à donner accès
aux variables depuis l’extérieur de la classe :
– les accesseurs en lecture pour lire les valeurs
des variables ; « accesseur en lecture ». Par convention
cet méthode est nommées :getXxx ou Xxx et le nom du
champs auquel on veut récupérer la valeur.
– les accesseurs en écriture, ou modificateurs, ou
mutateurs, pour modifier leur valeurs . Par convention
cette méthode est nommées :setXxx ou Xxx et le nom du
champ auquel on veut modifier la valeur.
 Paramètres d’une méthode
• Les méthodes et les constructeurs qui ont besoin
qu’on leur passe des données sous la forme de
paramètres doivent indiquer le type des
paramètres dans la déclaration :
setSalaire(double unSalaire)
calculerSalaire(int indice, double prime)
• Quand la méthode ou le constructeur n’a pas de
paramètre, on ne met rien entre les parenthèses :
getSalaire()
 Type de retour d’une méthode
• Quand la méthode renvoie une valeur, on doit
indiquer le type de la valeur renvoyée dans la
déclaration de la méthode :
double calculSalaire(int indice, double prime)
• Le pseudo-type void indique qu’aucune valeur
n’est renvoyée :
void setSalaire(double unSalaire)
 Surcharge d’une méthode
• On peut surcharger une méthode, c’est-à-dire,
ajouter une méthode qui a le même nom mais
pas la même signature qu’une autre méthode.
– Signature: nombre et types de paramètre.
calculerSalaire(int)
calculerSalaire(int, double)
 Surcharge d’une méthode
• En Java, on ne peut pas différencier deux
méthodes par leur type retour
• Par exemple, il est interdit d’avoir ces deux
méthodes dans une classe :
int calculerSalaire(int)
double calculerSalaire(int)
 La méthode toString()
• il est conseillé d’inclure une méthode toString
dans toutes les classes que l’on écrit
• Souvent, cette méthode renvoie une chaîne
de caractères qui décrit l’instance
• System.out.println(objet) affiche la valeur
retournée par objet.toString()
 Exemple
public class Livre {
...
public String toString() {
return "Livre [titre=" + titre
+ ",auteur=" + auteur
+ ",nbPages=" + nbPages
+ "]";
}
}
public class Livre {
//Variables d’instances (attributs ou champs)
private String titre, auteur;
private int nbPages;
// Constructeur
public Livre(String unTitre, String unAuteur) {
titre = unTitre;
auteur = unAuteur;}
pulic Livre(String unTitre, String unAuteur, int unNbPages) {
this(unTitre, unAuteur);
nbPages= unNbPages;
}
//Méthodes
public String getAuteur() { // accesseur
return auteur;
}
public void setNbPages(int nb) { // modificateur
nbPages = nb;
}
public String toString() {
return "Livre [titre=" + titre+ ",auteur=" + auteur+ ",nbPages=" + nbPages+0 "]";
}}
 Les variables:
• Variables d’instances
– Sont déclarées en dehors de toute méthode
– conservent l’état d’un objet.
– sont accessibles par toutes les méthodes de la classe
• Les variables locales
– sont déclarées à l’intérieur d’une méthode
– conservent une valeur utilisée pendant l’exécution de
la méthode
– ne sont accessibles que dans le bloc dans lequel elles
ont été déclarées
 Déclaration des variables
• Toute variable doit être déclarée avant d’être
utilisée
• Pour déclarer une variable, on doit indiquer
son nom (identificateur) et son ce type
double prime;
Employe e1; // aucun objet n’est crée
Point centre; // aucun objet n’est crée
 Affectation

• L’affectation d’une valeur à une variable est

effectuée par l’instruction
variable = expression;
• L’expression est calculée et ensuite la valeur
calculée est affectée à la variable
• Exemple :
x = 3;
x = x + 1;
x=y=5;
 Initialisation d’une variable
• Une variable doit être initialisée (recevoir une
valeur) avant d’être utilisée dans une expression
• Si elles ne sont pas initialisées par le
programmeur, les variables d’instance (et les
variables de classe étudiées plus loin) reçoivent
les valeurs par défaut de leur type (0 pour les
types numériques, par exemple)
• L’utilisation d’une variable locale non initialisée
par le programmeur provoque une erreur (pas
d’initialisation par défaut) à la compilation
 Initialisation d’une variable
• On peut initialiser une variable en la
déclarant. La formule d’initialisation peut être
une expression complexe :
double prime = 200.0;
Employe e1 = new Employe("Dupond", "Jean");
double salaire = prime + 500.0;
 Déclaration et création

• Il ne faut pas confondre

– déclaration d’une variable
– création d’un objet référencé par cette variable
• Exemple:
public static void main(String[] args) {
Employe e1;
e1.setSalaire(1200);//provoque une erreur!
…}
• Employe e1; :
– déclare que l’on va utiliser une variable e1 qui référencera un
objet de la classe Employe,
– mais aucun objet n’est créé
 Déclaration et création
• Correction de l’anomalie:
public static void main(String[] args) {
Employe e1;
e1 = new Employe("Dupond", "Pierre");
e1.setSalaire(1200);
...
}
 Utilisation d’une variable d’instance
• Pour désigner un variable d’instance « v » d’un
Objet O en peut utiliser la notation: O.v
• Cette notation est toujours valable à
l’intérieure de la classe de l’objet ou si « v »
est déclarée publique.
• Mais si « v » est déclaré privée, cette notation
n’est plus valable à l’extérieure de la sa classe.
 Autorisation d’accès aux membres
d’une classe: encapsulation
• private : seule la classe dans laquelle il est
déclaré a accès (à ce membre ou
constructeur)
• public : toutes les classes sans exception y ont
accès
• Sinon, par défaut, seules les classes du même
paquetage que la classe dans lequel il est
déclaré y ont accès
• protected sera étudié dans le cours sur
 encapsulation
• En Java, la protection des attributs se fait
classe par classe, et pas objet par objet
• Un objet a accès à tous les attributs d’un objet
de la même classe, même les attributs privés
 Protection de l’état interne d’un objet
• Autant que possible l’état d’un objet (les variables
d’instance) doit être private
• Si on veut autoriser la lecture d’une variable depuis
l’extérieur de la classe, on lui associe un accesseur, avec le
niveau d’accessibilité que l’on veut
• Si on veut autoriser la modification d’une variable, on lui
associe un modificateur, qui permet la modification tout en
contrôlant la validité de la modification
• On peut autoriser l’accès au paquetage, ou à tous (public)
– si l’on veut un accès rapide pour améliorer les performances
– pour simplifier l’écriture du code qui accède à la variable
 Le mot clé « this »
• Le code d’une méthode d’instance désigne
l’instance qui a reçu le message (l’instance
courante), par le mot-clé this.
• Lorsqu’il n’y a pas d’ambiguïté, this est
optionnel pour désigner un membre de
l’instance courante
 Exemple de this implicite
public class Employe {
private double salaire;
...
public void setSalaire(double unSalaire) {
salaire = unSalaire; // implicitement « this.salaire »
}
public double getSalaire() {
return salaire; // implicitement « this.salaire »
}
}. . .
}
 Le mot clé « this »
• this est utilisé surtout dans 2 occasions :
– pour distinguer une variable d’instance et un paramètre qui
ont le même nom :
public void setSalaire(double salaire)
this.salaire = salaire;
}
– un objet passe une référence de lui-même à un autre objet :
salaire = comptable.calculeSalaire(this);
– Comptable et « this » sont deux objet de la classe « Employe »
• On ne peut pas modifier this; le code suivant est interdit :
this = valeur;
 variables de classe (statique) Vs
Variables d’instances
• Une variable de classe ou variable statique est
une variable partagée par toutes les instances
d’une classe (modificateur static); elle a la
même valeur pour toutes les instances de la
classe.
• La variable statique ne dépend que de la
classe où elle est définie et pas des objets de
cette classe.
 variables de classe (statique)
public class Employe {
private String nom, prenom;
private double salaire;
private static int nbEmployes = 0;
// Constructeur
public Employe(String n, String p) {
nom = n;
prenom = p; Taha Sami
Ahmed Rachid
nbEmployes++;
3000 5000
}. . .}
2
 Désigner une variable de classe
• Depuis une autre classe, quand le mode
d’accès le permet, on la préfixe par le
nom de la classe : Employe. nbEmployes;
• Depuis sa classe, le nom de variable suffit.
• On peut aussi la préfixer par une instance
quelconque de la classe
n = e1. nbEmployes;// à éviter : car
//ne dépend pas de e1
 Méthodes de classe (statique)
• Une méthode de classe exécute une action
indépendante d’une instance particulière de
la classe. Elle peut être considérée comme un
message envoyé à une classe
• Exemple :
public static int getNbEmployes() {
return nbEmployes;
}
 Désigner une méthode de
classe(statique)
• Depuis une autre classe, on la préfixe par le
nom de la classe :
int n = Employe.getNbEmploye();
• Depuis sa classe, le nom de la méthode suffit
• On peut aussi la préfixer par une instance
quelconque de la classe (à éviter car cela nuit à la
lisibilité : on ne voit pas que la méthode est
static) :
int n = e1.getNbEmploye();// à éviter : car
//ne dépend pas de e1
 Méthodes de classe (statique)
• Comme une méthode de classe exécute une
action indépendante d’une instance particulière
de la classe, elle ne peut utiliser que des variables
statiques. Elle ne peut non plus utiliser « this »
• Exemple:
static double tripleSalaire() {
return this.salaire * 3;// Erreur de compilation! }
• Une méthode de classe ne peut avoir la même
signature (nombre et types de paramètres)
qu’une méthode d’instance
 Pourquoi main() est statique:
• La méthode main() est nécessairement static
car elle est exécutée au début du programme.
Aucune instance n’est donc déjà créée lorsque la
méthode main() commence son exécution.
Pour cela elle ne peut donc pas être une
méthode d’instance.
 Blocs d’initialisation static
• Ils permettent d’initialiser les variables static trop
complexes à initialiser dans leur déclaration :
class UneClasse {
private static int [] tab = new int[25];
static {
for (int i = 0; i < 25; i++) {
tab[i] = 1;
}
}
...
• Ils sont exécutés une seule fois, quand la classe est chargée
en mémoire
 Blocs d’initialisation non static
• Ils servent à initialiser les variables d’instance ou toute
autre initialisation.
• Exemple:
class UneClasse {
private int[] tab = new int[25];
{
for (int i = 0; i < 25; i++) {
tab[i] = 1;
}
}
...
Représentation Graphique de classe en
UML

- Point centre
- int rayon

+ Cercle(Point, int)
+ void setRayon(int)
+ int getRayon()
+ double surface()

(- : private, # : protected, + : public, $ (ou souligné) : static)

 Les classes internes
• Une classe est dite interne lorsque sa définition
est située à l’intérieur de la définition d’une autre
classe.
• Exemple:
class E // définition d’une classe usuelle (dite alors externe)
{ ..... // méthodes et données de la classe E
class I // definition d’une classe interne à la classe E
{ ..... // méthodes et données de la classe I}
..... // autres méthodes et données de la classe E
}
49
 Les classes internes
• La définition de la classe I n’introduit pas d’office de membre de
type I dans E. Exemple:
class E
{ public void fe() // methode de E
{ I i = new I() ; // creation d’un objet de type I ; sa reference est
// ici locale a la methode fe
}
class I
{ ..... }
.....
}
• Ici un objet de classe E ne contient aucun membre de type I.
Simplement, une de ses méthodes (fe) utilise le type I pour
instancier un objet de ce type.

50
 Les classes internes
• Dans une classe E, on peut trouver une ou plusieurs
références à des objets de type I.
class E
{ .....
class I
{ .....
}
private I i1, i2 ; /* les champs i1 et i2 de E sont des références
a des objets de type I */
}
• Ici, un objet de classe E contient deux membres de type I

51
 Lien entre objet interne et objet
externe
• Un objet d’une classe interne est toujours associé, au
moment de sa création , à un objet d’un classe externe
dont on dit qu’il lui a donné naissance.
– Exemple, l’objet de référence i sera associé à l’objet de
type E auquel sera appliquée la méthode fe.
• Un objet d’une classe interne a toujours accès aux
champs et méthodes (même privés) de l’objet externe
lui ayant donné naissance
• Un objet de classe externe a toujours accès aux
champs et méthodes (même privés) d’un objet d’une
classe interne auquel il a donné naissance.

52
Déclaration et instanciation d’un objet
d’une classe interne
• En dehors de E, on peut toujours déclarer une
référence à un objet de type I, par:
E.I i ; // référence a un objet de type I (interne à E)
• La création d’un objet de type I ne peut se faire qu’en le
rattachant à un objet de sa classe englobante.
E e = new E() ;
i = e. new I() ; /* création d’un objet de type I, rattaché à l’objet e
et affectation de sa référence à i */

53
 Classes internes locales
• Java permet de définir une classe interne I dans une méthode f d’une
classe E.
– Dans ce cas, l’instanciation d’objets de type I ne peut se faire que dans f.
– En plus des accès déjà décrits, un objet de type I a alors accès aux variables
locales finales de f.
public class E
{ .....
void f()
{ final int n=15 ; float x ;
class I // classe interne à E, locale à f
{ ..... // ici, on a accès a n, pas a x
}
I i = new I() ; // classique
}
}

54
 Classes internes statique
• Java permet de créer des classes internes autonomes en
employant l’attribut static
public class E // classe englobante
{ .....
public static class I // définition (englobée dans celle de E)
{ ..... // d’une classe interne autonome}
}
• Depuis l’extérieur de E, on peut instancier un objet de classe I de
cette façon :
E.I i = new E.I() ;
• L’objet i n’est associé à aucun objet de type E.
• Bien entendu, la classe I n’a plus accès aux membres de E, sauf s’il
s’agit de membres statiques.

55
Droits d’accès pour les classes internes
compte tenu de l’imbrication de leur définition dans celle
d’une autre classe :
• avec public, la classe interne est accessible partout où sa
classe externe l’est ;
• avec private (qui est utilisable avec une classe interne, alors
qu’il ne l’est pas pour une classe externe), la classe interne
n’est accessible que depuis sa classe externe ;
• sans aucun mot-clé, la classe interne n’est accessible que
depuis les classes du même paquetage.
• Avec protected (qui est utilisable avec une classe interne,
alors qu’il ne l’est pas pour une classe externe), la classe
interne n’est accessible que depuis les classes du même
paquetage et les classe dérivée de sa classe externe.
 La classe Object
• Classe fournie par java: c’est la classe mère de
toute les classe. Parmi les méthodes de cette
classe :
public String toString() {...}
protected native Object clone() throws
CloneNotSupportedException {...}
public equals(java.lang.Object) {...}
public native int hashCode() {...}
protected void finalize() throws Throwable {...}
 La classe Scanner
• Permet le lecture des données sur l’entrée standard:
clavier ou fichier.
• D’abord l’importer :
import java.util.Scanner;
• Ensuite créer un objet de la classe Scanner :
Scanner sc = new Scanner(System.in);
String chaine= “une chaine de caracteres”
Scanner str = new Scanner(chaine);

• Pour récupérer les données, Utiliser l’une des

méthodes :
 La classe Scanner
• String next(): donnée de la classe String qui forme un
mot,
• String nextLine(): donnée de la classe String qui forme
une ligne,
• boolean nextBoolean() : donnée booléenne,
• int nextInt(): donnée entière de type int,
• byte nextByte() : donnée entière de type byte,
• short nextShort : donnée entière de type short,
• long nextLong : donnée entière de type long,
• float nextFloat : donnée entière de type float,
• double nextDouble(): donnée réelle de type double.
 La classe Scanner
• Pour vérifier le type d’une donnée avant de la lire :
boolean hasNext(): renvoie true s’il y a une donnée à lire
boolean hasNextLine(): renvoie true s’il y a une ligne à
lire
boolean hasNextBoolean(): renvoie true s’il y a un
booléen à lire
boolean hasNextInt(): renvoie true s’il y a un entier à lire
boolean hasNextDouble(): renvoie true s’il y a un double
à lire.
Plateforme Java
 Objectifs de la conception de java
• Langage d’une syntaxe simple, Orienté Objet
et interprété et optimisant le cycle de
développement. ( compilation et exécution)
• Les applications sont portables
• Meilleure gestion de la mémoire (via le «
ramasse miette ») .
• Les applications graphiques sont plus
performantes.
• Plus de sécurité (via la Machine Virtuelle Java)
 Essor de Java
• Les caractéristique de java se trouvent très
intéressantes pour les application
client/server sur internet ou intranet:
– Le téléchargement d’un programme java à partir
d’un site prend peu de temps
– Un programme java peut tourner sur n’importe
quelle plate-forme
 Plate-forme Java

• Partie logiciel qui s’exécute sur de nombreux

machines et système d’exploitation. Il se
compose de :
– Machine virtuelle Java (JVM)
– Interface de programmation application Java (API)
– Les outils de déploiement des applications
– Les outils d’aide au développement
 Machine virtuelle Java (Java)
• C’est la base de la plate-forme Java: il est
nécessaire pour exécuté un programme java:
– JVM interprète le byte-code
– JVM gère la mémoire: nettoyage de la mémoire-
ramasse-miettes (Garbage collector)
– JVM assure la sécurité: initialisation de mémoire,
conversion de type. Pour les applets JVM interdit
au programme d’accéder au périphériques
– JVM s’occupe de l’interfaçage avec du code natif:
code écrit dans un autre langage
 API Java
• Contient une collection de composant logiciel
préfabriqué qui fournissent un grand nombre
de fonctionnalités:
– APIs de bases
– APIs d’accès aux données
– APIs de gestion d’interface d’application avec
l’utilisateurs
 Les outils de développement
d’application
• Java Web Start : simplifie le déploiement et
l’installation des application java et assure la
mise à jour par la suite.

• Java Plug-in : Permet le fonctionnement des

applet Java avec la JVM
Les outils d’aide au développement
• Javac.exe : compilateur java
• Javadoc.exe: Génère la documentation java
• Java.exe: Permet d’exécuter une application
java
• Appletviewer: exécute une applet java dans
une page web
 Cycle de conception d’un programme
Java
• D’abord se procurer le kit de développement
des application java à partir du site d’oracle.
– Téléchargera le JDK(Java development kit)
• Utiliser l’API pour écrire le code
• Compiler
• Executer
 Différentes étapes de création d’un
programme Java
• Création des fichiers source
• Compiler un fichier source
• Exécuter l’application
 Création des fichiers source
• Un ou plusieurs fichiers de code source
• Tout code java est contenu à l’intérieur d’une classe
qui est elle-même contenue dans un fichier portant
l’extension .java
• Plusieurs classes peuvent exister dans un même fichier
.java mais une seule peut être déclarée publique, et
c’est la classe qui donne son nom au fichier.
• Dans une application, une et seulement une classe doit
contenir la méthode main() qui a le prototype:
public static void main(String[] args)
 Création des fichiers source
• Le fichier source java sont des fichier texte qui peut
être enregistrer à l aide d’une simple éditeur de texte
(EX bloc note)
• Un fichier contient une ou plusieurs classes. Mais une
seule classe est déclarée « public ».
• Les fichier doit être enregistrer avec le l’extension
« .java ». Son nom est le nom de la classe. S’il contient
plusieurs classes son nom est celui de la classe
publique
• Il existe des environnement de développement
d’application java plus sophistiqués : Eclipse, netbeans,
Jcreator…..
 Compiler un fichier source
• Pour compiler , à l’invite de commande, tapez:
– javac <nomFicier>.java
– javac <nomFicier1>.java, <nomFicier2>.java,
<nomFicier3>.java,
• Apres compilation chaque classe génère un
fichier qui porte le nom de la classe avec
l’extension .class
 Exécuter une application
• java lance l’interprétation du code de la
méthode main().
• Pour exécuter un programme java on utilise la
commande :
– Java <fichierMain>
• <fichierMain>: qui contient la classe principale
de la l’application; la classe qui contient la
méthode main().
 Paquetages
• Les classes Java sont regroupées en
paquetages (packages en anglais). Il offrent
un niveau de modularité supplémentaire pour
– réunir des classes suivant un centre d’intérêt
commun
– la protection des attributs et des méthodes
• Le langage Java est fourni avec un grand
nombre de paquetages

75
 Quelques paquetages du SDK
• java.lang : classes de base de Java
• java.util : collections
• java.io : entrées-sorties
• java.awt : interface graphique
• javax.swing : interface graphique avancée
• java.applet : applets
• java.net : réseau
• java.sql: accès aux bases de données

76
 Nommer une classe
• Le nom complet d'une classe est le nom de la
classe préfixé par le nom du paquetage :
java.util.ArrayList
• Une classe du même paquetage peut être
désignée par son nom « terminal » (les classes
du paquetage java.util peuvent désigner la
classe cidessus par « ArrayList »)
• Une classe d’un autre paquetage doit être
désignée par son nom complet

77
 Importer une classe d’un paquetage
• Pour pouvoir désigner une classe d'un autre
paquetage par son nom terminal, il faut
l’importer
import java.util.ArrayList;
public class Classe {
…
ArrayList liste = new ArrayList();
• On peut utiliser une classe sans l’importer ;
l’importation permet seulement de raccourcir le
nom d’une classe dans le code

78
 Importer toutes les classes
d’un paquetage
• On peut importer toutes les classes d'un
paquetage :
import java.util.*;
• Les classes du paquetage java.lang sont
automatiquement importées

79
 Importer des constantes static
• Depuis le JDK 5.0 on peut importer des variables ou
méthodes statiques d’une classe ou d’une interface avec
« import static »
• Example1:
import static java.lang.Math.*;
public class Machin {
...
x = max(sqrt(abs(y)), sin(y));
• Example 2:
import static java.lang.Math.PI;
...
x = 2 * PI;
80
Ajout d’une classe dans un paquetage
• package nom-paquetage;
• doit être la première instruction du fichier
source définissant la classe (avant même les
instructions import)
• Par défaut, une classe appartient au «
paquetage par défaut » qui n’a pas de nom, et
auquel appartiennent toutes les classes
situées dans le même répertoire (et qui ne
sont pas dans un paquetage particulier)

81
Fichier contenant plusieurs classes
• L’instruction package doit être mise avant la
première classe du fichier
• Toutes les classes du fichier sont alors mises
dans le paquetage
• De même, les instructions « import » doivent
être mises avant la première classe et
importent pour toutes les classes du fichier
• Rappel : il n’est pas conseillé de mettre
plusieurs classes dans un même fichier
82
 Sous-paquetage
• Un paquetage peut avoir des sous-paquetages
• Par exemple, java.awt.event est un
souspaquetage de java.awt
• L’importation des classes d’un paquetage
n’importe pas les classes des sous-paquetages ;
• on devra écrire par exemple :
import java.awt.*;
import java.awt.event.*;

83
 Nom d’un paquetage
• Le nom d’un paquetage est hiérarchique :
java.awt.event

84
 Encapsulation d’une classe
dans un paquetage
• Si la définition de la classe commence par
public class la classe est accessible de partout
• Sinon, la classe n’est accessible que depuis les
classes du même paquetage

85
Deployment d’une application
Java
Fichiers archives de java

86
 Archive java
• Une archive java (fichier jar) est un format
particulier permettant de regrouper dans un
seul fichier (l’archive) plusieurs autres fichiers
– Le fichier jar regroupe tous les fichier nécessaire
au fonctionnement de le l’application.
– Ils contiennent les .class et autres ressources
nécessaires (icones, etc.)

87
 Avantage de l’archive
• Les fichiers archives peuvent être compressés afin
d’optimiser leurs stockage et leur transfert sur un
réseau
• Les applet peuvent être récupérées par le navigateur
avec une seule requêtes http
<applet
code=AppletClassName.class
archive="JarFileName.jar"
width=width height=height> </applet>
• la sécurité est améliorée par la signature l’archive.
• Le format des archives est standard et est donc
portable.

88
 Manipulation d’une archive
• Creation d’une archive
jar cf nomDuFichier listeFichier
– c: indique à la commande jar que l’on souhaite créer une
archive.
– f: indique que la commande jar doit générer un fichier.
L’extension du fichier est .jar
• Si plusieurs fichiers sont à inclure dans l’archive, leurs
noms sont séparés par un espace.
• Si un nom de répertoire est présent dans la liste, son
contenu entier est ajouté à l’archive.
• Le caractère generique * est également autorisé dans
la liste.

89
 Manipulation d’une archive
• L’archive est créer dans le répertoire courant
• Un fichier manifest par défaut est ajouté à
l’archive
• Les option suivantes sont également disponible:
– v: affiche le nom des fichier au fur et à mesure de
l’ajout dans l’archive.
– O: désactive la compression du fichier archive
– M: désactive la génération du manifest
– m: ajout le manifest indiqué à l’archive.
– -C : supprime le nom de répertoire dans l’archive.

90
 Manipulation d’une archive
• Visualisation d’une archive
– Pour afficher sur la console le contenu de l’archive
ardoise : jar tf ardoise.jar
– Pou afficher des information supplémentaire sur
le fichier on utilise le paramètre v :
• jar tvf ardoise.jar

91
 Manipulation d’une archive
• Extraction des fichiers:
– Les fichier peuvent être extraits par la commande
jar xvf ardoise.jar
– Le fichier extrait sera recrée alors sur le disque.
– L’extraction peut ne concerner que certains
fichiers: jar xvf ardoise.jar ClientArdoise.class

92
 Manipulation d’une archive
• Mise à jour
– jar uf ardoise.jar connect.gif : le fichier sera
ajouté s’il n’existe pas déjà. S’il existe il sera
remplacé
– On peut ajouter ou modifier plusieurs fichiers à la
fois.

93
 Manipulation d’une archive
• Exécution
– java –jar ardoise.jar : cette commande permet
d’exécuter l’application sans extraire l’archive.
– Dans ce cas, le fichier contenant main doit être
fourni à la machine virtuelle par le fichier manifest
de l’archive.

94
 Le manifest
• Le manifest est un fichier texte contenant des
couples nom de paramètre et valeur de
paramètre.
• Ce fichier est toujours nommé MANIFEST.MF et
se trouve dans le répertoire MEFA-INF de
l’archive.
• A la création d’un fichier archive, un fichier
manifest est crée par défaut. Il contient les
information suivante:
– Manifest-Version: 1.0
– Created-By: 1.7.0

95
 Le manifest
• Pour ajouter des informations au manifest, on
doit d'abord créer un fichier texte contenant
ces informations.
• Ensuite fusionner ce fichier texte avec le
manifest par défaut de l’archive en utilisant
l’option m de la commande jar.

96
 Le manifest
• Exemple: Dans le fichier infos.txt on ajoute
l’information:
– Main-Class: ClientArdoise
• On fusionne avec la commande:
– jar cfm ardoise.jar infos.txt *
• Le fichier manifest contiendra alors les
information:
– Manifest-Version: 1.0
– Created-By: 1.7.0
– Main-Class: ClientArdoise
97