1. Programmation Orientée Objet
Lycée lissan eddine ibn_elkhatib laayoune
Filière BTS DSI
Pr H.LAARAJ
hasLaaraj@gmail.com
http://lewebpedagogique.com/laarajbts 2015/2016
1

2. « Partie1 »
Classe et objets
Encapsulation
Héritage-polymorphisme
Interface –classe abstraite
Pr H.LAARAJ
hasLaaraj@gmail.com
http://lewebpedagogique.com/laarajbts 2015/2016
2

3. 1- Introduction :
Programmation Orientée objets
3

4. 1.2 exemple 1 :
Programme qui affiche le message « bonjour »:
package application1;
public class Principale{
public static void main(String[] args) {
String message="Bonjour";
System.out.println(message);
}
}
4

5. 1.3 exemple 2 :
Programme qui calcule la somme de 2 nombres entiers
saisis en clavier
package application2;
public class Principale{
public static void main(String[] args) {
int a,b,som;
Scanner s = new Scanner(System.in);
a=s.nextInt();
b=s.nextInt();
som=a+b;
System.out.println("somme "+som); }
}
5

6. 1.4 Exercice1 :
Ecrire un programme qui permet de
comparer 2 nombres
6

7. Exercice2
soit un tableau tab de 6 cases, écrire un code java qui
permet de:
 Saisir les éléments du tableau
 Afficher ses éléments
 Chercher un nombre saisi en clavier s’il existe ou pas
dans le tableau tab
7

8. 2. classe et objet
8
Classe Etudiant
Nom : String
Prénom : String
Age : int
Objets
Sara Mourad Hind Adil

9. 2.1 définitions
 Classe : c'est un ensemble de données et de fonctions regroupées dans une
même entité. Une classe est une description abstraite d'un objet.
 objet : est une instance d'une classe. Pour chaque instance d'une classe, le
code est le même, seul les données sont différentes à chaque objet.
Exemple :
Définir la classe Filiere
code : int
nomFil : String
void afficher()
Filière
Classe Filière
code = 1
nomFil = DSI
Objet f1
code = 2
nomFil = RSI
code = 3
nomFil = PME
Objet f3
Objet f2
Instanciation
9

10. Solution :
public class Filiere {
int code;
String nomfiliere;
public Filiere(int code, String nomfiliere) {
this.code = code;
this.nomfiliere = nomfiliere;
}
void afficher(){ System.out.println(code+" "+nomFil);}
}
// code dans la méthode main()
Filiere f1=new Filiere(1,"dsi"); f1.afficher();
Filiere f2=new Filiere(2,« rsi"); f2.afficher();
résultat :après l’exécution de ce code java le système affiche:
1 dsi
2 rsi
10

11. 3. mot clé static
11

12. 3.1 Les attributs statiques
Les attributs statiques(les variables de la classe) : sont des attributs marqués
par le mot clé « static », ils désignent les attributs communs entre tous les
objets.
nbreFiliere : int
code : int
nomFil : String
void afficher()
Filiere
static int nbreFiliere;
nbreFiliere est un attribut
statique
code = 1
nomFil = DSI
Objet f1
code = 2
nomFil = RSI
code = 3
nomFil = PME
Objet f3 Objet f2
Instanciation
12
On accède à la attribut statique nbreFiliere via :
• Une instance quelconque de la classe f1.nbreFiliere ou f2.nbreFiliere …
• Le nom de la classe directement. Filiere.nbreFiliere

13. Exemple :
public class Filiere {
static int nbrefiliere;
int code;
String nomfiliere;
public Filiere(int code, String nomfiliere) {
this.code = code;
this.nomfiliere = nomfiliere;
nbrefiliere++;
} }
// code dans la méthode main()
Filiere f1=new Filiere(1,"dsi");
Filiere f2=new Filiere(2,"Rsi");
System.out.println(Filiere.nbrefiliere);
résultat :après l’exécution de ce code java le système affiche: 2
13

14. Les constantes
Les constantes sont définies avec le mot clé final static :
leur valeur ne peut pas être modifiée.
Exemple:
public class MaClasse {
final static double PI=3.14 ;
}
14

15. 3.2 Les méthodes statiques
 S’appellent aussi méthodes de classe, elles désignent les
méthodes dont les actions concernent la classe entière et
non pas un objet particulier.
 De même, l’accès à ces méthodes ne nécessite pas la
création d’un objet de la classe, car on peut appeler
directement la méthode à travers le nom de la classe.
 On peut utiliser aussi ces méthodes statiques pour
manipuler des données statiques.
15

16. 4. Encapsulation
16

17. 4.1 définition:
 Modificateur private : Un attribut ou une méthode déclaré "private" n'est
accessible que depuis l'intérieur de la même classe.
 Encapsulation : les attributs doivent être cachés(declarés privés). Leurs
valeurs ne doivent être visibles et modifiables qu'au travers des méthodes.
17
Objet o2
Objet o3
Attributs
privés
Méthodes
Classe

18. 4.2 accesseur et modificateur
le créateur de la classe doit prévoir des méthodes spéciales portant l'étiquette
public, permettant de manipuler ces données.
 Les fonctions membres permettant d'accéder aux données membres sont
appelées accesseurs, parfois getter (appellation d'origine anglophone)
 Les fonctions membres permettant de modifier les données membres sont
appelées modificateurs, parfois setter (appellation d'origine anglophone)
18

19. 4.3 exemple
1 . Créer la classe Filière qui contient les attributs suivants:
Private int code , private String nomFil
2. Ajouter a la classe filiere les méthodes :
 public void setCode(int c ) : méthode accesseur qui permet d’affecter le code par un
nombre compris entre 1 et 20
 public void setNomFil(String n ) : méthode accesseur qui permet d’affecter le nomFil
par la variable n
 public int getCode(): permet de retourner le code de la filière
 public String getNomFil(): permet de retourner le nom de la filière
3. Dans la methode main(…)
 Instancier un objet f ( 2 , ‘bts’)
 Modifier le code de l’objet f par la valeur 34
 Modifier le code de l’objet f par la valeur 5
 Afficher le nom de l’objet f
19

20. Solution
public class Filiere {
private int code;
private String nomfiliere;
public Filiere(int c, String nomfil) { code = c; nomfiliere = nomfil; }
public void setCode(int c ){ if(c>0 && c<=20) code=c;}
public void setNomfil(String nomfiliere ){ this.nomfiliere=nomfiliere;}
public getCode() {return code;}
public getNomFiliere() {return nomfiliere;}
}
// code dans la méthode main()
Filiere f=new Filiere(2, "bts");
f.setCode(34);
f.setCode(5);
System.out.println(f.getNomFiliere() );
20

21. 5. héritage
21
Classe Vehicule
matricule : String
marque : String
puissance : String
void démarrer()
void accélérer()
Classe Voiture
Classe Bus Classe Moto

22. 5.1 Définitions
 L'héritage est un mécanisme qui facilite la réutilisation du
code et la gestion de son évolution.
 Grâce à l'héritage, les objets d'une classe ont accès aux
données et aux méthodes de la classe parent.
 Une classe ne peut avoir qu'une seule classe mère : il n'y a
pas d'héritage multiple en java.
22

23. 5.2 Syntaxe
class Mere {
…
}
class Fille1 extends mere {
…
}
class Fille2 extends mere {
…
}
23
Mere
Fille1 Fille2

24. 5.3 exemple
24
nom : String
prenom : String
age : int
void afficher()
Personne
codeInsc : int
nbabsence : int
void afficher()
Etudiant
matiere : String
void afficher()
Professeur
Super classe
Sous classes
Relation d’héritage

25. 5.4 Solution
public class Personne {
String nom;
String prenom;
int age;
Personne(String nom,String prenom,int age)
{
this.nom=nom;
this.prenom=prenom;
this.age=age;
}
void afficher(){
System.out.print(nom+" "+prenom+"
"+age);
}
}
25
public class Professeur extends Personne {
String matiere;
public Professeur (String n ,String p ,int a,String m){
super(n,p,a);
this.matiere = m;
}
void afficher(){
super.afficher();
System.out.println(" la matiere est :" +matiere);
}
}
public class Etudiant extends Personne {
int codeinsc;
int nbrabs;
Etudiant(String n,String p,int a,int codeinsc,int nbr)
{
super(n,p,a);
this.codeinsc=codeinsc;
this.nbrabs=nbr;
}
void afficher(){
super.afficher();
System.out.println("code "+ codeinsc+" , "+nbrabs);
}
}

26. 5.5 la redéfinition
Les sous classes peuvent redéfinir les méthodes héritées. Les
méthodes sont redéfinies avec le même nom, les mêmes types
et le même nombre d'arguments, sinon il s'agit d'une surcharge.
Exemple:
26
class Mere
void methode(String , int)
class Fille1
void methode(String , int)
class Fille2
void methode( int)
Redéfinition Surcharge

27. 5.6 polymorphisme
 Le nom de polymorphisme vient du grec et signifie qui peut
prendre plusieurs formes.
 une méthode polymorphe est une méthode qui a plusieurs
formes en fonction de la classe dans laquelle elle se situe.
Exemple:
27
void parler()
Animal
void parler()
Chien
void parler()
Canard
Chat
void parler()
Méthode parler() est polymorphe
woof
maoh
wack

28. Solution:
public class Animal {
public void parler(){
System.out.println("parler");
} }
public class Canard extends Animal {
public void parler(){
Class c=this.getClass();
System.out.println(c. getSimpleName() +"a dit
wack");
} }
public class Chat extends Animal {
public void parler(){
Class c=this.getClass();
System.out.println(c. getSimpleName() +"a dit
maoh");
} }
28
public class Chien extends Animal {
public void parler(){
Class c=this.getClass();
System.out.println(c. getSimpleName() +"a dit
woof");
}
}
public class Polymorphe {
public static void main(String[] args) {
Chat cha =new Chat();
//Chat() est un constructeur par défaut
Chien chi = new Chien();
Canard can = new Canard();
Animal tab[]=new Animal[10];
tab[0]=cha;
tab[1]=chi;
tab[2]=can;
for(int i=0;i<3;i++)
tab[i].parler();
//parler() est polymorphe car il affiche un texte
//selon le type de l’objet tab[i]
} }
Après l’exécution le système affiche :
Chat a dit maoh
Chien a dit woof
Canard a dit wack

29. 6 classe abstraite
29

30. 6.1 définition:
 Les méthodes abstract n’ont pas d’implémentation. Leur
déclaration doit être suivie d’un point-virgule.
 Une classe qui contient une méthode abstract doit être déclarée
abstract.
 Une classe abstract ne peut pas être instanciée.
 Une classe peut être déclarée abstract, même si elle ne comporte
pas de méthodes abstract.
 Pour pouvoir être instanciée, une sous-classe d’une classe abstract
doit redéfinir toute les méthodes abstract de la classe parente.
30

31. 6.2 exemple
31
x : int
y : int
abstract surface() : double
deplacer(dx,dy) : void
abstract Forme
rayon : double
Circle(double r)
Circle
Cote : int
Carre(double C)
Carre
Sous classes
Définir les classes suivantes : Abstraite

32. Solution:
public abstract class Forme {
int x,y;
public Forme(int x, int y) {
this.x = x; this.y = y;
}
public abstract double surface();
public void deplacer(int dx,int dy){
x=x+dx;
y=y+dy;
}
public class Carre extends Forme {
int a;
public Carre(int a, int x, int y) {
super(x, y);
this.a = a;
}
32
public double surface() {
return a*a;
}
}
public class Circle extends Forme {
int r;
public Circle(int r, int x, int y) {
super(x, y);
this.r = r;
}
public double surface() {
return Math.PI*r*r;
}
}
//main()
Carre c=new Carre(4,5,6);
c.deplacer(2, 3);
System.out.print(c.surface());
Après l’exécution le système affiche :
16 (=4*4)

33. 7 interface
33

34. 7.1 définition
Une interface: est une sorte de contrat qui indique
ce que la classe qui l'implémente offre comme
service(méthodes).
Interface est composée d'un ensemble d'en-têtes
de méthodes et éventuellement de constantes.
Une interface n'est jamais instanciée
Elle peut servir à l'héritage multiple.
34

35. 7.2 Exemple:
Soit la classe principale suivante:
public class CoursInterface {
public static void main(String[] args) {
Carre c=new Carre(4,13,16);
Personne p =new Personne("elfid","zaid",23);
c.info();
p.info();
}
Modifier les 2 classes Carre et Personne à fin que tous les deux doit
implémenter même méthode info()et que le résultat de l’exécution donne :
carre de surface 16.0
nazih anas 23
35

36. 7.3 Solution
public interface Information {
public void info();
}
public abstract class Forme {
int x,y;
public Forme(int x, int y) {
this.x = x;
this.y = y;
}
public abstract double surface();
public void deplacer(int dx,int dy){
x=x+dx;
y=y+dy;
}
}
36
public class Carre extends Forme implements Information{
int a;
public Carre(int a, int x, int y) {
super(x, y);
this.a = a;
}
public double surface() {
return a*a;
}
public void info() {
System.out.println("carre de surface "+surface());
} }
public class Personne implements Information{
String nom, prenom;
int age;
Personne(String nom,String prenom,int age)
{
this.nom=nom; this.prenom=prenom; this.age=age;
}
void afficher(){
System.out.print(nom+" "+prenom+" "+age);
}
public void info() {
afficher();
}
}

37. 8 classe Object :
37

38. 8.1 définition
 La classe Object est la classe racine de toute la hiérarchie des objets Java.
Quelques méthodes de la classe Object:
• public String toString()
• public final Class getClass()
• public boolean equals(Object o)
• protected Object clone()
• …
38

39. 8.2 transtypage(Casting)
Le transtypage explicite des références est utilisé pour convertir
le type d'une référence dans un type dérivé(sous classe).
Mere -> fille
Exemple :
Etudiant e =new Etudiant("elalami","adil",22,101,2) ;
Personne p=new Etudiant(« achraf","said",23,102,4) ;
e= (Etudiant) p; // Casting p vers e
e.afficher();
39

40. 8.3 equals
 Cette méthode permet de comparer deux objets, et notamment de
savoir s'ils sont égaux
 Pour comparer 2 objets , on doit redéfinir la méthode equals().
Exemple :
Comparer 2 objets de type Personne
Solution:
Personne p1=new Personne("Boutaib","bachir",23);
Personne p2=new Personne("Boutaib","bachir",23);
if(p1.equals(p2))
System.out.println("egaux");
else
System.out.println("pas egaux");
//mais il faut redéfinir la méthode equals dans la classe Personne (voir la
page suivante)
40

41. Solution (suite)
public boolean equals(Object o) {
Personne p=(Personne)o;
if(!this.nom.equals(p.nom))
return false;
if(!this.prenom.equals(p.prenom))
return false;
if(this.age!=p.age)
return false;
return true;
}
/* ou bien 2eme méthode
public boolean equals(Object o) {
Personne p=(Personne)o;
return this.nom.equals(p.nom)&&this.prenom.equals(p.prenom)&&this.age==p.age;*/
}
41

42. 8.4 Clonage
 Mécanisme qui permet de construire une copie (sûre) de l'objet, pour conserver
l'état initial d'un objet
 Pour pouvoir être clonée, une classe doit implémenter l'interface Cloneable.
Celle-ci indique que la classe peut réécrire la méthode clone() héritée de la
classe Object afin que ses instances puissent procéder à une copie de ses
attributs vers une nouvelle instance
Exemple :
Personne p1=new Personne("boutaib","bachir",27);
Personne p2=p1;
p2.nom= "faouzi";
System.out.println(p1.nom)
/* il affiche faouzi puisque p1 et p2 référencent même objet
pour créer deux objets de références différentes on doit changer l’instruction
Personne p2=p1; par Personne p2=p1.clone(); et redéfinir la méthode clone() dans la
classe Personne qui implémente l'interface Cloneable */
42

43. Solution (méthode clone())
class Personne implements Cloneable{
…
//1ere methode en utilisant try et catch pour traiter les erreurs de clonage
protected Personne clone() {
Personne p=null;
try{
p=(Personne) super.clone();
}
catch(CloneNotSupportedException e){
System.out.println("erreur de clonage "+e.getMessage());
}
return p;
}
/*2eme methode en utilisant throws pour traiter les erreurs de clonage(voir plus loin)
protected Personne clone() throws CloneNotSupportedException {
return (Personne) super.clone();*/
}
43

44. 8.5 Exercice
1. Créer une classe nommée Tableau pour la gestion de tableaux d’objets. Elle aura les
caractéristiques suivantes :
 Un champ privé donnees, de type tableau d’Object.
 Un champ privé nbElts, entier, c’est le nombre d’éléments dans la tableau.
 Un constructeur admettant un argument entier, le nombre nb d’éléments du tableau.
 Une méthode public int size() renvoyant renvoyant le nombre d’éléments dans la
tableau.
 Une méthode public int indexOf(Object elem) qui renvoie l’indice dans le tableau de
l’objet dont une référence est passée en argument. On se servira, pour les
comparaisons, de la méthode boolean equals(Object elt) héritée d’Object.
 Une méthode public Object get(int index) qui renvoie une référence sur l’objet stocké à
l’indice index.
 Une méthode public void add(Object element) qui ajoute l’objet référencé par
element à la dernière indice .
2. Ajouter la méthode nommée void modifierNomPrenom(String nom, String prenom) à la
classe Personne qui change le nom et prenom de la personne courante.
44

45. Exercice(suite)
3. Créer une classe TableauMain, ne contenant qu’une méthode main().
Dans cette dernière, créer un Tableau de 6 cases, nommé par exemple tab, puis créer une
personne, nommé par exemple p("A", "A",22).
Effectuer ensuite les opérations suivantes :
tab.add(p);
p.modifierNomPrenom("B", "B");
tab.add(p);
p.modifierNomPrenom("C", "C");
tab.add(p);
System.out.println("index de p: "+tab.indexOf(p));
// Puis afficher les différents éléments du tableau.
Le résultat vous semble-t-il conforme à vos attentes?
45