JAVA - POO
POO
POO
POO
POO
POO
POO
POO
POO
Écrivez une fonction
● Il existe trois types de classes :
Les classes modèles qui sont utilisées comme modèles pour l'instanciation des
objets.
Les classes utilitaires qui contiennent des méthodes statiques qui peuvent être
appelées directement sur la classe.
Les classes services qui contiennent des méthodes ou des services
POO
POO
POO
POO
POO
POO
POO
POO
POO
Concepts clés de la POO en Java :
● Encapsulation
● Héritage
● Polymorphisme
● Abstraction
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Encapsulation
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Héritage
Polymorphisme
Polymorphisme
Polymorphisme
Polymorphisme
Polymorphisme
Polymorphisme
Polymorphisme
Polymorphisme
Polymorphisme
Classe Abstraite
Une classe abstraite est une classe incomplète. Elle regroupe un
ensemble d'attributs et de méthodes mais certaines de ses
méthodes ne contiennent pas d'instructions, elles devront être
définies dans une classe héritant de cette classe abstraite.
67
A quoi ça sert ?
En général à définir les grandes lignes du comportement
d'une classe d'objets sans forcer l'implémentation des
détails de l'algorithme.
Pourquoi "abstraite" ?
Une classe est abstraite soit parce qu'on n'est pas capable
d'écrire l'implémentation de toutes les méthodes, soit parce
qu'on ne veut pas créer d'instance de cette classe.
68
Une sous-classe qui n'implémente pas toutes les méthodes
abstraites de sa super-classe est elle-même abstraite. Il faut
donc la qualifier d'abstraite.
Quand on ne peut pas écrire d'implémentation pour une
méthode donnée, cette méthode est qualifiée d'abstraite.
Cela signifie que l'on laisse le soin aux sous-classes
d'implémenter cette méthode.
En java, c'est le mot clef abstract qui permet de qualifier
d'abstraite une classe ou une méthode
69
Règles d'utilisation des classes abstraites
Règle 1 : Une classe est automatiquement abstraite si une de ses méthodes est abstraite.
Règle 2 : On peut aussi déclarer qu'une classe est abstraite par le mot clef abstract.
Règle 3 : Une classe abstraite n'est pas instanciable ( on ne peut pas utiliser les constructeurs
d' une classe abstraite et donc on ne peut pas créer d'objet de cette classe. ).
Règle 4 : Une classe qui hérite d'une classe abstraite ne devient concrète que si elle
implémente toutes les méthodes abstraites de la classe dont elle hérite.
Règle 5 : Une méthode abstraite ne contient pas de corps, mais doit être implémentée dans
les sous-classes non abstraites:
abstract nomDeMéthode (<arguments>);
ce n'est qu'une signature
Règle 6 : une classe est abstraite peut contenir des méthodes non abstraites et des
déclarations de variables ordinaires.
Règle 7 : Une classe abstraite peut être dérivée en une sous-classe :
abstraite si une ou plusieures méthodes ne sont pas implémentées par la classe fille,
non abstraite si toutes les méthodes abstraites sont implémentées dans la classe fille.
Le Rôle des classes abstraites :
dénomination commune de classes que l'on ne veut pas voir exister en tant que tel.
outil de spécification 70
Exemple
On modélise la tarification du transport d'une marchandise :
Une marchandise comporte un poids et un volume
Le tarif d'un transport est toujours le produit d'un prix unitaire par
l'encombrement de la marchandise transportée.
Pour le transport aérien, l'encombrement est le poids de la marchandise. Le tarif
sera 10 fois supérieur à l'encombrement.
Si on veut un transport aérien urgent, il faut payer deux fois plus cher que le tarif
normal.
Pour le tarif routier, l'encombrement est le volume de la marchandise. Le tarif
sera 2 fois supérieur à l'encombrement.
71
Voici le diagramme de classes en UML
72
Voici les sources java (sans la classe Marchandise pour simplifier) :
abstract class Transport {
protected Marchandise m ;
public Transport (Marchandise m)
{
this.m = m ;
}
public int tarif() {
return prixUnitaire() * encombrement() ;
}
abstract public int prixUnitaire() ;
abstract public int encombrement() ;}
73
class Aerien extends Transport{
public Aerien (Marchandise m) {
super(m) ; }
protected int prixUnitaire(){ return 10 ; }
protected int encombrement(){
return [Link]() ; }
}
74
class Urgent extends Aerien{
public Urgent (Marchandise m) {
super(m) ; }
protected int prixUnitaire(){
return 2 * [Link]() ; }
}
75
class Routier extends Transport{
public Routier (Marchandise m){
super(m) ; }
protected int prixUnitaire(){ return 2 ; }
protected int encombrement(){
return [Link]() ; }
}
76
Interfaces
A quoi sert une interface ?
Elles sont utiles pour des équipes qui travaillent sur un
même projet, chacune doit pouvoir connaitre les méthodes
qui seront implémentées par les autres et leur spécification
pour pouvoir inclure les appels dans leurs propres
méthodes.
77
Une interface ne comporte que des constantes et des méthodes abstraites. Elle
n'est pas classe abstraite .
Une classe peut implémenter une ou plusieures interfaces, c'est à dire définir le
corps de toutes les méthodes abstraites. C'est l'héritage multiple de Java.
[<modificateurs d'accès>] interface <nomInterface> [implements <interfaces>] {
<constantes> <méthodes abstraites> }
❑ les constantes sont explicitement ou implicitement static et final :
■ [<modificateurs>] static final <type> <nomVariable> = <valeur> ;
■ [<modificateurs>] <type> <nomVariable> = <valeur> ;
❑ les méthodes sont explicitement ou implicitement abstraites :
■ [<modificateur>] <type> <nomMéthode> ([<paramètres formels>]);
■ [<modificateur>] abstract <type> <nomMéthode> ([<paramètres formels>]);
78
Une classe qui implémente une interface doit
définir le corps de toutes ses méthodes
abstraites.
Les sous-classes d'une super-classe qui
implémente une interface, héritent (et
peuvent redéfinir) des méthodes
implémentées.
79
Exemple d'implémentation
public interface Animal
{
// tous les animaux doivent implémenter les méthodes suivantes
void manger(String nourriture);
void seDeplacer();
void respirer();
}
80
public interface Parler
{
// une interface plus spécifique
void parle(int phrase);
}
public interface Aboyer
{
void aboie();
} 81
public class Homme implements Animal, Parler
{
//implémentations de l'interface Animal
public void manger(String nourriture)
{
[Link]("Miam, " +nourriture+ "!");
}
public void seDeplacer()
{
[Link]("déplacement de l'homme");
}
public void respirer()
{
[Link]("respiration de l'homme");
}
//implémentations de l'interface Parler
public void parle(int phrase)
{
[Link](phrase);
}
}
82
public class Chien implements Animal, Aboyer
{
//implémentations de l'interface Animal
public void manger(String patee)
{
[Link]("Miam, " +patee+ "!");
}
public void seDeplacer()
{
[Link]("déplacement du chien");
}
public void respirer()
{
[Link]("respiration du chien");
}
//implémentations de l'interface Aboyer
public void aboie()
{
[Link]("Ouaf!");
}
}
83
L'héritage d'interface est aussi possible en
java. A la différence des classes, l'héritage
multiple est autorisé, ce qui veut dire qu'une
interface peut hériter d'autant d'autres
interfaces que désiré.
84
Exemple :
public interface InterfaceA {
public void methodA();
}
public interface InterfaceB {
public void methodB();
}
public interface InterfaceAB extends InterfaceA, InterfaceB {
public void otherMethod();
}
85
public class ClassAB implements InterfaceAB{
public void methodA(){
[Link]("A");
}
public void methodB(){
[Link]("B");
}
public void otherMethod(){
[Link]("blablah");
}
public static void main(String[] args) {
ClassAB classAb = new ClassAB();
[Link]();
[Link]();
[Link]();
}
} 86
POO:Class Object
Java est un langage qui ne supporte que l’héritage simple. L’arborescence d’héritage est un arbre dont la racine est la
classe Object. Si le développeur ne précise pas de classe parente dans la déclaration d’une classe, alors la classe
hérite implicitement de Object.
La classe Object fournit des méthodes communes à toutes les classes. Certaines de ces méthodes doivent être
redéfinies dans les classes filles pour fonctionner correctement.
● La méthode equals: En Java, l’opérateur == sert à comparer les références. Il ne faut donc jamais l’utiliser pour
comparer des objets. La comparaison d’objets se fait grâce à la méthode equals héritée de la classe Object.
● La méthode hashCode:La méthode hashCode est fournie pour l’utilisation de certains algorithmes, notamment pour
l’utilisation de table de hachage. Le principe d’un algorithme de hachage est d’associer un identifiant à un objet. Cet
identifiant doit être le même pour la durée de vie de l’objet. De plus, deux objets égaux doivent avoir le même code de
hachage.
● La méthode toString:La méthode toString est une méthode très utile, notamment pour le débugage et la production de
log. Elle permet d’obtenir une représentation sous forme de chaîne de caractères d’un objet.
● La méthode finalize:La méthode finalize est appelée par le ramasse-miettes avant que l’objet ne soit supprimé et la
mémoire récupérée. Redéfinir cette méthode donne donc l’opportunité au développeur de déclencher un traitement avant
que l’objet ne disparaisse.
● La méthode getClass: La méthode getClass permet d’accéder à l’objet représentant la classe de l’instance.
POO:Class Object
● La méthode clone:La méthode clone est utilisée pour cloner une instance, c’est-à-dire obtenir une copie d’un objet. Par
défaut, elle est déclarée protected car toutes les classes ne désirent pas permettre de cloner une instance.
Pour qu’un objet soit clonable, sa classe doit implémenter l’interface marqueur Cloneable. L’implémentation par défaut de
la méthode dans Object consiste à jeter une exception CloneNotSupportedException si l’interface Cloneable n’est pas
implémentée. Si l’interface est implémentée, alors la méthode crée une nouvelle instance de la classe et affecte la même
valeur que l’instance d’origine aux attributs de la nouvelle instance. L’implémentation par défaut de clone n’appelle pas les
constructeurs pour créer la nouvelle instance.
RQ:Par défaut, tous les tableaux implémentent l’interface Cloneable et redéfinissent la méthode clone afin de la rendre public.
On peut donc directement cloner des tableaux en Java si on désire en obtenir une copie.
int[] tableau = {1, 2, 3, 4};
int[] tableauClone = [Link]();