Page 1 sur 46

COURS DE PROGRAMMATION ORIENTEE OBJET

EUSEBIO Claude Olakiitan

Cel : 90325987 / 99315812

[email protected]

Notion de classe et d’objet

1. Définition de classe

Une classe est un type.

Exemple :

nom de la classe VOITURE

propriété Numéro
Nom
Couleur

Rouler ()
méthode

En Java, une propriété devient un champ et une méthode devient une fonction.

2. Définition d’un objet

Un objet est une occurrence de la classe.

Un objet est une instance de la classe.

Lorsqu’on instancie une classe, on obtient un objet.

Exemple :

Mavoiture (1717, peugeot, grise).

Mavoiture est un objet de la classe voiture.

 Page 2 sur 46

Les méthodes sont invoquées pour changer l’état d’un objet.

3. Communication entre objets

En POO les objets communiquent entre eux par l’envoi des messages. Un objet peut envoyer
de message à lui-même ou à un autre objet.

L’état d’un objet peut changer lorsque cet objet invoque une de ses méthodes.

4. Concept de POO

Un langage est de type orienté objet lorsqu’il utilise les concepts suivants :

-classe

-objet

-objets communiquant entre eux par l’envoi de messages.

-Encapsulation

-Agrégation

-Héritage et le polymorphisme.

5. Différence entre la programmation procédurale et POO

En POO, les données et les fonctions sont regroupées dans un module appelé classe ; ce qui
rend la maintenance facile par rapport à la programmation procédurale dans laquelle les
données au lieu d’être regroupées par classe avec leurs fonctions, sont groupées ensemble, de
même que les fonctions sont le sont aussi. Autrement, les données et les fonctions ne sont pas
modularisées dans des classes, mais sont mélangées ensembles.

Dans la programmation procédurale, les données de chaque entité ne sont pas structurées
ensemble avec leur fonction. Ce qui rend la maintenance difficile.

6. Quelques langages de type POO

- Java
- C#
- C++
- VB.NET
- …
 Page 3 sur 46

Généralités

1. Premier programme :

public class PremProg{

public static void main(string args[])

{
System.out.println(‘‘mon premier programme’’) ;

Par convention en Java le nom des classes commence par une lettre majuscule.

Enregistrez dans PremProg.java

La compilation de code en Java donne un fichier d’extension .class…Dans ce cas on aura :

PremProg.class (à la compilation).

Pour exécuter :

Compilation : javac PremProg.java

Exécution : java PremProg

Exercice1

Résoudre une équation du second degré ax2+bx+c avec a différent de 0.

a,b et c doivent être saisies.

Pour la saisie utilisez la méthode exposée sur le site du zéro.

Exercice 2

Programme permettant de calculer la suite Un=Somme i allant de 1 à n de 1/i2.

 Page 4 sur 46

2 – Le bytecode

Bytecode Résultat
Code

La compilation d’un code en java ne donne pas un code binaire comme en C mais un
bytecode.

JVM (Java Virtual Machines). Java est un langage portable sur différentes plateformes.
Autrement une fois compilé ; le bytecode est interprété sur différentes plateformes par le JVM
(Java Virtual Machine).

Les types primitifs

1 – Type entier :

Byte (octet) varie de -128 à 127

2 – Type flottant :

3 – Type caractère :

4– Type booléen :

Ce type à 2 valeurs possibles :

 True
 False
Exemple : Boolean a ;
 Page 5 sur 46

5 – Déclaration de constante :

final int N ;

N = 18 ;

N++ ; //erreur

final int p = 30 ;

LES OPERATEURS ET LES

EXPRESSIONS

LES INSTRUCTIONS DE
CONTROLES DE JAVA

1 – L’instruction continue ordinaire :

Il permet de passer prématurément à la boucle suivante :

 Page 6 sur 46

public class contin1

public static void main (String args[])

int i;

for(i = 1; i <= 5; i++)

System.out.println(“debut tour ”, +i);

if (i < 4) continue;

System.out.println(“fin tour” +i);

System.out.println(“Après la boucle”);

DES CLASSES ET DES

OBJETS

1 – Exemple :

public class Point

{

private int x, y ;

public void initialise (int abs, int ord) // 4, 7

{

x = abs ;// x = 4
y = ord ;// y = 7
 Page 7 sur 46

}
public void deplace (int dx, int dy)//(2,1)
{

x += dx ;//x = 6
y += dy ;//y = 8
}
public void affiche ()
{

System.out.println ("Je suis un point de coordonnees " + x + " " + y) ;

}
}

public class TstPoint

{

public static void main (String args[])

{

Point a ;//declaration d’une variable de type class

a = new Point() ;
a.initialise(4, 7) ;
a.affiche() ;
a.deplace(2, 1) ;
a.affiche() ;
Point b = new Point() ;
b.initialise (1, 5) ;
b.affiche() ;

System.out.println(‘’valeur de x :’’ + a.x) ;//erreur

}
}

« a » est un pointeur sur l’objet crée donc en java « a » est une référence sur l’objet créé
parce que « a » contient l’adresse de l’objet.

Par abus de langage on dit parfois que a est un objet (réellement l’objet est : new Point()).

Un membre private ne peut être utilisé qu’à l’intérieur de sa classe.

Un membre public peut être utilisé directement dans n’importe quelle autre classe.
 Page 8 sur 46

2 – Le constructeur

Un constructeur est généralement utilisé pour donner de valeur initiale à l’objet créé. En java
un constructeur porte le même nom que la classe et n’a pas de type de retour. Un constructeur
est une méthode particulière.

Exemple :

package rectangle;
public class Rectangle {
private int L, l;

public Rectangle(int x, int X) {

l = x; constructeur
L = X;
}

public void affichage(){

System.out.println("Longueur du rectangle : " +L+ " Largeur : " +l);
}

public long aire(){

long aire = L*l;
return aire;
}

public int perimetre(){

int perimetre = (L+l)*2;
return perimetre;
}
}

package rectangle;
public class TestRectangle {
public static void main(String[] args){
Rectangle rec = new Rectangle(4, 5); constructeur
rec.affichage();
System.out.println("Aire = " +rec.aire());
System.out.println("Perimetre = " +rec.perimetre());
}

Un constructeur par défaut est un constructeur sans argument. Lorsqu’il n’y a aucun
constructeur dans la classe pour créer un objet le compilateur nous fournit un constructeur par
défaut.
 Page 9 sur 46

Dès qu’il y a un constructeur dans la classe le compilateur n’aide plus et c’est au

développeur d’écrire tous les constructeurs dont il a besoin.

3 – Initialisation par défaut des champs d’un objet :

Type du champ Valeur par défaut

Boolean False
Char Caractère de code nul
Entier 0
Flottant O.f ou 0.
Objet Null

4 – Utilisation de this :

This représente l’objet courant.

Exemple:

package rectangle;
public class Rectangle {
private int larg, l;

public Rectangle(int l, int la) {

this.l = l;
this.larg = la;
}

public void affichage(){

System.out.println("Longueur du rectangle : " +l+ " Largeur : " +larg);
}

public long aire(){

long aire = larg*l;
return aire;
}

public int perimetre(){

int perimetre = (larg+l)*2;
return perimetre;
}

public void afficher(){

System.out.println("Aire = " +this.aire());
System.out.println("Perimetre = " +perimetre());
}
 Page 10 sur 46

package rectangle;
public class TestRectangle {
public static void main(String[] args){
Rectangle rec = new Rectangle(4, 5) ;
rec.affichage();
System.out.println("Aire = " +rec.aire());
System.out.println("Perimetre = " +rec.perimetre());
}

5 – Surcharge ou surdéfinition :

On parle de surcharge lorsque les méthodes portent le même nom et diffèrent :

 Soit par le nombre d’argument

 Soit par le type d’argument

6 – Encapsulation :

Le processus d’encapsulation demande à ce que les champs ou les données soient

protégés (private, protected) on passe alors par le service des méthodes (public) pour accéder
ou modifier ces champs.

7 – Accesseur (get) et mutateur (set):

a – Accesseur :

Les méthodes d’accès fournissent des informations relatives à l’information d’un

objet, c’est-à-dire aux valeurs de certains de ces champs (généralement privés) sans les
modifier.

public int getLargeur()

{
Return largeur;
}

public int getLongueur()

{
return longueur;
}
 Page 11 sur 46

b – Mutateur :

Un mutateur modifie l’état d’un objet c’est-à-dire modifie la valeur de certains de ces champs.

Exemple:

Public void setLargeur(int larg)

{
this.largeur = larg;
}

Public void setLongueur(int l)

{
Longueur = l;
}

Public void setLongueurLargeur(int x, int y)

{
longueur = x;
largeur = y;
}

8 – Affectation et comparaison d’objets :

Exemple :

Rectangle a = new Rectangle (1, 3); deux objets différents

Rectangle b = new Rectangle (1,3) ; a et b sont des références

et : new rectangle(1,3) est un objet

b = a ;  b fait référence à l’objet sur lequel pointe a par conséquent l’objet de la référence b
n’est plus utilisé ( il est détruit par les ramasse-miette : garbage collector).

Remarque : En java Garbage Collector ou ramasse-miettes s’occupe de la destruction

d’objets inutilisés.

NB : On peut créer un objet sans référence.

Exemple : new Rectangle(4, 5).affichage() ;

Exercice :
 Page 12 sur 46

Banque
-Solde
- …. Test
- ….
- ….
?Créditer( ?)
?Débiter( ?)
?Afficher( ?)

Contenant les notions suivantes :

1- Constructeur
2- Accesseur, mutateur
3- This

9 – La notion de clone :

class Point
{
private int x, y ;
public Point(int abs, int ord)
{
x = abs ;
y = ord ;
}
public Point copie () // renvoie une référence à un Point
{
Point p = new Point(x, y) ;
p.x = x ;
p.y = y ;
return p ;
}
-------------------------
}
------------------------
Point a = new Point(7,3) ;
Point b = a.copie() ;
-------------------------

Remarque :

L’expression a==b est vraie uniquement si a et b font référence à un seul objet.

10 – champ et méthode de classe :

 Page 13 sur 46

On peut définir des champs qui au lieu d’exister dans chacune des instances de la
classe, n’existent qu’en un seul exemplaire pour toutes les instances d’une même classe.
On parle alors de champ de classe ou champ statique.

De même on peut définir des méthodes de classe ou méthodes statique qui peuvent
être appelés indépendamment de tout objet de classe.

a – champ de classe :

Class A
{
int n; a1.n a2.n
float y; ------------- -------------
}
a1.y a2.y
A a1 = new A() ;//objet1
A a2 = new A() ;//objet2

Class B
{
static int n;
float y; b1.n =b2.n
}
B b1 = new B() ;//objet1 b1.y b2.y
B b2 = new B() ;//objet2

Les champs de classe n’existent qu’en un seul exemplaire quel que soit le nombre d’objets de
la classe. En fait ce champ existe indépendamment de tout objet de sa classe.

b - Méthode de classe :

Une méthode de classe a un rôle indépendant d’un quelconque objet. L’appel de la

méthode statique se fait : nomClasse.méthodeStatique().

Si on écrit Objet.méthodeStatique, le code marchera. Mais c’est déconseillé.

Une méthode de classe ne pourra en aucun cas agir sur un champ statique. Une méthode serait
déclarée statique lorsqu’on ne veut pas créer un objet avant de l’utiliser. On ne peut pas
utiliser this à l’intérieur d’une méthode statique.

class Obj
{
public Obj()
{
 Page 14 sur 46

System.out.print ("++ creation objet Obj ; ") ;

nb ++ ;
System.out.println ("il y en a maintenant " + nb) ;
}
public static long nbObj ()
{
return nb ;
}
private static long nb=0 ;
}

public class TstObj2

{
public static void main (String args[])
{
Obj a ;
System.out.println ("Main 1 : nb objets = " + Obj.nbObj() ) ;
a = new Obj() ;
System.out.println ("Main 2 : nb objets = " + Obj.nbObj() ) ;
Obj b ;
System.out.println ("Main 3 : nb objets = " + Obj.nbObj() ) ;
b = new Obj() ;
Obj c = new Obj() ;
System.out.println ("Main 4 : nb objets = " + Obj.nbObj() ) ;
}
}

Java permet d’introduire dans la définition d’une classe un ou plusieurs blocs d’instructions
précédées du mot static. Les blocs d’initialisation statique présente un intérêt lorsque
l’initialisation des champs statiques ne peut être faite par une simple expression.

class A
{ private static int t[] ;
..........................................
static
{ .....................................
int nE1= sc.nextInt() ;
t = new int[nE1] ;
for (int i=0 ; i<nE1 ; i++)
t[i] = i ;
}
..............................;
}

11- Echange d’information avec les méthodes :

a- Java transmet toujours les informations par valeurs :

 Page 15 sur 46

class Util
{
public static void Echange (int a, int b) // ne pas oublier static
{
System.out.println ("début Échange : " + a + " " + b) ;
int c;
c = a;
a = b;
b = c;
System.out.println ("fin Échange : " + a + " " + b) ;
}
}

public class Echange

{
public static void main (String args[])
{
int n = 10, p = 20 ;
System.out.println ("avant appel : " + n + " " + p) ;
Util.Echange (n, p) ;
System.out.println ("apres appel : " + n + " " + p) ;
}
}

avant appel : 10 20
debut Échange : 10 20
fin Échange : 20 10
apres appel : 10 20

b- Transmission de la référence d’un objet ou simulation d’un passage par adresse :

class Point
{
public Point(int abs, int ord)
{
x = abs ; y = ord ;
}
public void permute (Point a) // méthode d’Échange les coordonnées
// du point courant avec celles de a
{
Point c = new Point(0,0) ;
c.x = a.x ; //5
c.y = a.y ; //6 // copie de a dans c
a.x = x ; //1
a.y = y ; //2 // copie du point courant dans a
x = c.x ;
y = c.y ; // copie de c dans le point courant
}
 Page 16 sur 46

public void affiche ()

{
System.out.println ("Coordonnees : " + x + " " + y) ;
}
private int x, y ;
}

public class Permute

{
public static void main (String args[])
{
Point a = new Point (1, 2) ;
Point b = new Point (5, 6) ;
a.affiche() ;
b.affiche() ;
a.permute (b) ;
a.affiche() ;
b.affiche() ;
}
}

12- Appel d’un constructeur au sein d’un autre constructeur de la même classe :

On peut utiliser this pour faire appel à un constructeur de la classe.

Exemple :
class Point
{
private int x, y;
public Point(int abs, int ord)
{
x = abs;
y = ord;
}
public Point()
{
this(3,4); //utilisation de this doit être la première instruction du constructeur
System.out.println("constructeur sans argument");
}
}

13- Récursivité :
C’est quand une méthode appelle elle -même.

14- Objet membre :

 Page 17 sur 46

On parle d’objet membre lorsque le champ d’une classe est une référence à un objet. C’est
une composition ou une agrégation particulière.

Exercice :
Une classe CompteEpargne appelée Compte et une classe Banque ayant :
 Un objet membre de type compte
 Un constructeur qui appelle en son sein un autre constructeur de Banque
 Champ de classe
 Méthode de classe
 Méthode de copie des valeurs d’un objet
Test pour tester Banque.

14- Classe interne :

Une classe est dite interne lorsque sa définition est située à l’intérieure de la définition
d’une autre classe.

Exemple :

class A
{
------------------
------------------
Class B
{
-----------------
-----------------
}
-------------------
-------------------
}

Remarque:

 Un objet d’une classe interne est toujours associé, au moment de son instanciation,
à un objet d’une classe externe dont on dit qu’il lui a donné naissance.
 Un objet d’une classe interne à toujours accès aux champs et méthodes même
privée de l’objet externe lui ayant donné naissance.
 Un objet de classe externe à toujours accès aux champs et méthodes même privée
d’un objet de classe interne dont il a donné naissance.
 Une classe interne ne peut pas contenir de membre static

Exercice :
Créer une classe Banque ayant une classe interne Compte. Tester la classe Banque.

19- Package :
 Page 18 sur 46

La notion de package correspond à un regroupement logique sous un identificateur commun

d’un ensemble de classes.
package nomPackage ;
En l’absence d’instruction package, le compilateur considère que la classe correspondante
appartienne au package par défaut.

Pour utiliser une classe appartenant à un autre package on peut :

 Citer le nom du package avec le nom de la classe
 Ou utiliser une instruction import en y citant soit une classe particulaire d’un package
soit tout un package.

Exemple :

 En citant le nom de la classe :

exo.A a = new exo.A() ;

exo = nom package
A = nomclasse

 En important une classe :

import exo.A

 En important un package :

package dos3;
import dos2.A;
import dos2.dos1.*;//ou import dos2.dos1.B ou encore import dos2.dos1.C
classD
{
-------------
-------------
}

LES TABLEAUX

1- Déclaration et définition d’un tableau :

int t[] ; // t est destinée à contenir la référence à un tableau d’entiers

t = new int [4] ;

 Page 19 sur 46

les deux donnent :

int [] t = new int [4] ;

Déclaration et initialisation en même temps d’un tableau :

int tab[]={18,3,-5,0,16,23,56};

tab[3]=0;

Exemple :

Banque [] ban = new Banque[3];

ban[0] = new Banque (500000);

ban[1] = new Banque (25000);

ban[2] = new Banque (110000);

2- Affectation de tableau :

int [] tab = new int[4];

for (int i = 0; i < 4; i++)
{
tab[i] = i;
}
int [] t = new int[3];
for (int i = 0; i < 3; i++)
{
t[i] = 2*i + 10;
}

3- Champ length :

Le champ length nous donne la taille d’un tableau.

for (int i = 0; i < t.length; i++)

{
t[i] = 2*i + 10;
}

4- Tableau en argument ou en retour :

 Page 20 sur 46

public class TabArg

{
public static void public static void main(String[] args) {
int t[] = {1,3,5,7};
System.out.print("t avant : ");
Util.affiche(t); //au moment de l’appel on met juste la référence
Util.raz(t);
System.out.print("\n apres : ");
Util.affiche(t);
}
}

class Util
{
static void raz(int t[]) //un tableau en argument n’a pas de taille
{
for(int i = 0; i < t.length; i++)
{
t[i] = 0;
}
}
static void affiche(int t[])
{
for (int i = 0; i < t.length; i++)
{
System.out.println(t[i] + " ");
}
}
}

Exercice :
Complétez le code en écrivant une fonction qui retourne l’inverse du tableau.

5- Tableau à plusieurs indices :

a- Exemple
Ces 3 déclaration sont les mêmes
int t[][];
int []t[];
int [][]t;

int t[][] = {new int [3], new int[4], new int[2]} :

t est une référence à un tableau dans lequel chaque élément est lui-même une référence à un
tableau entiers.
 Page 21 sur 46

b- Initialisation :

int [][]t = {{12,-3},{4,11,27,32},{64,18}}

T[1][1] = 11

6- La boucle for each :

double t[];
for (double v:t)
{
System.out.println(v); //le tableau sera parcouru en lecture par la variable
}
for (int i = 0; i < t.length; i++)
{
System.out.println(""+ t[i]) ;
}

Héritage et Polymorphisme
 Page 22 sur 46

1- Exemple :

Classe mère ou super class

Figure
#nomFigure
+calculerPerimetre()
+calculerSurface()

Classes filles ou
Rectangle classes dérivées Cercle
-longu : double -ray : double
-larg : double +calculerDiamètre()
+calculerDiagonale()

+  public

-  private

#  protected

La classe mère est une classe généralisée, celle de la classe fille est une classe spécialisée.

On vérifie la compatibilité en utilisant le verbe être (exemple : le rectangle est une figure).

2- Implémentation :

public class Figure

{
protected String nomFig;
public Figure(String nomFig)
{
this.nomFig = nomFig;
}
public void calculerPerimetre()
{
System.out.println("Périmètrede" +nomFig+ "est : ");
}
public void calulerSurface
{
System.out.println("Surface de " +nomFig+ "est : ");
}
}
 Page 23 sur 46

public class Rectangle extends Figure

{
private double longu, larg;
public Rectangle(String nomFig, double longu, double larg)
{
super(nomFig);
this.longu = longu;
this.larg = larg
}
public void calculerPerimetre()
{
super.calculerPerimetre();
System.out.println(" " +2*(longu + larg));
}
public void calulerSurface()
{
super.calulerSurface();
System.out.println(" " +(longu * larg));
}

public void calculerDiagonale()

{
System.out.println("Le diagonale de " +nomFig+ "est : "
+Math.sqrt(Math.pow(longu,2) + Math.pow(larg,2)));
}

public class Cercle extends Figure

{
private double ray;
public void Cercle(String nomFig, double ray)
{
super(nomFig);
this.ray = ray;
}
public void calculerPerimetre()
{
super.calculerPerimetre();
System.out.println(" " +2*Math.PI.ray);
}
public void calulerSurface()
 Page 24 sur 46

{
super.calulerSurface();
System.out.println(" " +Math.PI*Math.pow(ray,2));
}
public void calculerDialetre()
{
System.out.println("Le diamètre de " +nomFig+ "est : " +2*ray);
}
}
public class Test
{
public static void main (String args [])
{
Figure [] tab = new Figure[3];
Rectangle r1 = new Rectangle("Rectangle", 5.0, 2.0);
Cercle c = new Cercle("Cercle", 3.0);
Rectangle r2 = new Rectangle("Rectangle", 4.0, 1.0);
tab[0] = r1;
tab[1] = c;
tab[2] = r2;
for (int i = 0; i < tab.length; i++)
{
tab[i].calculerPerimetre();
tab[i].calulerSurface();
}
r1.calculerDiagonale();
c.calculerDiametre();
}
}

3- Commentaire :
On utilise extends pour signifier que la classe fille dérive de la classe mère.
Chaque classe doit construire son objet.
 On utilise le mot clé super pour appeler le constructeur de la classe mère.
 super doit être la première instruction dans le constructeur de la classe fille.
 Lorsque la fonction existe dans la classe mère et que son corps ou sa définition
est modifié dans la classe fille on parle de redéfinition ou overwriting
 Dans la classe fille la fonction redéfinie masque celle de la classe mère

Le polymorphisme en java se traduit par :

 La compatibilité par affectation entre un type classe et un type ascendant

 La ligature dynamique des méthodes au moment de l’exécution.
 Page 25 sur 46

Une méthode polymorphe doit exister dans la classe mère et doit être redéfinie dans les
classes filles.

4- Classe abstraite :

Une classe abstraite est une classe qu’on ne peut pas instancier.

 Dès qu’une classe comporte au moins une méthode abstraite elle est abstraite.
 Une méthode abstraite doit obligatoirement être déclarée public.

Exemple :

public abstract class Figure

{
protected String nomFig;
public Figure(String nomFig)
{
this.nomFig = nomFig;
}
public abstract void calculerPerimetre() ;

public void calulerSurface

{
System.out.println("Surface de " +nomFig+ "est : ");
}
}

public class Rectangle extends Figure

{
private double longu, larg;
public Rectangle(String nomFig, double longu, double larg)
{
super(nomFig);
this.longu = longu;
this.larg = larg
}
public void calculerPerimetre()
{
System.out.println("perimetre de " +nomFig+ "est : ");
System.out.println(" " +2*(longu + larg));
}
public void calulerSurface()
 Page 26 sur 46

{
super.calulerSurface();
System.out.println(" " +(longu * larg));
}

public void calculerDiagonale()

{
System.out.println("Le diagonale de " +nomFig+ "est : "
+Math.sqrt(Math.pow(longu,2) + Math.pow(larg,2)));
}

public class Cercle extends Figure

{
private double ray;
public void Cercle(String nomFig, double ray)
{
super(nomFig);
this.ray = ray;
}
public void calculerPerimetre()
{
System.out.println("perimetre de " +nomFig+ "est : ");
System.out.println(" " +2*Math.PI.ray);
}
public void calulerSurface()
{
super.calulerSurface();
System.out.println(" " +Math.PI*Math.pow(ray,2));
}
public void calculerDialetre()
{
System.out.println("Le diamètre de " +nomFig+ "est : " +2*ray);
}
}
public class Test
{
public static void main (String args [])
{
Figure [] tab = new Figure[3];
Rectangle r1 = new Rectangle("Rectangle", 5.0, 2.0);
 Page 27 sur 46

Cercle c = new Cercle("Cercle", 3.0);

Rectangle r2 = new Rectangle("Rectangle", 4.0, 1.0);
tab[0] = r1;
tab[1] = c;
tab[2] = r2;
for (int i = 0; i < tab.length; i++)
{
tab[i].calculerPerimetre();
tab[i].calulerSurface();
}
r1.calculerDiagonale();
c.calculerDiametre();
}
}

5- Interface :

Une interface est constituée de méthode sans corps et quelques fois de constante.

Exemple :

public interface Personne

{
public void afficherPersonne();
}

public class Celibataire implements Personne {

private String nom;
private int age;
public Celibataire(String nom, int age)
{
this.nom = nom;
this.age = age;
}

public void afficherPersonne()

{
System.out.println("Je suis une peersonne du nom de " +nom+ "Je suis age de " +age);
System.out.println("Je suis celibataire");
}
}

public class Marie {

private String nom;
 Page 28 sur 46

private int age;

private String nomConj;

public Marie(String nom, int age, String nomConj)

{
this.nom = nom;
this.age = age;
this.nomConj = nomConj;
}

public void afficherPersonne()

{
System.out.println("Je m'appelle " +nomPersonne+ "jesuis age de " +age+ "et je suis
marié à " +nomConj);
}

6- La super-classe objet :

En réalité il existe une classe nommée objet dont dérive implicitement toute classe simple.

 Utilisation de la méthode equals de objet :

objet a = new objet(4,3);

objet b = new objet(4,3);
a.equals(b); //donne false

equals dans objet compare la référence.

Une classe déclarée final ne peut plus être dérivée.

Une classe dérivée d’une classe non abstraite ne peut pas être déclarée abstraite et ou contenir
des méthodes abstraites.

Une classe peut implémenter plusieurs interfaces.

Exemple :

public class Celibataire implements Personne

Le multiple héritage n’est pas autorisé en Java.

7- Les classes enveloppes :

 Page 29 sur 46

En anglais on parle de wappers. Elles permettent de manipuler les types primitifs comme des
objets. Plus précisément il existe des classes nommées Boolean, Character, Byte Integer,
Short, Long, Float, Double qui encapsulent les valeurs du type primitif correspondant
(boolean, char, byte, short, long, int, float, double).

Exemple :

double x = 5.34;
Double y = new Double(x);
x = y.doubleValue();

8- Les classes anonymes :

Java permet de définir ponctuellement une classe sans lui donner de nom.

A a;
a = new A()
{
/*champs et méthodes qu'on introduit dans la
classe anonyme dérivée de A*/
};

class A
{
public void affiche()
{
System.out.println("je suis A");
}
}

public class Anonym1

{
public static void public static void main(String[] args)
{
A a;
a = new A()
{
public void affiche()
{
System.out.println("Je suis anonyme dérivée de A");
}
};
affiche();
}
}

Exercice :
 Page 30 sur 46

Un exemple d'une classe anonyme implémentant une interface

Chaines de
caractères et type
énumérés

1- Introduction :

String ch; //déclaration d'une référence à un objet de type String

"bonjour"; //ref à un objet de type String

ch="bonjour"; //ref stocker dans une variable

String a, b, c;

a = new String(); //a contient la référence à une chaîne vide

b = new String(ch); //b ref à une chaîne contenant "bonjour"

c = new String(b); //c ref à une chaîne, copie de b donc contenant Bonjour

2- Un objet de type String n’est pas modifiable :

Un objet de type String n’est pas modifiable, il n’existe donc aucune méthode
permettant d’en modifier la valeur.
Exemple :

String a, b, c;
a = "bonjour";
b = "bonsoir";
c = a;
a = b;
b = c;

3- Longueur d’une chaîne :

On utilise la méthode length()
String a = "olakiitan";
int x = a.length(); // x = 9
 Page 31 sur 46

4- Méthode charAt() :
Permet d’accéder à un caractère de rang donné d’une chaîne.
String b = "claude";
b.charAt(0); //"c"
b.charAt(2); //"a"
5- Concaténation :
L’opérateur + est défini lorsque ces deux opérandes sont des chaînes.

Exemple :

String a, b, c;
a = "EUSEBIO ";
b = "Claude";
c = a + b; //c = "EUSEBIO Claude"

6- L’opérateur += :

String a = "bonjour"

a += " monsieur"; // a désigne bonjour monsieur

7- Recherche dans une chaîne :

String mot = "anticonstitutionnellement";

int n;

n = mot.indexOf('t'); // n = 2

n = mot.lastIndexOf('t'); // n = 24

n = mot.indexOf("ti"); // n = 2

n = mot.lastIndexOf("ti"); // n = 12

n = mot.indexOf('x'); // n = -1

8- Comparaison de chaînes :
Deux chaînes de valeurs différentes ont toujours des références différentes. En deux
chaînes de mêmes valeurs ne correspondent pas nécessairement à un seul et même objet.

== , != pour comparer les références avec la méthode equals. C’est une redéfinition de
equals dérivée de l’objet. Elle compare le contenu de deux chaînes.

String a = "EUSEBIO";
 Page 32 sur 46

String b = "Claude";

a.equals(b); // false

a.equals(a); // true

utilisation de equals sans la casse : equalsIgnoreCase()

9- CompareTo :

chaine1.compareTo(chaine2) ;

Elle fournit :

 Un entier négatif si chaine1 arrive avant chaine2

 Un entier nul si chaine1 et chaine2 sont égales
 Un entier positif si chaine1 arrive après chaine2

String a = "abalo";

String b = "mami";

a.compareTo(b); // négatif

10- Modification de chaîne :

 Replace

String ch = "bonjour";

String a = ch.replace('o', 'a'); // a contient : "bonjour"

 Extraction de sous-chaîne

String a = "anticonstitutionnellement";

String b = a.subString(5); // "anticonstitutionnellement"

String c = a.subString(4,16); // "constitution"

 Passage en majuscule : toUpperCase()

c.toUpperCase() ; // CONSTITUTION

 Passage en minuscule : totowerCase()

 Suppression des séparateurs de début et de fin : trim()

String a = "\n\t des séparateurs avant, pendant \t\n et après \n\t "
 Page 33 sur 46

String b = a.trim(); // b = "des séparateurs avant, pendant \t\n et après"

11- Tableaux de chaînes :

public class Trich

public static void public static void main(String[] args)

String tab[] = {"java", "c", "pascal", "c++", "basic", "fortran"}

String temp:

int i, j;

int n = tab.length;

for (i=0; i<n-1; i++)

for (j=i; j<n; j++)

if (tab[i].compareTo(tab[j])>0)

temp = tab[i];

tab[i] = tab[j];

tab[j] = temp;

System.out.println("chaînes triées : ");

for (i=0; i<n; i++)

System.out.println(tab[i]);

}
 Page 34 sur 46

Exercice :
Reprendre et comprendre l’exo d’application de Tableaux de chaînes.

12- Conversion entre chaînes et types primitifs :*

int n = 427;

String ch = String.value(n); // ch = "427"

ou

String ch = Integer(n).toString;

String a = "3567";

int n = Integer.parseInt(a);

int n = Double.parseDouble(a);

" " " "

13- Conversion entre chaînes et tableaux de caractères :

char mot[] = {'b','o','n','j','o','u','r'};

String ch = new String(mot); // contient "bonjour"

String ch1 = new String(mot,2,4); // extraction de la sous-chaine on prélève 4 //caractères

à partir du rang 2

String ch = "bonjour";

char mot[];

mot = ch.toCharArray();
 Page 35 sur 46

14- La classe StringBuffer :

class TstStB

public static void public static void main(String[] args)

String ch = "la java";

StringBuuffer chBuf = new StringBuuffer(ch);

System.out.println(chBuf);

chBuf.setCharAt(3,'J');

chBuf.setCharAt(1,'e');

chBuf.append("_2");

chBuf.insert(3, "langage_");

Les Threads et les

Exceptions

1- Threads :

En bref un processus est un programme en exécution. Il est donc constitué d'une

suite d'instructions et de ressources mobilisées.
L'idée des threads s'est révélée nécessaire lorsque les concepteurs des systèmes
d'exploitation ont constaté qu'un même programme pouvait être invoqué plusieurs
fois et simultanément sur une même machine.
Ainsi au lieu de créer une multitude de processus chacun avec ses propres
ressources, ils ont eu l'idée de créer des processus légers partageant entre eux les
mêmes ressources.
Ces processus légers sont ce qu'un appelle les threads. Les threads tournent
indépendamment les uns des autres et en parallèle. Ils permettent en outre
d'optimiser, d'améliorer et de simplifier beaucoup de pratiques de programmation.
 Page 36 sur 46

Tous les systèmes d'exploitation actuels supportent en quelque sorte la notion de

threads.
Java permet aux programmeurs de bénéficier des threads d'une manière efficace en
leur présentant une interface identique sur toutes les plate-formes où Java est
disponible.

Une classe pourra bénéficier des threads (c-à-d un objet de cette classe pourra
devenir un thread) si :

 La classe hérite de la classe Thread.

 La classe implémente l'interface Runnable.

La première méthode est la plus simple. Nous verrons plus tard la raison d'existence de la
seconde.

Le lancement d'un thread se fait par la méthode start() qui à son tour appelle la
méthode run(). Lorsqu'on sort de run() l'exécution du thread est terminée. Notre
classe qui hérite de Thread devra redéfinir cette méthode run() en y incluant les
instructions qu'on désire voir s'exécuter.

Note : la classe Thread se trouve directement importée car elle appartient au package par
défaut java.lang.

Une première méthode

Il s'agit dans cet exemple de simuler la course entre un lapin et une tortue. Pour
cela nous allons créer deux objets lapin et tortue qui héritent de Thread et qui
s'exécutent en parallèle. Ce qu'ils font c'est de compter jusqu'à 10, le premier qui
termine gagne la course.

class Competiteur extends Thread

{ public Competiteur(String nom)
{ super(nom);
}
public void run()
{ for(int k=1;k<11;k++)
{ System.out.println(getName()+" avance de: "+k+" metres");
try
{ sleep((int)(Math.random()*1000));
}
catch(InterruptedException e) { }
}
System.out.println(getName()+" arrive !!!");
}
}
 Page 37 sur 46

public class Course

{ public static void main(String args[ ])
{ Competiteur lapin=new Competiteur("lapin");
Competiteur tortue=new Competiteur("tortue");
lapin.start();
tortue.start();
}
}

On définit une classe Competiteur qui hérite de Thread. Le constructeur qui accepte
comme argument une chaîne de caractères, le fait passer au constructeur de la
classe mère qui associe ainsi la chaîne au nom du nouvel objet de type Thread.
C'est dans la fonction run() qu'est simulée la course : à chaque fois que notre thread
avance d'un pas on le fait dormir un certain temps aléatoire en faisant passer comme
argument à la méthode sleep un entier aléatoire représentant le nombre de
millisecondes à dormir.
On donne le départ à nos deux compétiteur (qui sont des threads) en invoquant pour
chacun sa méthode start().

Notez qu'à chaque nouvelle exécution de notre programme une nouvelle séquence
de course apparaît du fait du temps aléatoire qu'on génère.

Une deuxième méthode

Passons maintenant à la seconde méthode de réalisation des threads en Java.

Pour cela posons nous la question suivante : si notre classe souhaite se comporter
comme un thread et en même temps hériter d'une autre classe mère que la classe
Thread, et en tenant compte du fait que l'héritage multiple est interdit en Java, que
faire alors ?

La solution consiste à ce que notre classe implémente l'interface Runnable

(importée par défaut) et redéfinit sa méthode run(). Ensuite nous devons passer une
instance de notre classe à un objet de type Thread comme indiqué ci-dessous :

Utilisation de la classe Thread

public class TstThr1

{ public static void main (String args[])

Ecrit e1 = new Ecrit ("bonjour ", 10, 5) ;

Ecrit e2 = new Ecrit ("bonsoir ", 12, 10) ;

 Page 38 sur 46

Ecrit e3 = new Ecrit ("\n", 5, 15) ;

e1.start() ;

e2.start() ;

e3.start() ;

class Ecrit extends Thread

private String texte ;

private int nb ;

private long attente ;

public Ecrit (String texte, int nb, long attente)

this.texte = texte ; this.nb = nb ;

this.attente = attente ;

public void run ()

try

for (int i=0 ; i<nb ; i++)

System.out.print (texte) ;

sleep (attente) ;

}
 Page 39 sur 46

catch (InterruptedException e) {} // impose par sleep

Utilisation de l’interface Runnable

public class TstThr3

public static void main (String args[])

Ecrit e1 = new Ecrit ("bonjour ", 10, 5) ;

Ecrit e2 = new Ecrit ("bonsoir ", 12, 10) ;

Ecrit e3 = new Ecrit ("\n", 5, 15) ;

Thread t1 = new Thread (e1) ; t1.start() ;

Thread t2 = new Thread (e2) ; t2.start() ;

Thread t3 = new Thread (e3) ; t3.start() ;

class Ecrit implements Runnable

private String texte ;

private int nb ;

private long attente ;

public Ecrit (String texte, int nb, long attente)

this.texte = texte ;
 Page 40 sur 46

this.nb = nb ;

this.attente = attente ;

public void run ()

try

for (int i=0 ; i<nb ; i++)

System.out.print (texte) ;

Thread.sleep (attente) ; // attention Thread.sleep

catch (InterruptedException e) {} // impose par sleep

Pour terminer notons qu'on peut arrêter un thread par sa méthode stop().

Resumé

Les threads sont des processus légers ou petits programmes partageant entre eux les
mêmes ressources. Ce sont plusieurs petits programmes qui s’exécutent. Ils tournent
indépendamment les uns des autres. Pour implémenter les threads on peut :

 Créer une classe qui hérite la classe threads

 Créer une classe qui implémente l’interface Runnable (à une seule méthode
run)

Le lancement d’un thread se fait par la méthode start qui à son tour appelle la méthode run.
Lorsqu’on sort de run l’exécution du thread est terminée. La classe fille qui hérite de threads
devra redéfinir cette méthode run en y incluant les instructions qu’on désire voir s’exécuter.

Math.random = [0,1[

Sleep est en millisecondes

 Page 41 sur 46

2- Etats d’un thread :

3- Exception :

Comme dans tout langage de programmation Java prévoit un mécanisme

pour le traitement des anomalies qui peuvent survenir lors de l'exécution de
notre programme. C'est ce qu'on appelle le traitement des exceptions
(exception handling en anglais).
Pour cela Java introduit des mot-clés spéciaux que nous allons aborder ci-
dessous.

Le mot-clé try indique que la partie du code immédiatement après est

susceptible de générer une exception.
L'interception de cette exception se fera par le mot-clé catch et l'action
correspondante sera codée immédiatement après. La syntaxe est la suivante :

try
{
// bloc de code pouvant générer l'exception
}
catch(TypeException e1) { // traitement approprié }
catch(TypeException e2) { . . . }
.
 Page 42 sur 46

.
.
finally { . . . }

Si une exception est générée dans les instructions du bloc try elle est alors
interceptée par le bloc catch correspondant (on sait qu'un catch est destiné à
capturer un certain type d'exception d'après la classe de l'exception
mentionnée après ce catch) s'il existe.
Le bloc finally est éxécuté dans tout les cas et en dernier.

Note : Dans Java le traitement des exceptions est obligatoire, toute section de code
susceptible de générer des exceptions devra être munie des blocs try et catch
correspondants.

Donnons un exemple.

class TestException
{ public static void main(String args[ ])
{ int tab[ ]=new int[10];

try
{ for(int i=0;i<=10;i++)
tab[i]=i;
}
catch(ArrayIndexOutOfBoundsException e)
{ System.out.println("depassement de la taille du tableau");
}
}

Lorsque i devient égale à 10 notre bloc try génère une exception de type
ArrayIndexOutOfBoundsException qui sera capturée par le bloc catch
correspondant pour afficher un message d'erreur.

Exemple :

try
{
x/y
}
catch(ArithmeticException e)
{
System.out.println("division par zero impossible");
}
 Page 43 sur 46

public class Factoriel

{
int facto;
public Factoriel (int n) throws FactExcepton
{
private int n;
if(n<0)
{
throw new FactExcepton("n est inférieur à 0");
}
else
{
public void Fact(int n)
{
for(int i=n; i<=)
{
facto *= i;
}
}
}
}
public void affiche()
{
System.out.println("Resultat = " +facto);
}
}

public class testFactoriel

{
public static void main(String[] args)
{
try
{
Factoriel factoriel = new Factoriel(-5);
factoriel.affiche();
factoriel.Fact(-5);
factoriel.affiche();
}
}
}
 Page 44 sur 46

Exception Personnalisée
Le premier mot clé : throws
Ce mot clé permet de dire à une instruction Java (condition, déclaration de variable...)
ou à une classe entière qu'une exception potentielle sera gérée par une classe -souvent
une classe personnalisée- mais ce peut être la classe Exception elle-même. Ce mot clé
est suivi du nom de la classe qui va gérer l'exception. Ceci a pour but de définir le type
d'exception qui risque d'être générée par l'instruction, ou la classe qui précède le mot
clé throws.

Le deuxième mot clé throw

Celui-ci permet d'instancier un objet dans la classe suivant l'instruction throws. Cette
instruction est suivie du mot clé new ainsi que d'un objet cité avec throws. En fait, il
lance une exception, tout simplement.
Faites surtout bien attention à ne pas confondre ces deux mots clé.
Pour pouvoir mettre en pratique ce système, nous devons commencer par créer une
classe qui va gérer nos exceptions. Celleci, je vous le rappelle, doit être héritée
d'Exception.

package javaapplication1;

class NombreHabitantException extends Exception{

public NombreHabitantException(){
System.out.println("Instanciation d’une Ville avec un nombre d'habitants
négatif !");
} }

package javaapplication1;

public class NomVilleException extends Exception {

public NomVilleException(String message) {

super(message);
}
}

package javaapplication1;

public class Ville extends Exception {

private int nbreInstance = 0;

private String nomVille = null;

 Page 45 sur 46

private String nomPays = null;

private int nbreHabitant = 0;

public Ville(String pNom, int pNbre, String pPays) throws

NombreHabitantException, NomVilleException {
if (pNbre < 0) {
throw new NombreHabitantException();
}
if (pNom.length() < 3) {
throw new NomVilleException("le nom de la ville est inférieur à 3 caractères !
nom = " + pNom);
} else {
nbreInstance++;
nomVille = pNom;
nomPays = pPays;
nbreHabitant = pNbre;

}
}
}

package javaapplication1;

public class Test {

public static void main(String[] args) {

Ville v = null;
try {
v = new Ville("Re", -100, "Togo");

} catch (NombreHabitantException e) {
System.out.println(e.getMessage());

} catch (NomVilleException e2) {

System.out.println(e2.getMessage());

} finally {
System.out.println("\n--------------------------------------------");
System.out.println("Voici le code qui est toujours exécuté ! ! ! ");
System.out.println("--------------------------------------------\n");
}
System.out.println(v.toString());
}
 Page 46 sur 46

Fin du Cours