Le Java orienté objet

Dr MOUSSE Ange Mikaël

Sommaire
Classe
Concept de base
Les objets
Les attributs
Les méthodes
Le constructeur
Le Destructeur
Les Accesseurs
Exemple complet
Classe String
Classe Math

Héritage
Principe de l'héritage
L'héritage et les classes abstraites
L'héritage et les méthodes abstraites
2
L'héritage et les interfaces
Sommaire
Classe
Concept de base
Les objets
Les attributs
Les méthodes
Le constructeur
Le Destructeur
Les Accesseurs
Exemple complet
Classe String
Classe Math

Héritage

3
Classe(1)
I En java, tout appartient à une classe (sauf les objets de type
primitifs)
I Une classe est un support de l'encapsulation
I C'est un ensemble de données et de fonctions regroupées dans
une même entité
I La classe est un modèle qui s'apparente à la déclaration d'un
nouveau type de données
I On peut déclarer une variable (on parle d'objet ou d'instance
de la classe en POO) du type de cette classe
I C'est une description abstraite d'un objet
I Une classe comporte sa déclaration, des variables et la
dénition de ses méthodes 4
Classe(2)
I On déclare une classe par le mot clé class précédé d'un
modicateur.

modificateur class NomdelaClasse {

// Declaration des attributs
.................................
//Declaration des methodes
.................................
}

5
Classe(3)

public class Personne {

public String nom;
public String prenom;
public int age;

public void insererNom();

public String recupererPrenom();

6
Les modicateurs de classe
I public : la classe est accessible partout
I private : la classe n'est accessible qu'à partir du chier où elle
dénie
I nal : la classe ne peut pas être modiée. Sa redénition par
l'héritage est interdite.
I abstract : la classe contient au moins une méthode abstraite.
I Une classe déclarée abstract ne peut pas être instanciée
I Dénir une classe qui hérite de cette classe et qui implémente
les méthodes nécessaires pour ne plus être abstraite. (à voir)

7
Objets-Classe
I Un objet est une instance d'une classe
I La classe est une description d'un objet
I Un objet est créé à partir de l'opérateur new et est associé à
une variable.
I En java, tous les objets sont instanciés par allocation
dynamique.

Personne p;
p = new Personne();

OU

Personne p = new Personne(); 8

Objets-Classe
Objets
I p désigne un objet de type Personne
I new a permit d'instancier l'objet (par l'appel du constructeur)
an de pouvoir manipuler des attributs et méthodes.

Les attributs
I Des variables qui denissent l'etat d'un objet d'une classe (le
nom d'une personne,. . . ).
I Ce variables sont des attributs qui peuvent etre des types
primitifs (int,. . . ) ou des objets.
9
Les attributs(1)
Les variables d'instance
I Une variable d'instance est une simple variable déclarée dans le
corps de la classe.
I Chaque instance de la classe a accès à sa propre occurrence de
la variable.

public class Personne {

public String nom;
String prenom;
int age;
}
10
Les attributs(2)
Les variables de classe
I Les variables de classes sont dénies avec le mot clé static
I Chaque instance de la classe partage la même variable.

public class Personne {

static int nombre;
}

11
Les attributs(3)
Les constantes
I Les constantes sont dénies avec le mot clé nal.
I Leur valeur ne peut pas être modiée une fois qu'elles sont
initialisées.

public class MaClasse {

nal double pi=3.14 ;
}

12
Les méthodes(1)
Méthodes
I Permettent d'interagir à l'extérieur d'une classe.
I Elles peuvent aussi modier les attributs de la classe.

I Une methode est composee de deux elements : la declaration

(entête, signature,. . .) et l'implementation (corps,. . .).
I Une methode est declarée par son type de retour, son nom et
une liste d'arguments (qui peut être vide).
I la liste des arguments est entre parenthèse, les arguments sont
déclarés exactement comme des variables (type puis nom)
I le type de retour peut etre un type primitif, une classe ou void
si la méthode ne renvoie rien
I Si la methode renvoie quelque chose on doit imperativement
trouver le mot return suivi d'un element du type correspondant 13

à celui déclaré dans l'implémentation.

Les méthodes(2)

public void insererNom(String n){

nom = n;
}

public void insererPrenom(String p){

prenom = n;
}

public String recupererPrenom(){

return prenom;
}
14
 Surchage de méthodes
Surchage de méthodes
I Une meme methode peut avoir plusieurs declarations
diérentes dans la même classe.
I Le nombre et le type des arguments (et du retour) peuvent
librement varier sous reserve que pour un même ensemble
d'arguement (nombres et types) il n'y ait qu'une seule
declaration.
I Le compilateur choisit la methode à utiliser en fonction des
arguments passés.

public void modifierAge(){ public void modifierAge(int a){

age = 30; age = a; 15
} }
Les modicateurs des méthodes
I public : la méthode est accessible aux méthodes des autres
classes
I private : l'usage de la méthode est réservé aux autres
méthodes de la même classe
I protected : la méthode ne peut être invoquée que par des
méthodes de la classe ou de ses sous classes (Héritage)
I nal : la méthode ne peut pas être modiée. Sa redénition
par l'héritage est interdite.
I static : la méthode appartient simultanément à tous les objets
de la classe.
I comme une constante déclarée à l'intérieur de la classe
I inutile d'instancier la classe pour appeler la méthode mais la
méthode ne peut pas manipuler de variable d'instance. 16
Constructeur(1)
Méthode particulière
I Un constructeur est une méthode particulière, qui sert à
initialiser un objet une fois que la mémoire est réservée par new
I Elle n'a pas de type de retour même pas le type void.
I Elle est appelée lors de la création d'un objet de la classe.
I Elle a pour charge l'initialisiation des diérents attributs de la
classe.
I Si une classe est créée sans constructeur, un constructeur par
defaut (il est vide) est créé.

17
 Constructeur(2)
Constructeur sans paramètres Constructeur avec paramètres

public class Personne { public class Personne {

String nom, prenom; String nom, prenom;
int age; int age;
public Personne(){ public Personne(String n, String p){
} nom = n;
} prenom = p;
}
}

18
Destructeur
Destructeur
I Comme son nom l'indique, il détruit un objet après son usage.
I Il permet d'exécuter du code pour la libération de l'espace
mémoire occupé par un objet.
I En java, il est évoqué automatiquement par la machine
virtuelle.
I Il ne libérera pas la mémoire des objets en cours d'utilisation.
I Connu sous les noms de : GB (Garbage Collector), RM
(Rammasse-Miette).

19
 Les accesseurs
Accesseur
I Les données déclarées private à l'intérieur d'une classe ne
peuvent être accédées et modiées que par des méthodes
dénies dans la même classe.
I Un accesseur est une méthode publique qui donne l'accès à
une variable d'instance privée.
I Par convention, les accesseurs en lecture commencent par get
et les accesseurs en écriture commencent par set.

public void setNom(String n){ public int getAge(){

nom = n; return age;
} } 20
Classe Personne(1)

public class Personne {

private String nom, prenom;
private int age;
public Personne() {
nom = "TOTO";
prenom = "momo";
age = 25;
}
public Personne(String n, String p, int a){
nom = n;
prenom p;
age = a;
} 21
Classe Personne(2)

public void setNom(String n) {

nom = n;
}
public void setPrenom(String p) {
prenom = p;
}
public void setAge(int a) {
age = a;
}
public String getNom() {
return nom;
}
public String getPrenom() {
return prenom;
}
public int getAge() {
return age;
}
22
}
TestClassePersonne

public class TestClassePersonne {

public static void main(String[] args){
Personne p1 = new Personne();
Personne p2 = new Personne("MOUSSE", "Ange", 25);
// Achage de nom des personnes p1 et p2
System.out.println(" p1 ==> Nom : "+p1.getNom());
System.out.println(" p2 ==> Nom : "+p1.getNom());
// Modication des prenoms
p1.setPrenom("Mikael");
p2.setPrenom("Amoua");
// Achage de prenom des personnes p1 et p2
System.out.println(" p1 ==> Prenom : "+p1.getPrenom());
System.out.println(" p2 ==> Prenom : "+p1.getPrenom());
}
}

23
Classe String (1)
I Il s'agit d'une classe dénie dans l'API Java (package
java.lang) ;
String s = "aaa" ;
String s = new String("aaa") ;
I La concaténation
String str1 = "Bonjour !" ;
String str2 = null ;
str2 = "Comment vas-tu ?" ;
String str3 = str1 + str2 ; /* Concaténation de chaînes : str3
contient " Bonjour ! Comment vas-tu ?" */

24
Classe String (2)
I Longueur d'une chaine : méthode int length() ;
String s = "bonjour" ;
int l = s.length() ; // l vaut 7.
I Sous-chaîne : méthode String substring(int debut, int n) ;
extraction de la sous-chaine depuis la position debut jusqu'à
la position n non-comprise.
String str2 = s.substring(0,3) ; // str2 contient la valeur
"bon"
I Récupération d'un caractère dans une chaîne méthode char
charAt(int pos) ;
char unJ = s.charAt(3) ; // unJ contient le caractère 'j'
25
Classe String (3)
I pour tester si 2 chaînes sont égales : méthode boolean
equals(String str) ;
I pour tester si 2 chaînes sont égales à la casse près il faut
utiliser la méthode : boolean equalsIgnoreCase(String str)
I pour tester si une chaine de caractère commence par la chaine
de caractère str : boolean startsWith(String str)
I pour tester si une chaine de caractère se termine par la chaine
de caractère str : boolean endsWith(String str)
I Plus d'informations dans les documentations de l'API dans le
package java.lang

26
Classe Math
I Les fonctions mathématiques les plus connues sont regroupées
dans la classe Math qui appartient au package java.lang
I les fonctions trigonométriques
I les fonctions d'arrondi, de valeur absolue, ...
I la racine carrée, la puissance, l'exponentiel, le logarithme, etc.

I Ce sont des méthodes de classe (static)

double calcul = Math.sqrt (Math.pow(5,2) + Math.pow(7,2)) ;
double sqrt(double x) ; //racine carrée de x
double pow(double x, double y) ; x puissance y

27
Sommaire
Classe

Héritage
Principe de l'héritage
L'héritage et les classes abstraites
L'héritage et les méthodes abstraites
L'héritage et les interfaces

28
Héritage(1)
Dénition
I L'héritage est un mécanisme qui facilite la réutilisation du
code et la gestion de son évolution. C'est la relation entre :
I une classe mère ou super classe
I une classe lle ou sous classe qui hérite de sa classe mère
I Un fonctionnaire est une personne et étudiant est aussi une
personne.

Intêret
I Le code commun entre diérentes classes est factorisé dans la
classe mère
29
Héritage(2)
Principe
I les objets d'une classe lle ont accès aux données et aux
méthodes de la classe mère.
I Les sous classes peuvent redénir les variables et les méthodes
héritées
I Les instances de la classe lle (objets) sont aussi des instances
de la classe mère,l'operateur instanceof renvoie true
I Une classe peut avoir plusieurs sous classes. Une classe ne
peut avoir qu'une seule classe mère : il n'y a pas d'héritage
multiple en Java.
I Un attribut déclaré protected est accessible dans son
paquetage et dans ses classes dérivées.
I Si un attribut de la super-classe est privé (private), la 30

sous-classe ne peut y accéder.

Héritage(3)
Implémentation
I L'heritage est specié lors de la declaration de la classe à l'aide
du mot clé extends

public class UneClasseFille extends UneClasseMere {

... }

Redénition des méthodes

I A l'intérieur d'une classe lle, une méthode implementée dans
la classe mère peut être récrite : c'est la redénition (on utilise
aussi le mot surcharge).
I Dans ce cas, elle remplace la methode de la classe mère pour
les objet appartenant à la classe lle. 31
I Elle doit avoir le même nom, les mêmes attributs (type et
ordre) et le même type de retour que ceux de la classe mère.
Héritage(3)
Méthode redénies
I Possible de faire appel à une méthode de la classe mère avec le
mot clé super() dans la première ligne de l'implémentation
I Utilisées pour dénir les constructeurs des classes lles : on
prote ainsi de toutes les initialisations faites par la classe
mère.
I Le code remplace exactement le nom de la methode et peut
donc etre utilisé avec des arguments d'appel.

32
 Héritage(4)

public class Mere {

void AfficheTexte(String str ) {
System.out.println(" La mere ache " + str );}
}

public class Fille extends Mere{

void AfficheTexte (String str) {
super ( str );
System.out.println(" La lle ache "+ str ); }
}

...
Mere a= new Mere () ;
La mere affiche Bonjour de A
Fille b = new Fille () ;
La mere affiche Bonjour de B
a.afficheTexte (" Bonjour de A" );
La fille affiche Bonjour de B 33
b.afficheTexte (" Bonjour de B" );
...
Les Classes abstraites
Classes abstraites
I Une classe abstraite ne peut pas être instanciée ; seules ses
classes lles peuvent l'être.
I Le but est de decrire un comportement general puis de le
raner dans les classes lles.
I Une classe qui contient une (ou plusieurs) methode(s)
abstraite(s) doit etre declarée abstraite.
I En Java, c'est le mot clé abstract qui permet de declarer un
element abstrait.

public abstract class Personne {

protected int age;
abstract void ecrirePersonne() ; 34
...
}
Les méthodes abstraites
Méthodes abstraites
I Une methode abstraite est une methode qui est declaree
(entête) mais qui n'est pas implementée (corps).
I Il s'agit simplement de dénir l'existence d'une méthode qui
sera implementée lors d'un héritage.
I En Java, c'est le mot clé abstract qui permet de déclarer une
methode abstraite.

...
abstract void ecrirePersonne() ;
...
35
Exemple

36
Exemple

37
Exemple

38
Les interfaces
Interfaces
I Une interface = une classe qui contient uniquement des
méthodes abstraites.

public interface Personne {

/* Signature des methodes sans le mot cle abstract*/
...
}

Utilisation des interfaces

I Une interface est implémentée par une classe.

public class Etudiant implements Personne { 39

...
}
Les interfaces
Interfaces
I Une classe qui implémente une interface doit obligatoirement
dénir toutes ses méthodes abstraites.
I Une classe peut implémenter plusieurs interfaces : mettre une
liste après le mot-clé implements.
I Une classe qui hérite d'une autre classe et qui implémente une
interface : mettre dans l'ordre l'héritage (extends ) puis
l'implémentation (implements).

40
Exemple

41
Exemple

42
Exercices

43
Questions

44