ROYAUME DU MAROC

Office de la Formation Professionnelle et de la Promotion du Travail

Classes et Objets

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

SECTEUR NTIC
 ROYAUME DU MAROC

Office de la Formation Professionnelle et de la Promotion du Travail

DIRECTION RECHERCHE ET INGENIERIE DE FORMATION

SECTEUR NTIC
 Classe et Objet

[Link]
1. Sommaire........................................................................................1
2. Introduction à la P.O.O......................................................................3
2.1. La programmation classique :..........................................................3
2.2. La programmation objet ou P.O.O....................................................3
2.3. Avantages de la P.O.O....................................................................4
3. Exemple :Le type abstrait Personne.....................................................4
3.1. Cahier des charges.........................................................................4
3.2. Programmation classique, en langage C............................................4
3.3. Problèmes.....................................................................................5
4. Programmation objet.........................................................................5
4.1. Vocabulaire et définitions................................................................5
4.2. La classe, support de l’encapsulation................................................5
5. Une première version de la classe Personne..........................................5
5.1. Pour le cahier des charges :............................................................5
5.2. on peut définir :.............................................................................6
6. Un cahier des charges plus complet.....................................................6
6.1. Précisons les propriétés des objets Personne.....................................6
6.2. L’accès aux informations doit être contrôlé........................................7
7. Accès public ou privé ?......................................................................7
7.1. Seconde implémentation de la classe................................................7
7.2. mots clés : public ou private............................................................7
7.3. Les deux acteurs de la programmation objet......................................7
8. Contrôlons les instanciations..............................................................8
8.1. L’instanciation par défaut................................................................8
8.2. Définir un constructeur...................................................................8
9. Une nouvelle version de la classe........................................................8
9.1. Utilisation de this...........................................................................9
9.2. Récapitulons.................................................................................9
10. Types primitifs et types objets............................................................9
10.1. Les types primitifs : Rappels.........................................................9
10.2. Une variable de type objet désigne sa valeur................................10
10.3. Valeurs par défaut.....................................................................10
10.4. Affectation de variables de types primitifs.....................................10
10.5. Affectation d’une référence.........................................................11
11. Pile d’exécution, tas d’allocation........................................................11
11.1. Exemple d’exécution..................................................................12
12. Définissons des accesseurs...............................................................12
12.1. Comment changer de société ?...................................................12
12.2. Créer deux méthodes supplémentaires.........................................12
12.3. Intérêt des accesseurs...............................................................12
13. Une classe Personne sécurisée..........................................................13
14. Un ou plusieurs constructeurs ?.........................................................14
14.1. Revenons sur le premier constructeur..........................................14
14.2. Un deuxième constructeur..........................................................14
14.3. Notion de signature...................................................................14
15. Modificateurs static et final...............................................................14
15.1. Améliorer la gestion des personnes sans société............................14
15.2. Une variable de classe constante.................................................15
16. Variables et méthodes de classe........................................................15
Document Millésime Page
OFPPT @ [Link] novembre 08 1 - 29
 Classe et Objet

16.1. Définition.................................................................................15
16.2. Exemple d’utilisation..................................................................16
17. Comment exécuter une classe ?........................................................16
17.1. Définir une classe......................................................................16
17.2. Créer un exécutable : 3 solutions................................................16
17.3. Lancer un exécutable.................................................................17
18. Récapitulons…................................................................................17
18.1. Conventions d’écriture...............................................................17
18.2. Conseils...................................................................................18
19. Version finale de la classe Personne...................................................18
20. Ecriture et exécution d’un programme Java........................................19
20.1. Deux types d’applications...........................................................19
20.2. Structure d’une application stand-alone........................................19
20.3. Structure d’une applet...............................................................20
21. Une classe usuelle : la classe String...................................................20
21.1. Définition d’une chaîne de caractères...........................................21
21.2. Longueur et accès aux caractères................................................21
21.3. Comparaison............................................................................21
21.4. Autres méthodes :....................................................................21
22. Importations..................................................................................21
22.1. Les packages............................................................................21
22.2. Instruction d’importation............................................................22
23. Exercices :.....................................................................................22

Document Millésime Page

OFPPT @ [Link] novembre 08 2 - 29
Classe et Objet

2. Introduction à la P.O.O.
2.1. La programmation classique :
Structures de
données

Algorithmes

Programme

Dans la programmation traditionnelle (années 70 et 80) un programme faisait appel à

des fonctions ou procédures ( en PASCAL) qui traitaient des données ou des structures
de données (plus généralement). Le principe était de trouver l’algorithme puis ensuite
de trouver la structure de donnée la mieux appropriée pour le passage de paramètre
aux différentes fonctions. Cette programmation rendait la structure de données
« fragile » car n’importe quelle fonction pouvait accéder et changer les champs de cette
structure . De plus la réutilisation du code de certaines fonctions était difficile car rien
n’était compartimenté.

2.2. La programmation objet ou P.O.O.

Objet de la classe xxx

Données (notées attributs Fonctions de traitements des

ou champs) données ou méthodes

Dans la programmation objet chaque paquets de données (qui aurait fait parti d’une
structure en programmation classique) est dans une classe. Les différents traitements
à réaliser sur ces données sont faits par des fonctions appartenant à la classe. L’accès
aux données ne se fera que par des fonctions de la classe. Le fait de compartimenter le
code et les données dans une classe permet la réutilisation du code.
Exemples :
Classe Bateau : champs : Capitaine, type, couleur, position, vitesse,…
Fonctions ou méthodes : marche, stop, plus_vite, moins_vite
Classe Fenetre champs : positionX,positionY,TailleX,TailleY,Couleur,Nom,
…

Document Millésime Page

OFPPT @ [Link] novembre 08 3 - 29
Classe et Objet

Fonctions ou méthodes : Créer, Réduire,Fermer,Déplacer, …

2.3. Avantages de la P.O.O.

 La découpe du problème en classes et donc en objets (instances de la classe)
permet la réutilisation du code, chose plus difficile avec un programme classique.

 Une classe peut hériter d’une autre classe ce qui permet d’utiliser les fonctions et
les données de la classe parent et de rajouter les données et fonctions de la
nouvelle classe( en programmation graphique toute nouvelle fenêtre windows est
un objet hérité de la classe Fenêtre dans laquelle on va rajouter le code et les
données de l’application).

 Les fonctions de la classe n’ont pas un grand nombre d’arguments puisque les
données sont lisibles par les fonctions de la classe.

 Les données de la classes sont protégées de l’extérieur : sécurité.

 Grâce à la P.O.O., on gagne en rapidité de fabrication du code, puisqu’il est

possible d’utiliser un grand nombre de classe déjà existante.

3. Exemple :Le type abstrait Personne

3.1. Cahier des charges
Une personne est décrite par deux informations :
- son nom,
- la société où elle travaille.
Une personne est capable de s’identifier, en affichant les informations qui la
caractérisent.

3.2. Programmation classique, en langage C

#include <stdio.h>
#include <string.h>

struct Personne { /* une personne est décrite par son nom et sa société */
char Nom[25];
char Societe[32];
};

void Presente(struct Personne P)

{ /* ce traitement permet d’afficher la description d’une personne */
printf (« Je m’appelle %s\n », [Link]);
printf (« Je travaille à %s\n », [Link]);
}
void main()
{
/* on définit la variable Individu qui décrit une personne /
struct Personne Individu;
/ on initialise cette variable /
strcpy([Link], « DURAND »);
strcpy([Link], « OUTILS JAVA SA »);

Document Millésime Page

OFPPT @ [Link] novembre 08 4 - 29
Classe et Objet

/ on affiche la description de Individu */

Presente(Individu);
}

3.3. Problèmes
Les informations qui concernent une personne ne sont pas protégées.
En effet, tout utilisateur du type composé struct Personne est libre de modifier Nom ou
Societe sans restriction.

4. Programmation objet
4.1. Vocabulaire et définitions
Un objet est caractérisé par ses informations et ses comportements : en
programmation, on dira qu’un objet encapsule données et traitements.
Un objet reçoit des messages qui déclenchent ses comportements.
La programmation orientée objet apporte une sécurité supplémentaire par rapport à la
programmation classique puisque l’objet contrôle chacun des comportements qui lui sont
propres.
Les propriétés des objets de données et comportements semblables sont décrites par
une même classe.

4.2. La classe, support de l’encapsulation

Une classe décrit une famille d’objets.

Les objets regroupés dans une même classe CCC sont appelés les instances de CCC.
Les données d’un objet sont ses variables d’instance.
Les comportements communs à toutes les instances sont représentés par des
méthodes d’instance.

5. Une première version de la classe Personne

5.1. Pour le cahier des charges :

Une personne est décrite par deux informations :
- son nom, enregistré en majuscules
- la société où elle travaille.
Une personne est capable de s’identifier, en affichant les informations qui la
caractérisent.

5.2. on peut définir :

class Personne {
// deux variables d’instance

Document Millésime Page

OFPPT @ [Link] novembre 08 5 - 29
Classe et Objet

public String nom;

public String societe;
// une méthode
public void presenteToi() {
[Link](« Je m’appelle « + nom);
[Link](« Je travaille à « + societe);
}
public static void main (String arg[])
{
Personne p = new Personne();//création d’une instance de la classe Personne
[Link] = « DURAND »;
[Link]= »OUTILS JAVA SA »;
[Link](); //appel à méthode presenteToi()
}
} // class Personne, version provisoire

On obtient alors le même fonctionnement que le programme écrit en C précédemment.

6. Un cahier des charges plus complet

6.1. Précisons les propriétés des objets Personne
A Une personne est décrite par deux informations :
son nom et la société où elle travaille.
B Une personne a toujours un nom. Ce nom ne peut pas changer.
C’est une chaîne de caractères, dans laquelle les lettres sont en majuscules.
C Une personne n’est pas forcément associée à une société. Dans ce cas, elle est
considérée comme un travailleur indépendant ou comme une personne sans activité.
Une personne doit pouvoir indiquer si elle est ou non salariée (c’est-à-dire si sa société
est identifiée).
D Lorsqu’une personne est associée à une société, cette société est identifiée par une
chaîne ne comportant pas plus de 32 caractères, dans laquelle les lettres sont en
majuscules.
E Une personne peut changer de société ou même perdre toute association à une
société.
F Une personne est capable de s’identifier,en affichant les informations qui la
caractérisent.

6.2. L’accès aux informations doit être contrôlé

Si la classe Personne définit deux variables d’instance nom et société, le programmeur
qui utilise un objet Personne ne doit pas pouvoir affecter sans contrôle une nouvelle
valeur à l’une ou l’autre de ces variables.

Document Millésime Page

OFPPT @ [Link] novembre 08 6 - 29
 Classe et Objet

7. Accès public ou privé ?

7.1. Seconde implémentation de la classe
class Personne {
private String nom;
private String societe;
public void presenteToi() {
[Link](« Je m’appelle « + nom);
[Link](« Je travaille à « + societe);
}
} // class Personne, version provisoire

Maintenant, si on écrit :
Personne p = new Personne();
[Link] = « durand »; // nom en minuscules : la règle B n’est pas respectée

Le compilateur refuse la seconde instruction : [Link], privée, est inaccessible pour

l’utilisateur de la classe Personne.
Ainsi il n’est plus possible de venir changer les données de la classe (ou propriétés)
directement. On pourra changer la valeur de ces propriétés à travers des méthodes qui
vérifieront la justesse des informations entrées.

7.2. mots clés : public ou private

public les variables et méthodes d’une classe CCC, définies avec le modificateur
public sont accessibles partout où CCC est accessible.
private les variables et méthodes d’une classe CCC, définies avec ce modificateur
ne sont accessibles que dans la classe CCC.

7.3. Les deux acteurs de la programmation objet

Le concepteur de la classe CCC :est celui qui définit CCC : dans les méthodes de
CCC, il a directement accès aux variables d’instance et aux méthodes privées

Un utilisateur de la classe CCC :est aussi un programmeur mais il n’a directement accès
qu’aux variables et méthodes publiques de CCC.

8. Contrôlons les instanciations

8.1. L’instanciation par défaut
Avec la définition de la classe Personne de la page précédente, si nous exécutons :
Personne p = new Personne(); [Link]();

nous voyons s’afficher :

Je m’appelle null Je travaille à null

Document Millésime Page

OFPPT @ [Link] novembre 08 7 - 29
Classe et Objet

Quand le concepteur de la classe n’a pas spécifié de mécanisme d’instanciation, Java en

fournit un par défaut, encore appelé constructeur par défaut.
Le constructeur par défaut initialise chaque variable d’instance vi avec une valeur
par défaut :
-null si vi est de type objet,
- valeur par défaut du type ttt si ttt est un type primitif.

8.2. Définir un constructeur

class Personne {
private String nom;
private String societe;
public Personne (String leNom) {
nom = [Link](); // cahier des charges, règle B
}
// etc. cf. page précédente
}

Avec le constructeur Personne(String) on peut instancier un objet Personne dont le

nom est conforme aux spécifications :
Personne p = new Personne(« durand »);
et on ne peut plus instancier d’objet de nom indéterminé :
Personne p = new Personne();// erreur de compilation : il n’y a plus de constructeur
par défaut

Le constructeur est une des composantes importantes de la programmation objet. Toute

nouvelle instance est créée en utilisant un constructeur de clase.

9. Une nouvelle version de la classe

Dans cette nouvelle version, on retrouve le constructeur de la classe . Ce constructeur
(même nom que la classe) initialise les propriétés nom et societe de la classe Personne.
class Personne {
private String nom;
private String societe; // l’absence de société sera signalée par « ? »
public Personne (String nom) {
// construit un objet Personne de nom invariable et de société inconnue
[Link] = [Link]();
// qualification avec this pour distinguer la variable d’instance du paramètre
societe = new String(« ? »);
}
public void presenteToi() {
[Link](« Je m’appelle « + nom);
if ([Link](« ? »))
[Link](« Je ne suis pas salarié »);
else [Link](« Je travaille à « + societe);
}
} // class Personne, deuxième version

9.1. Utilisation de this

Dans un constructeur, le mot-clef this désigne l’objet qui est construit.
Dans une méthode, ce mot-clef désigne l’objet qui traite le message :

Document Millésime Page

OFPPT @ [Link] novembre 08 8 - 29
 Classe et Objet

// une autre méthode de la classe Personne

public void memeSocieteQue(Personne uneAutre) {
[Link] = [Link]; // ici, this est facultatif
}

9.2. Récapitulons
Le constructeur par défaut est encore appelé constructeur sans paramètres ou
constructeur implicite.
Un constructeur est une méthode particulière, en général publique et dont
l’identificateur est le même que celui de la classe et qui est toujours définie sans type
de renvoi.
Dès qu’un constructeur explicite est défini, le constructeur par défaut n’est plus
disponible, sauf si le programmeur le rétablit en définissant explicitement un
constructeur sans paramètres.

10. Types primitifs et types objets

Dans la séquence
Personne p;
byte age; // aucune valeur de age n’est supérieure à 127
String prenom = « Delphine »;

• la variable p est une référence non initialisée sur le type objet Personne,
- la variable age est une variable du type primitif byte,
- la variable prenom est une référence sur le type objet String, initialisée avec l’objet
String « Delphine ».

[Link] types primitifs : Rappels

Entiers avec signe : Réels représentés Caractères : Valeurs logiques :

en virgule
flottante :
byte (8 bits), float (32 bits), char (16 bits, boolean, deux
short (16 bits), double (64 bits) Unicode) valeurs true et false.
int (32 bits),
long (64 bits).

Les types primitifs ont déjà été vus précédemment.

Variables, valeurs et affectations :

Une variable de type primitif contient sa valeur.

Document Millésime Page

OFPPT @ [Link] novembre 08 9 - 29
Classe et Objet

L’emplacement mémoire de la variable contient la valeur associée à la variable.

[Link] variable de type objet désigne sa valeur

L’emplacement mémoire de la variable contient une référence sur l’objet associé à la

variable.
La valeur par défaut d’une référence est null, quel que soit le type objet associé.

[Link] par défaut

Une variable d’instance non initialisée par un constructeur explicite est toujours
initialisée par Java avec la valeur par défaut de son type.
Toutes les autres variables ne sont pas initialisées par défaut : elles doivent
obligatoirement être initialisées par le programmeur avant la première utilisation de
leur valeur.

[Link] de variables de types primitifs

L’exécution de la séquence suivante :
int a, b;
a = 2356;
b = a;
a = a + 4;
[Link](“a vaut “ + a);
[Link](“b vaut “ + b);

affichera
a vaut 2360
b vaut 2356

Les valeurs de a et b sont distinctes

[Link] d’une référence

Supposons que la classe Personne définit la méthode vaDansSociete qui permet
d’affecter une valeur à la variable d’instance societe.
L’exécution de la séquence :
Personne p1, p2;
p1 = new Personne(« Meunier »);
[Link]();
p2 = p1;

Document Millésime Page

OFPPT @ [Link] novembre 08 10 - 29
Classe et Objet

[Link](« Outils Java SA »);

[Link]();
affichera
Je m’appelle MEUNIER
Je ne suis pas salarié
Je m’appelle MEUNIER
Je travaille à Outils Java SA

Les références p1 et p2 désignent le même objet.

P1 Meunier
nom
Outils Java SA
societe
P2
P1 = P2

11. Pile d’exécution, tas d’allocation

Comme dans la plupart des langages, Java gère une pile d’exécution :
chaque méthode appelée ajoute à cette pile son environnement, c’est-à-dire ses
variables locales et ses paramètres.
Plus généralement, l’exécution d’un bloc de code empile un environnement, qui est
dépilé quand l’exécution du bloc est terminée.
Une variable de pile (variable locale ou paramètre) peut être de type primitif ou de
type objet. Elle est détruite quand son environnement est dépilé.
Un objet n’est jamais enregistré dans la pile. Il est construit dans un espace
d’allocation dynamique, le tas d’allocation, géré par le processeur Java.
Un objet ne peut être détruit tant qu’il existe au moins une référence sur lui. C’est
le ramasse-miettes (garbage collector) de la machine virtuelle Java qui récupérera
l’espace que cet objet occupait : le programmeur n’a pas à se soucier de cette
opération.

[Link] d’exécution

Document Millésime Page

OFPPT @ [Link] novembre 08 11 - 29
Classe et Objet

12. Définissons des accesseurs

[Link] changer de société ?
Nous n’avons aucun moyen d’associer une société à une personne puisque la variable
d’instance societe est privée.
Il faut donc définir de nouvelles méthodes publiques dans la classe qui permettront de
modifier et d’afficher la société d’une personne.

[Link]éer deux méthodes supplémentaires

public String taSociete() { // accès en consultation
return societe;
}

public void vaDansSociete(String entreprise) {

// accès en modification
societe = entreprise; // attention au cahier des charges !
}

Les méthodes taSociete et vaDansSociete sont respectivement des accesseurs en

consultation et en modification de la variable d’instance societe.

[Link]érêt des accesseurs

Gérer l’accessibilité des variables privées
on peut limiter l’accès aux données à la lecture (avec uniquement un
accesseur en consultation) ou étendre l’accès en lecture/écriture (avec deux
accesseurs en consultation et en modification).

Gérer l’intégrité des données

l’accesseur en modification comporte souvent des contrôles qui permettent
de valider la nouvelle valeur de la variable.

Document Millésime Page

OFPPT @ [Link] novembre 08 12 - 29
Classe et Objet

13. Une classe Personne sécurisée

class Personne {
private String nom;
private String societe; // l’absence de société sera signalée par « ? »

public Personne (String nom) {

// construit un objet Personne de nom invariable et de société inconnue
[Link] = [Link]();
// qualification avec this pour distinguer la variable d’instance du paramètre
societe = new String(« ? »);
}
public void presenteToi() {
[Link](« Je m’appelle « + nom);
if ([Link](« ? »))
[Link](« Je ne suis pas salarié »);
else [Link](« Je travaille à « + societe);
}

public String tonNom() { // accès en consultation

return nom;
}
public String taSociete() { // accès en consultation
if ( [Link](“?”) )
return new String(“société inconnue”);
else return societe;
}
public void quitteTaSociete() {
if ( [Link](“?”) ) {
presenteToi();
[Link](« impossible de quitter la société »);
[Link](1); // arrêt de l’exécution, code d’erreur 1
}
societe = « ? »; // car ici, on est sûr qu’il y a une société à quitter
}
private String valideSociete(String sNom) {
// méthode-filtre : renvoie sNom s’il représente un nom de société acceptable
if ( [Link]() > 32 || [Link](« ? ») ) {
// en Java, || représente l’opérateur logique OU
[Link](« classe Personne, société incorrecte : «
+ sNom);
[Link](2); // arrêt de l’exécution, code d’erreur 2
}
// ici, on est sûr que sNom est valide
return sNom;
}
public void vaDansSociete(String entreprise) {
// avant d’aller dans une société, il faut avoir quitté la précédente
if ( ! [Link](« ? ») ) {
// en Java, ! représente l’opérateur logique NON
presenteToi();
[Link](« erreur : 1-quitteTaSociete, 2-vaDansSociete »);
[Link](1);
}
societe = valideSociete(entreprise).toUpperCase();
}

Document Millésime Page

OFPPT @ [Link] novembre 08 13 - 29
Classe et Objet

14. Un ou plusieurs constructeurs ?

[Link] sur le premier constructeur
public Personne (String nom) {
// construit un objet Personne de nom invariable et de société inconnue
[Link] = [Link]();
societe = new String(« ? »);
}

Pour instancier l’individu Meunier, de la société Outils Java,il faut exécuter :

Personne p2 = new Personne(« Meunier »);

[Link](« Outils java »);

On peut souhaiter faire cette instanciation en une seule opération.

[Link] deuxième constructeur

public Personne (String nom, String entrep) {
// construit un objet Personne de nom fixe et de société connue
[Link] = [Link]();
societe = valideSociete(entrep).toUpperCase();
}

[Link] de signature
Pour le compilateur, il n’y a pas d’ambiguïté entre les deux constructeurs. Ainsi,
l’exécution de :
new Personne(« Meunier », « outils java »);

fait appel au deuxième constructeur car celui-ci utilise deux chaînes en paramètre.
Plus généralement, la signature d’un constructeur ou d’une méthode comprend son
identificateur, la liste et les types de ses paramètres. Le compilateur détermine la
méthode à exécuter en fonction de sa signature.
Des méthodes différentes peuvent porter le même nom, à partir du moment où leurs
signatures diffèrent.

15. Modificateurs static et final

[Link]éliorer la gestion des personnes sans société

class Personne {
private String pasDeSociete = “?”;
private String nom;
private String societe;
... // etc.
}

Document Millésime Page

OFPPT @ [Link] novembre 08 14 - 29
Classe et Objet

Quels reproches peut-on faire à cette implémentation ?

A un instant donné, il y aura autant d’exemplaires de la constante qu’il y a d’instances
existantes pour la classe Personne.
La variable pasDeSociete peut être modifiée par toute méthode de la classe.

[Link] variable de classe constante

class Personne {
private static final String pasDeSociete = “?”;
private String nom;
private String societe;
... // etc.
}

final ce modificateur impose que la définition comporte une valeur

d’initialisation et empêche toute affectation ultérieure d’une autre valeur. Il permet
de définir une information constante.

static ce modificateur indique que toutes les instances de la classe se

partageront un exemplaire unique : une variable de classe.

16. Variables et méthodes de classe

16.1.Définition
On peut parfois souhaiter disposer de données communes et accessibles à toutes les
instances d’une même classe.
Une variable permanente et unique pour toutes les instances d’une même classe
s’appelle une variable de classe.
Une méthode de classe représente un comportement associé à la classe elle-même
et non pas à une instance particulière de cette classe.
En Java, une variable de classe ou une méthode de classe, est définie avec le
modificateur static.
class Personne {
// variables de classe
private static final String pasDeSociete = « ? »;
private static String nomDuFichier;
// méthodes de classe
public static void choisirFichier() {
}
// etc.
}

Document Millésime Page

OFPPT @ [Link] novembre 08 15 - 29
Classe et Objet

[Link] d’utilisation
La classe System fournit une variable de classe publique, out, que l’on exploite dans
l’instruction suivante :
[Link](« utilisation du flux de sortie »);

Elle fournit également une méthode de classe publique exit :

[Link](0);

17. Comment exécuter une classe ?

17.1.Définir une classe
Toute application écrite en JAVA se trouve dans un fichier source [Link], dans lequel
on trouve la classe Nom :
Class Nom{
// variables de la classe privées ou publiques
// méthodes de la classe privées ou publiques
}

Pour qu’une classe puisse être exécutée, il faut qu’il y ait la fonction :
public static void main( String [] arg){
// code du programme
}

[Link]éer un exécutable : 3 solutions

La solution la plus simple consiste à créer une classe TestNom (qui créé une instance
de la classe Nom)ne comportant que la fonction main :
Class TestNom{
public static void main( String [] arg){
Nom monNom = new Nom(“toto”);
[Link](); // test des différentes méthodes
}

Une autre solution consiste à placer la fonction main() dans la classe Nom et à créer
une instance de la classe Nom dans la fonction main().
Class Nom{
// variables de la classe privées ou publiques
// méthodes de la classe privées ou publiques

public static void main( String [] arg){

Nom monNom = new Nom(“toto”);
[Link](); // test des différentes méthodes
}
}

Enfin il est possible de tester les méthodes de la classe, sans faire une instanciation
de la classe Nom. Il suffit de déclarer les méthodes en static (déconseillé en

Document Millésime Page

OFPPT @ [Link] novembre 08 16 - 29
Classe et Objet

général). Attention, des méthodes statiques ne peuvent manipuler que des variables
statiques.
Class Nom{
// variables statiques de la classe privées ou publiques
// méthodes statiques de la classe privées ou publiques

public static void main( String [] arg){

methode(); // test des différentes méthodes statiques
}
}

Il est possible d’appeler une méthode dans une méthode de la classe,

sans pour autant être obligé de déclarer cette méthode en static. Seule la
fonction main() demande cette condition.

[Link] un exécutable
Une fois le fichier source [Link] créé, il faut générer un fichier pseudo-exécutable
[Link] (commande javac nom .java) puis lancer cet exécutable : java nom. Il faut
pour cela avoir au préalable télécharger le jdk1.3 sur le site de http//[Link].

18. Récapitulons…
 Les variables d’instances sont généralement privées.

 L’instanciation d’une classe peut se faire de 2 façons :

si la classe ne comporte pas de constructeur : il y aura une initialisation par défaut ,
s’il existe un ou plusieurs constructeurs : on n’a plus le droit de faire appel au
constructeur par défaut (sauf si un constructeur est défini sans arguments).

 méthode d’instance : les méthodes sont publiques si elles doivent être appelées
de l’extérieur et privées si elles ne sont appelées que par des méthodes internes
à la classe.

 L’objet est un paramètre implicite de la méthode, accessible si nécessaire via la

notation this. Ainsi l’accés à une variable (ou à une méthode) se fait par variable
ou par [Link].

 Il est possible de créer des variables et méthodes de classe

définies avec le modificateur static
une méthode de classe ne dispose pas de la référence this

[Link] d’écriture
Jusqu’à présent, pour des raisons pédagogiques, nous avons personnifié les
messages et donné aux méthodes des identificateurs dont le libellé illustrait le
mécanisme : l’objet reçoit et traite le message :
tonNom, quitteTaSociete, etc.

Document Millésime Page

OFPPT @ [Link] novembre 08 17 - 29
Classe et Objet

Dans la pratique professionnelle, on utilise une forme moins personnifiée des

notations, en utilisant plutôt des verbes à l’infinitif
quitterSociete au lieu de quitteTaSociete
afficherEcran au lieu de presenteToi

[Link]
De même, pour les accesseurs, il est conseillé d’adopter les préfixes get et set :
getNom au lieu de tonNom, setSociete au lieu de vaDansSociete ;cette convention
est celle attendue par la technologie des JavaBeans, pour retrouver dynamiquement
ces accesseurs

19. Version finale de la classe Personne

class Personne {
private static final String pasDeSociete = “?”;
private String nom;
private String societe;

private String validerSociete(String sNom) {

// méthode-filtre : renvoie sNom s’il représente un nom de société acceptable
if ( [Link]() > 32 || [Link](« ? ») ) {
[Link](« classe Personne, société incorrecte : « + sNom);
sNom=societe ;
}
return sNom; // ici, on est sûr que sNom est valide
}
// deux constructeurs pour instancier
public Personne (String nom) { // construit un objet Personne de société inconnue
[Link] = [Link]();
societe = pasDeSociete;
}
public Personne (String nom, String entrep) {// construit un objet Personne de nom fixe et de société connue
[Link] = [Link]();
societe = validerSociete(entrep).toUpperCase();
}
// accesseurs en consultation
public String getNom() {
return nom;
}
public String getSociete() {
if ( [Link](“?”) )
return new String(“sans emploi”);
else return societe;
}
// accesseurs en modification
public void setSociete(String entreprise) {
societe = valideSociete(entreprise).toUpperCase();
[Link](« Changement de société ») ;
AfficherSurEcran() ;
}

public boolean etreSalarie() {

return ;
}

public void quitterSociete() {

if ( [Link](“?”) ) {
[Link](« impossible de quitter la société car sans emploi »);
}
else [Link](« Je quitte la societe : »+societe);
societe = « ? »; // car ici, on est sûr qu’il y a une société à quitter
afficherSurEcran();
}

Document Millésime Page

OFPPT @ [Link] novembre 08 18 - 29
Classe et Objet

// afficher les caractéristiques d’un objet

public void afficherSurEcran() {
[Link](« Je m’appelle « + nom);
if (!etreSalarie()) [Link](« Je ne suis pas employé d’une entreprise »);
else [Link](« Je travaille à « + societe);
}
} // class Personne, dernière version

20. Ecriture et exécution d’un programme

Java
[Link] types d’applications
Java permet d’écrire 2 types de programme :

 les applications autonomes (stand-alone), exécutées via un appel au système

d’exploitation,

 les applets, exécutées sous le contrôle d’un navigateur Web,,ou par l’intermédiaire
de l’appletViewer.

[Link] d’une application stand-alone

Exemple1 : programme [Link] (nom du fichier) avec exécution dans fenêtre
DOS.
class Personne {
// définition des variables

// définitions des méthodes

...
public static void main(String args[]) {
// méthode principale appelée au début de l’exécution
... // ici, tests élémentaires unitaires de Personne
}
} // class Personne

Exemple2 : programme [Link] (nom du fichier) , application windows.

import [Link].*;
import [Link].*;
import [Link].*;
import [Link].*;

public class ImageViewer extends Frame

Document Millésime Page

OFPPT @ [Link] novembre 08 19 - 29
Classe et Objet

{ public ImageViewer()
{ setTitle(“ImageViewer”);
MenuBar mbar = new MenuBar();
Menu m = new Menu(« Fichier »);
[Link](new MenuItem(“Ouvir”));
}
}

[Link] d’une applet

Exemple3 : programme [Link] (nom du fichier) ,

import [Link].*;
import [Link].*;
import [Link].*;

public class WelcomeApplet extends Applet

{ public void start()
{ setLayout(new BorderLayout());
Label l = new Label(getParameter(“greeting”),
[Link]);
[Link](new Font(“Times”, [Link], 18));
add(“Center”, l);
Panel p = new Panel();
[Link](new Button(“Bonjour”));
}
}

Après compilation le bytecode se trouve dans le fichier [Link].

Dans un fichier [Link] ou [Link] il suffit de placer le code :
<HTML>
<TITLE>WelcomeApplet</TITLE>
<HR>
Essai de [Link]
<A HREF= »[Link] »>
Core Java</A>

<APPLET CODE=[Link] WIDTH=200 HEIGHT=200>

<PARAM NAME=greeting VALUE=”Welcome to Core Java!”>
</APPLET>

<HR>
<A href= »[Link] »>Voir le source de [Link].</A>

21. Une classe usuelle : la classe String

La classe String a déjà été utilisée dans les programmes, 2 caractéristiques
essentielles :

 La classe String permet la manipulation de chaînes de caractères.

 Les objets String sont constants.

Document Millésime Page

OFPPT @ [Link] novembre 08 20 - 29
Classe et Objet

21.1.Définition d’une chaîne de caractères

String maChaine, uneAutre;
maChaine = « voici une chaîne »; uneAutre = « en voilà une autre »;
String maChaine2 = new String(« voici une chaîne »);

[Link] et accès aux caractères

La méthode length() fournit la longueur d’une chaîne de caractères.
La méthode charAt() renvoie un caractère de rang donné
String maChaine = « voici une chaîne »;
int lgrMaChaine = [Link]();
char carac = [Link](0); // carac prend la valeur ‘v’

[Link]
La méthode equals() permet de comparer deux chaînes.
String chaine1= »voici une chaîne »; String chaine2= »et une autre »;
if([Link](chaine2)) [...] else [...]

[Link] méthodes :
String chaine1 = « voici une chaîne « ;
String chaine2 = [Link](2,5);
// extraction de sous-chaîne : chaine2 vaut « ici »
// [Link](deb, fin+1) pour obtenir les caractères de rangs deb à fin
String chaine3 = [Link]().toUpperCase();
// écrémage puis majuscule : chaine3 vaut « VOICI UNE CHAÎNE »
String chaine4 = [Link](‘i’,’?’);
// remplacement des occurences d’un caractère : chaine4 vaut « vo?c? une
chaîne «
int rangDeH = [Link](‘h’);
// rangDeH vaut 11, (-1 si la lettre était absente de chaine1)
String chaine5 = [Link](20.6);
// représentation d’une valeur numérique sous forme de chaîne (méthode de
classe)

22. Importations
[Link] packages
Des librairies de classes appelées packages standard peuvent être utilisées afin
d’accéder à des classes d’utilité générale :
[Link] : String, StringBuffer, Math, System...Ce package est importé par
défaut.
[Link], [Link], [Link], ... qui doivent être importés explicitement.

Document Millésime Page

OFPPT @ [Link] novembre 08 21 - 29
Classe et Objet

[Link] d’importation
import [Link]; Permet l’utilisation de la classe Date
import [Link].*; Permet l’utilisation de toutes les classes des deux packages util et
io.
import [Link].*;
Si une classe n’est pas trouvée, elle sera recherchée dans les packages importés.
Les instructions d’importation doivent se trouver en tête du fichier.
L’accès aux classes peut se faire sans importation mais au prix d’une plus grande
complexité d’écriture :
[Link] uneDate = new [Link]();

au lieu de :
import [Link].*;
Date uneDate = new Date();

23. Exercices :
1/Classe point: Créer la classe point pour manipuler des points d’un plan (abscisse,
ordonnée), définir un constructeur et une fonction membre affiche qui donne les
coordonnées d’un point, les coordonées du point sont privées. Les coordonnées d’un
point sont des entiers compris entre –999 et 999.
Définir la fonction membre float norme(point) qui permet de calculer la norme du
vecteur constitué du point courant et du point passé en paramètre.
Définir 4 constructeurs : un constructeur par défaut sans argument (met à 0 l’abscisse
et l’ordonnée) un constructeur avec 1 argument et un constructeur avec 2 arguments
et le constructeur Point (Point p )
Définir la fonction boolean equals(Point p) pour tester la coincidence de 2 points.
Définir la fonction void translate(int dx, int dy)qui fait changer l’abscisse (x + dx) et
l’ordonnée (y+dy).
Definir la fonction void setLocation(double,double) (utiliser la fonction
[Link](double) pour arrondir la valeur à l’entier).
Définir les fonction void setLocation(Point p) et void setLocation(int x, int y);
Définir la fonction String toString() qui renvoie les coordonnées du point.
Définir la fonction void move(int x, int y) qui donne les nouvelles valeurs du point.
Définir la fonction double distance(int x, int y) et double distance (Point p) permettant
de calculer la distance entre le point courant et les coordonnées passées en arguments.
public class Point {
private int x;
private int y;
public static void main(String[] args) {
Point p1 = new Point( 3, -21 );
Point p2 = new Point( 1, 4 );

Document Millésime Page

OFPPT @ [Link] novembre 08 22 - 29
Classe et Objet

//Tester les méthodes de Point

// Pour afficher la norme sous la forme [Link] double x = norme(p1);
//on pourra utiliser la ligne suivante :
// DecimalFormat arrondi = new DecimalFormat( “0.00” ); [Link](x);

2/ La classe MaString
On désire faire une classe chaîne de caractères. Pour cela, il existe 2 solutions
possibles :
La première solution consiste à utiliser une chaîne à 0 terminal comme c’est le cas en C
par exemple.
La deuxième solution que nous allons utiliser se sert de la notion de tableau en Java.
Un tableau de caractères en Java se défini comme :
char value[ ] = new char [10]; // il est possible d’utiliser [Link] pour
connaître la taille du tableau
La classe MaString a donc les champs suivants :
Class MaString {
private char [] value ; // tableau de caractères
private int count ; // longueur de la chaine de caractères
private int offset ; // offset sur le caractère courant
//methods de la class MaString
}

a/ Ecrire les constructeurs de la classe MaString :

On définira tout d’abord le constructeur par défaut de la classe MaString(taille par
défaut de 10 chars)
public MaString() {
value = new char[10];
offset=0;
count= [Link];
}

Ecrire le code du constructeur MaString(int count)

MaString(char [ ] value); // initialise la chaine avec un tableau de caractère
MaString(MaString s) ; // initialise la chaine avec la classe s
MaString(byte [ ] byte) // initialise la chaine avec un tableau de byte que l’on caste
en tableau de char

b/ On donne ci-dessous les accesseurs de la classe MaString : expliquer le but de ces

accesseurs
public int length() {
return count;
}
public char [ ] getChars() {
return value ;
}

Document Millésime Page

OFPPT @ [Link] novembre 08 23 - 29
Classe et Objet

c/ On désire écrire la fonction copyValueOf qui permet de copier un tableau de

caractères dans la classe MaString :
public static MaString copyValueOf(char data[]) {
return copyValueOf(data, 0, [Link]);
}

Ecrire la fonction MaString copyValueOf(char data[], int offset, int count) qui renvoie
une reference sur MaString.
Expliquer l’intérêt de définir ces méthodes comme statique.
Expliquer ce que fait la méthode ci-dessous :
public static String valueOf(char c) {
char data[] = {c};
return new String(0, 1, data);
}

d/Ecrire la méthode public static MaString valueOf(byte i) qui permet de renvoyer une
chaine image de la valeur entrée. Pour cela on pourra se rappeler que un byte est
compris entre –128 et +127. On doit renvoyer une chaine de caractères égale à « -
128 » et « 127 ».
e/ expliquer ce que fait la méthode ci-dessous :
public char charAt(int index) {
if ((index < 0) || (index >= count)) {
[Link](“indexe en dehors des limites”);
}
return value[index + offset];
}

f/ Ecrire la méthode public String concat(String str) qui permet de faire la

concaténation de la chaine courante avec la chaine str.
g/ Ecrire la fonction public boolean equals(MaString s) qui vient comparer les chaines s
et this.
h/ Expliquer ce que fait la méthode ci-dessous :
public int compareTo(MaString anotherString) {
int len1 = count;
int len2 = [Link];
int n = [Link](len1, len2);
char v1[] = value;
char v2[] = [Link];
int i = offset;
int j = [Link];

while (n-- != 0) {
char c1 = v1[i++];
char c2 = v2[j++];
if (c1 != c2) {
return c1 - c2;
}
}
return len1 - len2;
}

i/ Ecrire la méthode public int indexOf(int ch, int fromIndex qui retourne la valeur de
l’indexe à partir duquel le caractère a été trouvé et retourne –1 si aucun caractère n’a
été trouvé. La recherche commence à partir de fromIndex. En déduire ce que fait la

Document Millésime Page

OFPPT @ [Link] novembre 08 24 - 29
Classe et Objet

fonction ci-dessous :
public int indexOf(int ch) {
return indexOf(ch, 0);
}

j/ Ecrire la fonction public String substring(int beginIndex, int endIndex)); qui permet
de renvoyer la chaine courante commençant à l’indexe beginIndex et finissant à
endIndex.
k/ Ecrire la fonction public String toString()
l/ Ecrire les methods MaString toLowerCase() et toUpperCase() ; qui renvoient
respectivement les chaines en minuscules et en majuscules.
3/ Soit le programme ci-dessous : fichier [Link]
public final class carte
{
private int couleur;
private int valeur;

public static final int AS = 1;

public static final int VALET = 11;
public static final int DAME = 12;
public static final int ROI = 13;
public static final int PIQUES = 1;
public static final int CARREAUX = 2;
public static final int COEURS = 3;
public static final int TREFLES = 4;

public carte(int v, int s)

{ valeur = v;
couleur = s; }
public int getValeur()
{ return valeur;}

public int getCouleur()

{ return couleur; }

public int rank()

{ if (valeur == 1) return 4 * 13 + couleur;
else return 4 * (valeur - 1) + couleur;
}

public String toString()

{ String v;
String s;
if (value == ROI) v = “Roi”;
else if (value == DAME) v = “Dame”;
else if (value == VALET) v = “Valet”;
else if (value == AS) v = “As”;
else v = [Link](valeur);
if (couleur == CARREAUX) s = « Carreaux »;
else if (couleur == COEURS) s = “Coeurs”;
else if (couleur == PIQUES) s = “Piques”;
else couleur == TREFLES s = « Trefles »;
return v + « de » + s;
}
}

Commenter ce programme.
On désire créer un jeu de carte qui se serve de la classe carte. Pour cela on créer la
classe jeuxCarte qui contiendra la fonction main. Ecrire la fonction rempli() qui rempli le
tableau de carte nommé jeu.

Document Millésime Page

OFPPT @ [Link] novembre 08 25 - 29
Classe et Objet

A la sortie de la fonction jeu[0]=carte(1,1) jusqu’à jeu[51]=carte(13,4)

La fonction distribue(), utilisera la fonction [Link]() qui renvoie un
double compris entre 0.0 et 1.0 pour trouver l’indice de jeu qui correspond à joueur et
celui qui correspond à PC.
Le programme principal fera 10 parties en affichant à chaque fois qui à gagné et à la fin
comptabilisera le nombre de parties gagnées par le jouer et le nombre de parties
gagnées par le PC.
public class jeuxCarte
{ private carte[] jeu;
private carte joueur, PC;
private int cards;
public jeuCarte()
{ jeu = new Carte[52];
rempli();
distribue();}

public static void main(String[] args)

{ jeuxCarte d = new jeuxCarte();
// Acompléter
}
}

Document Millésime Page

OFPPT @ [Link] novembre 08 26 - 29
Classe et Objet
Pour approfondir le sujet….
Proposition de références utiles permettant d’approfondir le thème abordé

Sources de référence
Citer les auteurs et les sources de référence utilisées pour l’élaboration du
support

Document Millésime Page

OFPPT @ [Link] novembre 08 27 - 29