Java 2.objet

POO – JAVA
Partie II
Les concepts Objet en Java
http://gherabi.zz.mu
Partie OO
Les classes et les objets
2
Notion d’objet
3
Notion d’objet
4
Notion de classe
5
Classe
POO- JAVA Ensa Khouribga

Classe

Codage de la classe « voiture »

Classe

Attributs et variables

Objet : Définition

Objet : Notations

Etats des objets

Affectation et comparaison

Structure des objets

Cycle de vie d’un objet

Création d’objet
voiture v:
v=NULL

Création d’objet

Création d’objet

Constructeur
v Constructeur : méthode appelée automatiquement à la création d'un objet
v Rôle
❙ Initialise les différentes parties de l'objet : on connaît toujours l’état initial
❙ Réalise les actions indispensable à l'état initial de l'objet
❙ Plusieurs manières d'initialiser un objet
◊ Surcharge possible i.e. plusieurs constructeurs de même nom
❘ Construire un point à partir de 2 réels
❘ Construire un point à partir de rien
❘ Construire un point à partir d’un autre point
v Syntaxe
§ Fonction de même nom que la classe, comme en C++
20
Constructeur de « Voiture »

Constructeur de « Voiture »

Construire une voiture de 7CV

Constructeur sans argument

Constructeur: Exemple
class Point { private double x; private double y;
/* Constructeur : quelles sont les valeurs initiales d'un point */
public Point (double a, double b) {System.out.println("C1"); x = a; y = b;}
public Point () { System.out.println("Constructeur 2"); x = 0; y = 0; }
public Point (Point a) { System.out.println("Cons 3"); x = a.x; y = a.y; }
};
public class Ex1 {
public static void main (String []arg) { Point a ;
System.out.println("Creation de a");
a= new Point(1,2); // Création du point 1,2, constructeur 1
System.out.println("Fin Création de a");
System.out.println("Creation de b");
Point b = new Point(); // Création du point 0,0 constructeur 2
System.out.println("Fin creation de b");
System.out.println("Creation de c");
Point c = new Point(b); // Création de C à partir de b;
System.out.println("Fin creation de c");
}
}
25
Destructeur
❚ Fonction appelée automatiquement lors de la destruction

des objets
❙ Prototype : protected void finalize()
❙ En C++, ~nom_de_la_classe()
❚ En java, très peu utilisé car vous ne gérez pas la libération de

la mémoire : c’est automatique, grâce au ramasse miette
❚ ramasse miette :
❙ Récupère automatiquement la mémoire des objets devenus inutiles et appelle la
méthode finalize
❙ On ne sait pas quand il est appelé : on ne sait donc pas quand est utilisé le
destructeur
❚ Objets inutiles :
❘objets réels alloués qui ne sont plus utilisés
❘Difficile à trouver ==> quand un objet est inutile, pour qu’il puisse être
détruit, mettre sa référence à null
26
Les classes en JAVA
q La classe définit la structure des objets
q Les champs
q les méthodes utilisables par un objet de ce type, i.e. les actions qu’un objet
de ce type peut réaliser
q Syntaxe
[public] class Nom_de_ma_classe {
// déclaration des champs;
[public, private] type nom_champ;
//déclaration de methodes;
[public, private] type_retour nom_de_fonction(type nom_parametre, …)
}
q En pratique, le nom d’une classe commence par une majuscule
q Le nom du fichier est celui de la classe contenant la fonction main ou celui de la
classe public
27
Les objets et les variables
en JAVA
Ø Un objet = un exemple ou une entité dont le modèle (type) est une classe
Ø On dit aussi une instance de classe.
Ø La variable est une référence (pointeur constant) sur cet objet
Ø En Java, 3 étapes
Ø Définition de la variable : Point p1;
ØSa durée de vie est celle du bloc
Ø Création et allocation de l’objet : p1= new Point(2,8);
ØSa durée de vie est celle de son utilisation
ØElle est détruite AUTOMATIQUEMENT quand elle est devenue inutile
Ø Utilisation du point p1 :
Øpar exemple, appliquer affiche() à p1 : p1.affiche()
Øou changer la valeur de l’abscisse : p1.x=10;
Ø Donc
❚ En java, une variable est une référence, i.e. un pointeur "masqué"
❚ Le passage d’un objet comme paramètre d’une fonction permet de modifier
cet objet : pas besoin de passage de l’adresse
❚ Pas de pointeur, de gestion mémoire par le programmeur
28
Concept d'objet : exemple
public class Ex2 {
public static void main (String[] args){
System.out.println("Premier exemple");
Point p1=null, p2=null; // Définition p1, p2
p1 = new Point(); // Creation p1

p1.x=2; p1.y=8; // On change p1 p1 p1
22
2
p1.affiche(); 88
8
p2 = new Point(20,80); `
p2.affiche(); p1
20
p2
p1.x = p1.x + 20; p1.y += 80; 80
p1.affiche();
p1
p2=null; // l’objet pointé par p2 est libre
} // les variables p2 et p1 sont détruites
}
p1.affiche()
p2.affiche()
p1.affiche()
29
Notion d’objet
Les attributs et les méthodes
30
Accès aux membres
q Accès aux membres d’un objet : objet.champ
❙ Attention, objet est une référence
❙ Exemple : a.x est l’abscisse du point a.
q Appeler/exécuter une méthode : objetappelant.methode(param);
❙ Cela signifie que l’on exécute methode(parametres) « SUR » objetappelant
❙ Les méthodes s’exécutent sur un objet
❙ p.affiche() signifie
❘On cherche la classe de p : c’est la classe Point
❘On cherche si une méthode affiche() existe dans la classe Point :
•si elle n’existe pas, erreur de compilation « Cannot find Symbol »
❘On exécute cette fonction avec un paramètre supplémentaire invisible :this, qui est l’objet
sur lequel on travaille = objet appelant. Ici, this = p
public void translate(double a, double b) {
x = x + a; y = y + b;
}
Si on appelle translate avec le point p sous la forme p.translate(2,3), p.x et p.y qui sont
incrémentés de 2 et 3
31
Paramètre this
❚ Dans une méthode, il y a toujours un paramètre « implicite »
this, qui est l’objet sur lequel on travaille
❙ p.translate(1,2) ==> this est une référence sur p
❚ Donc
public void translate(double a, double y) { ATTENTION !!!!!
x = x + a; y = y + y;
}
// Quand on écrit y, est ce le paramètre de la fonction ou l’attribut de p ?
public void translate(double a, double y) {

x = x + a; this.y = this.y + y;
}
32
Paramètre this

Paquetages
Paquetages
Quelques paquetages de SDK :
Notion d’objet
Sécurité
36
Accès et protection
Encapsulation
Les membres déclarés avec les modificateurs :

v Private : sont accessibles uniquement au sein de la classe
dans laquelle ils sont déclarés
v Protected : sont accessibles uniquement aux classes d’un
package et à ses classes filles.
v Public : sont accessibles de partout et sans restriction.
v Les membres déclarés sans modificateur d’accès ont une
portée d’accès au niveau du package (default access).
sans declarer =pretected

Encapsulation
3 Java-les fondamentaux (Youssef Saadi /

8 POO- JAVA v1.1) Ensa Khouribga
Encapsulation

Notion d’objet
Surcharge de méthodes
40
Surcharge ou
Polymorphisme de méthodes
❚ Possibilité pour une fonction ou méthode d’avoir un même nom si

les signatures différentes
❙ Signature : type de retour, nombre et type des paramètres
❙ En Java et C++, surcharge uniquement sur les paramètres
❙ La fonction réellement exécutée est déterminée sur la base des
paramètres utilisés
❘En java, il y a liaison dynamique décidé à l’exécution
❙ Attention :
❘on ne peut pas surcharger uniquement sur le type de retour
41
Surcharge ou
Polymorphisme de méthodes
class Point { private double x, y;
/* Constructeur */
public Point (double a, double b) {x = a; y = b; }
public Point (Point a) {x = a.x; y = a.y; }
public void affiche() { System.out.println( "x:"+x+" y:"+y);}

// Deux methodes de translations :
// A partir de 2 reels
public void translate(double a, double b) { x += a; y += b; }
// A partir d’un point
public void translate(Point p) { x += p.x; y += p.y; }
};
public class Ex3 {
public static void main (String []arg) {
Point a= new Point(1,2); // Création du point 1,2
Point b = new Point(10,20);
Point c = new Point(b); // Création de C à partir de b;
b.affiche();
b.translate(1,2); b.affiche();
c.affiche();
c.translate(a); c.affiche();
}
} 42
Lecture des entrées
q Lire des nombres et des chaines : classe Scanner
❙ Créer un objet de la classe Scanner associé au flux de lecture voulu : le clavier
❙ Les méthodes nextDouble(), nextInt(), nextLine() de la classe Scanner permettent la lecture
des réels, entiers et chaines.
q Afficher : System.out.println()
import java.util.*;
public class EX4{
double x1, x2;
String x;
Scanner clavier = new Scanner(System.in);
System.out.println("Entrer 2 reels ");
x1=clavier.nextDouble(); // Lecture d’un reel
x2=clavier.nextDouble(); // 3,14567 :virgule
System.out.println("Voici x1 : " + x1);
System.out.println("Tapez une chaine");

x=clavier.nextLine();
System.out.println("Ce que vous avez ecrit : " + x);
}
}
43
Méthodes existantes
❚ Toutes les classes JAVA héritent de la classe de base Object, qui contient :
❚ Pour l’affichage : toString()
❙ Doit retourner une représentation textuelle de l’objet
❙ Elle est utilisée par System.out.println
❚ Pour les tests d’égalité : equals()
❙ a==b ne test pas si les objets a et b sont identiques mais si a et b regarde le même objet, il faut définir le test
d’égalité avec la méthode equals
class Point { ……
public String toString() {return("abscisse:"+x+" ordonnée:"+y);}
// Avec cette methode, on peut afficher point avec System.out.println(a)
public boolean equals(Point b) {return( x==b.x && y==b.y); }
};
public class Ex5 {
Point a,b,c,d;
a= new Point(1,2); b = new Point(1,2); c=new Point(1,3); d=a;
System.out.println(a);// Affiche a
if (a==b) System.out.println("a et b pointe le même objet");
if (a==d) System.out.println("a et d pointe le même objet");
if (a.equals(b)) System.out.println("a et b de contenu identique");
if (a.equals(c)) System.out.println("a et c de contenu identique");
if (a.equals(d)) System.out.println("a et d de contenu identique");
}
}
44
Résumé
q Un programme objet :
❙ 1 fonction main qui démarre le programme, crée les objets et les
enchainements d’actions
❙ 1 ensemble de classes décrivant les capacités des données manipulées
q 1 classe : type de données qui rassemble des données (champs) et la manière
de s’en servir (méthodes)
❙ Données et méthodes protégées si besoin :
❘public : n’importe quelle fonction du programme peut les modifier ou
les utiliser
❘private : seules les méthodes de la classe concernée peuvent les modifier
ou les utiliser
45
Résumé
❙ Constructeurs : comment initialiser l’objet ?
❙ Surcharge : plusieurs fonctions peuvent avoir le même nom, mais pas les
mêmes nombres et/ou types de paramètres
q 1 objet : une instance
❙ Définir la variable
❙ Créer l’objet
❙ Destruction de l’objet automatique quand on n’en a plus besoin : pas de
gestion mémoire ni pointeurs
❙ Exécuter une méthode ou fonction : objet.méthode (parametres);
46
Tableaux et tableaux d’objets
Tableaux
v Ensemble d’objets de même type à accès direct

v Les tableaux sont des OBJETS
v Taille du tableau fixe, n’est pas modifiable, accessible par la valeur (et pas
la méthode) length: tab.length;
v Accès aux éléments par tab[i]
v Indices débutant à 0
Ø Création d’un tableau en 3 étapes

1/ Déclaration d’une variable : int [] tableau;
2/ Instanciation ou création : tableau = new int [10];
3/ Utilisation : tableau [i] = 2*i
Indices
0 1 2 3 9
tableau 0 2 4 6
Tableau de 10 éléments

Tableaux
v Lire la dimension au clavier, créer un tableau de nombre, le remplir et l’afficher
import java.util.*;
public class Ex6 {
public static void main(String[] arg) {
int [] tableau;
Scanner clavier = new Scanner (System.in);
System.out.println("Nombre d'element du tableau ?");
int nb = clavier.nextInt();
tableau = new int [nb];
for (int i=0; i<tableau.length ; i++) tableau[i]=2*i+1;

for (int i=0; i< tableau.length ; i++)
System.out.print(tableau[i]+" " );
tableau[2+ tableau.length ]=0; // ERREUR : pourquoi ?

}
}

Tableaux

Tableaux d’objets
v Création d’un tableau d’objet : 2 étapes

§ Créer le tableau :
• Point [] tab = new Point [ clavier.nextInt()];
§ Créer chaque objet du tableau :`
• for (int i=0; i< tab.length ; i++) tab[i]=new Point(2*i,2*i+1);
v Exemple : tableau de points

public class Ex7 {
public static void main (String []arg) { Point [] tab;
Scanner clavier = new Scanner(System.in);
System.out.println("Entrer le nombre de points");
tab = new Point [ clavier.nextInt()];
clavier.nextLine();
// Attention ; les points ne sont pas créés
for (int i=0; i< tab.length ; i++) System.out.print(tab[i]+" ");
System.out.println(); clavier.nextLine();
// Creation des points
for (int i=0; i< tab.length ; i++) tab[i]=new Point(2*i,2*i+1);
for (int i=0; i< tab.length ; i++) System.out.print(tab[i]+" ");
System.out.println();
}
}
Les fonctions mathématiques

Objet Math
Calculer le cosinus d'un angle Math.cos ( )
Calculer le sinus d'un angle Math. sin ( )
Calculer la tangente d'un angle Math.tan ( )
Calculer le logarithme d'une valeur Math.log ( )
Calculer l'exponentielle d'un nombre Math.exp ( )
Arrondir à l'entier inférieur Math.floor ( )

Objet Math
Calculer la racine carrée d'un nombre Math.sqrt ( )
ab (a puissance b) Math.pow ( )
|a| (valeur absolue de a) Math.abs ( )
Trouver la plus grande de deux valeurs Math.max ( )
Trouver la plus petite de deux valeurs Math.min ( )
Tirer un nombre au hasard entre 0 et 1 Math.random ( )

Les chaines de caractères



Exemple

Comparaison de chaines

Les opérations sur les
chaines
L'opérateur "+" permet de concaténer (mettre bout à bout) des

chaînes de caractères
§ String Text = " Bonjour";

§ String s1 = Text + " Said";
§ String rec = “Salut" + s1 + 3 + ')';

chaines
Différentes méthodes permettent de convertir des valeurs de types

primitifs en objets de type String et inversement.
q Ces méthodes se trouvent soit dans la classe String, soit dans les
classes Wrapper associées aux types primitifs ( Byte, Short, Integer, Long,
Float, Double, Character, Boolean ).
q Dans les librairies de base, il existe souvent plusieurs méthodes pour
effectuer un même type de conversion.

chaines
La classe String dispose d'un grand nombre de méthodes pour traiter les
chaînes de caractères.
♣La méthode length() permet de connaître la longueur d'une chaîne
de caractères (nombre de caractères).
♣La méthode charAt() permet de retrouver le caractère situé à la
position n d'une chaîne
♣La méthode substring() retourne une sous-chaîne d'une chaîne
donnée. Les paramètres déterminent la position initiale et la position
finale (+1) de la sous-chaîne dans la chaîne originelle.

chaines
q La méthode split() permet de découper une chaîne de

caractères sur la base d'un séparateur qui est exprimé sous la
forme d'une expression régulière (regex).

Classe StringBuffer
Contrairement à la classe String, la classe StringBuffer permet de créer des

chaînes de caractères modifiables (la taille et le contenu peuvent varier durant
l'exécution de l'application).
♣ La notion de capacité (Capacity) représente la taille du buffer interne qui
mémorise la chaîne de caractères (nombre total de caractères disponibles
avant de devoir agrandir la taille du buffer interne).
♣ La capacité est automatiquement augmentée lorsque c'est nécessaire. La
capacité initiale peut être définie lors de la création d'un objet StringBuffer
(paramètre du constructeur, 16 par défaut).
♣Ne pas confondre capacité et longueur d'un objet StringBuffer

Classe StringBuffer

Classe StringBuffer
Différentes méthodes permettent de manipuler les objets de

type StringBuffer :

Héritage
Héritage simple
Héritage
Ø L’héritage permet de réutiliser ce qui a déjà été fait très simplement
❙ La nouvelle classe (fille) hérite d’une classe existante (Mère)
❙ Elle possède les mêmes champs et les mêmes méthodes
❙ On peut ajouter de nouveaux champs et de nouvelles méthodes
Ø L’héritage est récursif : une classe dérivée peut devenir classe de base
Ø Les liens hiérarchiques forment un arbre : l’arbre d’héritage
Héritage : Syntaxe

Accès au membre des
superclasses

Héritage : Exemple

Généralisation
La relation d'héritage ("Est un...") permet de traiter les objets des

sous-classes comme s'ils étaient des objets de leur classe parente (par
généralisation).

Opérateur Instanceof
v L'opérateur instanceof permet de tester (à l'exécution)

l'appartenance d'un objet à une classe donnée.
v Dans l'exemple précédent, on aurait pu écrire :
Remarque : (v1 instanceof Vehicule) est également vrai !

Classe Object
Ø En Java, chaque classe que l'on crée possède une classe parente.
Ø Si l'on ne définit pas explicitement une classe parente (avec extends),
la super-classe par défaut est Object (qui est déclarée dans le
paquetage java.lang).
Ø La classe Object est donc l'ancêtre de toutes les classes Java (c'est la
racine unique de l'arbre des classes).
Ø La classe Object est la seule classe Java qui ne possède pas de classe
parente.
Ø Toutes les classes héritent donc des méthodes de la classe Object (par
exemple toString(), equals(), finalize(), etc).

Héritage et Java

Héritage : Niveaux
Surcharge et redéfinition

Surcharge et redéfinition
surcharge=ajouter des méthode

redéfinition=utilise des méthode existe deja

Héritage : Mettre en commun
Ø Les cercles et les rectangles ont des points communs
Ø On fait donc une classe « mère » qui regroupe les parties communes des cercles et des
rectangles
Ø On peut faire encore plus !!
Héritage : intérêt
q Définir explicitement les liens entre les classes
❙ Une classe augmente ou étend les possibilités d’une autre classe
❙ Une classe adapte le comportement d’une autre classe à un besoin concret
❙ A l’inverse, une classe mère regroupe des comportements communs
❙ Un mélange des trois raisons précédentes
q Exploiter les classes existantes
❙ Sans écrire de code
❙ Sans connaître le code
q Génie logiciel : organisation du développement logiciel
❙ Regrouper les aspects (ici, champs ou méthodes) communs
❙ Définir les accès et les protections des structures de données
❙ Mieux conceptualiser les développements
q Comment ?
❙ Trouver les relations de type « est-un » : classe dérivée
❙ Trouver les points communs et les regrouper : classe mère
Champs hérités privés
class Point { ❚ Impossible d’utiliser les parties privées x et y
private double x, double y; d’un point couleur sans mutateur
….
}
class PointCouleur extends Point {
private int couleur;
/* Les nouveaux constructeurs */
public PointCouleur () {
x=y=0; couleur=0;
} // INTERDIT car x et y privés
public PointCouleur (double a, double b, int c)
{ super(a,b); couleur=c; }
public String toString(){
return (super.toString()+ "couleur "+Integer.toString(couleur));
}
};
public class Ex2 {
PointCouleur a,b;
a=new PointCouleur(1,2,0);
b=new PointCouleur(4,5,255);
System.out.println("a "+a); System.out.println("b "+b);
a.translate(2.,3.); System.out.println("a "+a);
a.x=56; INETRDIT, car main n’est pas une méthode de
PointCouleur
}
}
Champs hérités protected
❚ Utilisation directe des parties protected x et y d’un point
class Point { ❚ Attention à la protection qui peut être détournée
protected double x, double y; ❙ On suppose que Point et PointCouleur sont écrites et on ne
…. dispose pas du source
}
class PointCouleur extends Point {
/* Definition des champs d'un point couleur ; on a déjà x et y */
protected int couleur;
/* Les nouveaux constructeurs */
public PointCouleur () { x=y=0; couleur=0;} // ATENTION : on peut modifier x et y
public PointCouleur (double a, double b, int c) { super(a,b); couleur=c; }
public String toString(){
return (super.toString()+ "couleur "+Integer.toString(couleur));
// super, c’est la classe mere
}
};
class Truand extends PointCouleur {
public void setx(double a) { x=a; }
// Je modifie x, meme si je n’ai pas le code PointCouleur: contraire à la POO
}
public class Ex3 {
public static void main (String []arg) {PointCouleur a,b; Truand c;
a=new PointCouleur(1,2,0); b=new PointCouleur(4,5,255);
System.out.println("a "+a); System.out.println("b "+b);
a.translate(2,3); System.out.println("a "+a);
//a.x=56; A Eviter, car main n’est pas une méthode de PointCouleur
c = new Truand(); System.out.println(c);
//Vraiment pas recommandé; il suffit de déclarer PointCouleur comme classe finale pout être tranquille
c.setx(8); System.out.println(c);
}
}
Champs hérités : conserver la protection
q Pour empêcher n’importe quel utilisateur de modifier les champs protected, il faut
interdire l’héritage
q La classe truand ne peut plus hériter de PointCouleur
class Point {
protected double x, double y;
….
}
final class PointCouleur extends Point { final ==pour interdire l héritage
/* Definition des champs d'un point couleur ; on a déjà x et y */
protected int couleur;
………….
};
class Truand extends PointCouleur { // Interdit car classe PointCouleur est final
public void setx(double a) { x=a; }
}
public class Ex17b {
public static void main (String []arg) {PointCouleur a,b; Truand c;
….
}
}
Champs hérités
Ø Un objet possède tous les champs de sa classe et de sa classe mère, de grand-mère…
Ø Le nom est comme précédemment : objet.nom_du_champ
❙ Le nom de la classe mère n’apparaît pas : si a est un PointCouleur hérite de la classePoint : on
écrit a.couleur, a.x, a.y
Ø Mais
❙ Les protections s’appliquent : les champs privés ne sont accessibles que par les méthodes de
la classe où ils sont définis. Les champs x et y de Point sont privés
❙ Un objet de la classe PointCouleur accède au champ couleur mais pas aux champs x et y s’ils
sont private.
❙ Important quand vous définissez une hiérarchie de classes utilisées par d’autres !!!!
❙ Trop lourd lorsque c’est un ensemble de classes cohérentes comme les Point, PointCouleur
Ø Donc
❙ Le mot clé protected permet l’accès aux champs pour toutes les classes dérivées
❙ Le mot clé final interdit à une classe d’etre superclasse, à une méthode d’etre redéfinie.
Héritage et Polymorphisme
Si l'on considère le diagramme de classes suivant :

Si l'on implémente les classes Animal, Chien et Poisson et

que l'on écrit le code suivant :
Ø Chien milou = new Chien(...);
Ø milou.mange();
Ø La méthode mange() qui sera invoquée est celle qui est

définie dans la sous-classe Chien (car milou est du type
Chien et la méthode mange() est redéfinie pour cette sous-
classe).
Ø Si la sous-classe Chien ne redéfinissait pas la méthode
mange(), ce serait alors la méthode mange() d'Animal qui
serait invoquée (la classe Chien en hériterait).
Comme un Chien est un Animal (relation d'héritage) on peut

écrire le code suivant :
Ø Animal toutou = new Chien(...);
Ø toutou.mange();
q Quelle méthode mange() sera invoquée dans ce cas ?

q C'est toujours la méthode mange() définie dans la sous-
classe Chien qui sera invoquée.
q Même si toutou est une référence de type Animal, c'est le
type de l'objet référencé qui détermine la méthode qui sera
appelée (comportement décrit sous "Redéfinition des
méthodes").
En Java, dans la plupart des situations où il y a des relations

d'héritage, la détermination de la méthode à invoquer n'est pas
effectuée lors de la compilation.
q C'est seulement à l'exécution que la machine virtuelle

déterminera la méthode à invoquer selon le type effectif de l'objet
référencé à ce moment là.
q Ce mécanisme s'appelle "Recherche dynamique de
méthode" (Late Binding ou Dynamic Binding).
q Ce mécanisme de recherche dynamique (durant l'exécution de
l'application) sert de base à la mise en œuvre de la propriété
appelée polymorphisme.
Polymorphisme: Exemple
B b=new A();//erreur
Polymorphisme: Exemple
Remarques:
Les classe abstraites
Classe et méthode abstraite
public class Animation {

...
publ ic void faireManger ( Animal a , Nouriture n ) {
...
a . manger ( n ) ;
...
}.
..
}
Ø Il faut introduire une méthode manger() dans la classe Animal pour

que cela compile
Ø Problème =) quel comportement y décrire puisque la façon de
manger dépend de l’espèce animale ?
Classe abstraite
Classe abstraite
q Intérêts
Il y a plusieurs intérêts à définir des classes abstraites :
Ø Pour interdire l'instanciation d'une classe ;

Ø Pour faire de la factorisation de code en ne donnant qu'une
implémentation partielle.
classe abstraite
q Une classe abstraite est une classe qui contient une ou plusieurs méthodes
abstraites. Elle peut malgré tout contenir d'autres méthodes habituelles (appelée
parfois méthodes concrètes).
q Une méthode abstraite est une méthode qui ne contient pas de corps. Elle
possède simplement une signature de définition suivie du caractère point-virgule
(pas de bloc d'instructions).
q Une méthode abstraite doit obligatoirement être déclarée avec le modificateur
abstract.
q Exemple :
public abstract double area();
q Une classe possédant une ou plusieurs méthodes abstraites devient obligatoirement

une classe abstraite. Cette classe doit également être déclarée avec le modificateur
abstract.
Le règles : Classe abstraite
Les règles suivantes s'appliquent aux classes abstraites :
q Une classe abstraite ne peut pas être instanciée : on ne peut pas créer d'objet
en utilisant l'opérateur new.
q Si une sous-classe d'une classe abstraite n'implémente pas toutes les méthodes
abstraites dont elle hérite, cette sous-classe est elle-même abstraite (et ne peut donc
pas être instanciée).
q Les méthodes déclarées avec l'un des modificateurs suivants : static, private
ou final ne peuvent pas être abstraites étant donné qu'elles ne peuvent pas être
redéfinies dans une sous-classe
Exemple
Considérons la hiérarchie de classes suivantes :
q on veut que toutes les classes disposent de la méthode aire()

retournant l’aire de la figure géométrique définie par la classe.
Exemple
Exemple
obliger la redéfinition des méthode abstract

Exemple
Classes abstraites et polymorphisme
Même si la classe Figure est abstraite, il est tout de même possible de déclarer
des variables de ce type qui pourront recevoir des objets créés à partir des
sous-classes concrètes :
Figure[] dessin = new Figure[3];

dessin[0] = new Rectangle(2.5, 6.8);
dessin[1] = new Cercle(4.66);
dessin[2] = new Carre(0.125);
Le polymorphisme permet ensuite d'invoquer une méthode commune sur

chacun des objets :
double surfaceTotale = 0.0;

for (int i=0; i<dessin.length; i++) { // Calcule la somme
AireTotale += dessin[i].aire(); // les aires des figures
}
Interfaces
Interface
q Une interface est un ensemble d'opérations utilisée pour spécifier un
service offert par une classe.
Ø Elle peut être vue comme une classe sans attributs et dont toutes
les opérations sont spécifiées mais pas définies à priori (ie
vides)‫‏‬
Ø Elle peut être vue comme un contrat ou un modèle que doivent
offrir toutes les classes qui se réclame (implémente) de cette
interface
public interface objetgeometrique {

public int surface();
public void translate(int , int );
}
Interface
q Le corps d'une interface ressemble beaucoup à celui d'une classe abstraite
avec cependant les différences suivantes :
q Une interface ne peut définir que des méthodes abstraites. Le modificateur

abstract n'est pas nécessaire. getters et setters
q Toutes les méthodes abstraites sont implicitement publiques même si le
modificateur public est omis. c a dire par défaut sans indiquer public abstract
q Une interface ne peut pas contenir de méthodes statiques.
q Une interface ne peut pas définir de champs d'instance.
qUne interface peut cependant contenir des constantes déclarées static et
final (tous les champs sont implicitement static et final même si les
modificateurs correspondants sont omis).
q Une interface ne définit pas de constructeur (on ne peut pas l'instancier et
elle n'intervient pas dans le chaînage des constructeurs).
Interface
q les méthodes déclarées dans l’interface doivent être définies dans les
classes qui l’implémentent avec le même nom, le même type pour les
paramètres et le résultat.
q De plus ces méthodes doivent être définies avec le mot-clé public. Ce

mot-clé ne doit pas apparaître dans la déclaration de la méthode dans
l’interface
Interface
Interface
Héritage et Interface
Ø L'implémentation d'une ou de plusieurs interfaces

(implements) peut être combinée avec l'héritage simple
(extends).
Ø La clause implements doit suivre la clause extends.

Interface
Utilisation des interfaces
q Lorsqu'une classe déclare une interface dans sa clause implements,

elle indique ainsi qu'elle s'engage à fournir une implémentation
(c'est-à-dire un corps) pour chacune des méthodes de cette interface.
q Si une classe implémente une interface mais ne fournit pas
d'implémentation pour toutes les méthodes de l'interface, elle hérite
des méthodes (abstraites) non implémentées de l'interface et doit elle-
même être déclarée abstract. une classe implémente une interface si n a pas déclarer les méthodes abstract
il faut declarer que cette classe est abstract
q Si une classe implémente plus d'une interface, elle doit implémenter
toutes les méthodes de chacune des interfaces mentionnées dans la
clause implements (ou alors être déclarée abstract).
Interface
Un modèle de conception impliquant les deux approches constitue la

meilleure solution :
•Création d'une interface (totalement abstraite)
•Création d'une classe abstraite qui implémente l'interface créée et
qui fournit des méthodes par défaut dont les sous-classes pourront
profiter
Avec cette approche, les utilisateurs pourront choisir entre
implémenter l'interface en créant le corps de toutes les méthodes
abstraites ou alors en sous-classant la classe abstraite et en
n'implémentant ou ne redéfinissant que les méthodes nécessaires
(les autres méthodes étant héritées avec le comportement par défaut).
interface------------------------------->classe abstract(pas nécessairement implémenter tout

les méthodes de l interface)
Exemple
public interface Imprimable {

public void print();
}
public abstract class figure
public abstract class Figure implements Imprimable {
impléments IMrimable{
public abstract double perimetre(); // Méthode abstraite pas nécessairement importer les
public abstract double surface(); // Méthode abstraite méthodes de l interface car c est
} un classe abstract
public class Cercle extends Figure {
public static final double PI = 3.14159265358979;
protected double rayon;
public Cercle(double rayon) {
this.rayon = rayon;
}
public double getRayon() { return rayon; }
//redéfinition de méthode
public double perimetre() { return 2*PI*rayon; }
périmètre et surface de classe
public double surface() { return PI*rayon*rayon; } abstract
public void print() { ... } //redefinition des methode de l interface
}
Interface
Les interfaces peuvent avoir des sous-interfaces (tout comme les

classes peuvent avoir des sous-classes). Comme pour les classes, le
mot-clé extends est utilisé pour créer une sous-interface.
public interface Cercle extends Figure{...}
q Une sous-interface hérite de toutes les méthodes abstraites et de
toutes les constantes de son interface parente et peut définir de
nouvelles méthodes abstraites ainsi que de nouvelles constantes.
qUne classe qui implémente une sous-interface doit implémenter les

méthodes abstraites définies directement par l'interface ainsi que les
méthodes abstraites héritées de toutes les interfaces parentes de la
sous-interface.
Héritage multiple
Héritage multiple
q Les animaux sont définis par une classe
q Les animaux volant, nageant, courant sont eux aussi défini par une classe
animaux
Animaux volant Animaux nageant Animaux courant

Héritage multiple
❚ Un canard vole
❚ Un canard court (pas vite)
❚ Un canard nage (mal)
❚ Pour respecter la notion d’héritage, il faut donc que la classe canard hérite
des 3 classes volant, nageant, courant
animaux
Animaux volant Animaux nageant Animaux courant
Canard Truites
Héritage multiple
Héritage multiple
❚ Une truite hérite des champs
❙ Vitesse par Nageant
❙ Poids, nom et cdg par Nageant/Animaux
❚ Un canard hérite des champs

❙ Vitesse par Nageant
❙ Poids, nom et cdg par Nageant/Animaux
❙ Vitesse par Volant
❙ Poids, nom et cdg par Volant/Animaux
❙ Vitesse par Courant
❙ Poids, nom et cdg par Courantt/Animaux
❚ Donc un canard a 3 poids !!!
❚ Il faudrait de l’héritage partagé (cela existe en C++ avec l’héritage virtuel) de manière
à ce que la classe Canard n’hérite qu’une seule fois des champs poids, nom et cdg.
Héritage multiple
❚ Interdit en JAVA : une classe ne peut hériter que d’une seule autre
classe
❚ mais autorisé en C++
❚ Remplacé par la notion d’interface
❚ Qu’est ce qu’une interface en JAVA
❙ Précise des comportements (des méthodes) que doivent avoir les

objets qui en dérive
❙ Ne définit pas ses comportements
❙ N’a pas de champs (hormis des constantes)
❚ Une interface peut hériter d’une autre interface

Héritage multiple
Héritage multiple
class Animaux {
protected int poids;
protected Point cdg;
public Animaux( int p) { poids=p; cdg=new Point(0,0);}
public void deplace(int a, int b) {cdg.translate(a,b); }
public String toString() { return ("Animal : poids "+poids+" au point "+cdg); }
};
interface Volant {
void vole();
public String toString();
};
interface Nageant {
void nage();
};
interface Courant {
void coure();
};
Héritage multiple
class Canard extends Animaux implements Volant, Nageant, Courant {
private int vitessecourse=2, vitessenage=5, vitessevole=3;
private String nom;
public Canard (String name, int p){super(p); nom=new String (name); }
public String toString() { return ("Canard "+nom+" "+super.toString()); }
public void vole() { super.deplace(vitessevole,vitessevole); }
public void nage() { super.deplace(vitessenage,vitessenage); }
public void coure() { super.deplace(vitessecourse,vitessecourse); }
}
Class Chien extends Animaux implements Courant {
private int vitessecourse=10; private String nom;
public Chien (String name, int p){super(p); nom=new String (name); }
public String toString() { return ("Canard "+nom+" "+super.toString()); }
public void coure() { super.deplace(vitessecourse,vitessecourse); }
}
public class Ex {
public static void main (String []arg) { Canard a; Chien b;
a=new Canard("Duffy",10); System.out.println(a);
b = new Chien("Medor",50); System.out.println(b);
a.vole(); System.out.println(a); a.nage(); System.out.println(a);
a.coure(); System.out.println(a);
b.coure(); System.out.println(b);
// b.vole (); }}

Java 2.objet

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Java 2.objet

Transféré par

Droits d'auteur :

Formats disponibles

POO – JAVA

Les classes et les objets

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

❚ Fonction appelée automatiquement lors de la destruction

❚ En java, très peu utilisé car vous ne gérez pas la libération de

p1 = new Point(); // Creation p1

Les attributs et les méthodes

public void translate(double a, double y) {

POO- JAVA Ensa Khouribga

Les membres déclarés avec les modificateurs :

POO- JAVA Ensa Khouribga

3 Java-les fondamentaux (Youssef Saadi /

POO- JAVA Ensa Khouribga

❚ Possibilité pour une fonction ou méthode d’avoir un même nom si

public void affiche() { System.out.println( "x:"+x+" y:"+y);}

System.out.println("Tapez une chaine");

v Ensemble d’objets de même type à accès direct

Ø Création d’un tableau en 3 étapes

POO- JAVA Ensa Khouribga

tableau = new int [nb];

for (int i=0; i<tableau.length ; i++) tableau[i]=2*i+1;

tableau[2+ tableau.length ]=0; // ERREUR : pourquoi ?

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

v Création d’un tableau d’objet : 2 étapes

v Exemple : tableau de points

POO- JAVA Ensa Khouribga

Calculer le cosinus d'un angle Math.cos ( )

Calculer le sinus d'un angle Math. sin ( )

Calculer la tangente d'un angle Math.tan ( )

Calculer le logarithme d'une valeur Math.log ( )

Calculer l'exponentielle d'un nombre Math.exp ( )

Arrondir à l'entier inférieur Math.floor ( )

POO- JAVA Ensa Khouribga

Calculer la racine carrée d'un nombre Math.sqrt ( )

|a| (valeur absolue de a) Math.abs ( )

Trouver la plus grande de deux valeurs Math.max ( )

Trouver la plus petite de deux valeurs Math.min ( )

Tirer un nombre au hasard entre 0 et 1 Math.random ( )

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

POO- JAVA Ensa Khouribga

L'opérateur "+" permet de concaténer (mettre bout à bout) des