Programmation objet avancée
Rappels généraux et en Java
Plan
● Définitions.
● Déclaration et définition d'une classe.
● Instanciation d'une classe.
● Mots-clé Java
Définitions
● Classe : modélisation d'une chose, d'un concept sous la forme d'un couple propriétés/fonctionnalités.
● Attribut : une propriété d'une classe.
● Méthode : une fonctionnalité d'une classe.
● Membre d'une classe : un attribut ou une méthode.
● Sous-classe : classe qui hérite de tout ou une partie des propriétés/fonctionnalités d'une autre classe, dite super- classe.
● Héritage : principe permettant à une sous-classe de manipuler des membres déclarés dans une super-classe.
Définitions
Exemple 1 : classe Véhicule
● Attributs : couleur, nombre de roue
● Méthodes : avancer, tourner
Exemple 2 : classe Camion, hérite de Véhicule
● Attributs (propres à Camion) : immatriculation
● Méthodes (propres à Camion) : contenir
● Membres hérités : couleur, nb roue, avancer, tourner.
Définitions
● Objet : instance (= exemplaire) particulière d'une classe
● Instanciation : processus pour obtenir une instance d'une classe = créer un objet
● Constructeur : méthode particulière utilisée pour créer un objet.
● Destructeur : méthode particulière pour détruire un objet.
Définitions
Remarques :
● Initialisation des attributs dans le constructeur, soit avec une valeur par défaut, soit à partir des paramètres du constructeur,
● Création de deux objets avec les mêmes valeurs d'attributs = 2 clones MAIS PAS le même objet.
● Plusieurs constructeurs possibles, un seul destructeur.
● Destructeur implicite en Java, explicite en C++
Déclaration et définition d'une classe
● En Java, la déclaration et la définition se fait en même temps, dans un fichier .java portant le nom de la classe.
● En C++, on met la déclaration dans un fichier .h et la définition dans un fichier .cpp
● La déclaration des membres permet de spécifier leur droit d'accès :
– public : n'importe quel autre objet peut les manipuler
– protégé : seul un objet de la même classe, ou d'une sous-classe, peut les manipuler
– privé : seul un objet de la même classe peut les manipuler.
Déclaration et définition d'une classe
Attention ! Il n'existe PAS de restrictions d'accès liées à un objet en particulier
Þ un objet de la classe A peut TOUJOURS accéder librement aux membres d'un autre objet de la classe A
● Règle de programmation :
– utiliser le moins possible des attributs public.
– accès aux attributs privés via méthodes publiques nommées getter/setter, qui lisent/écrivent la valeur d'un attribut spécifique + éventuellement des instructions de contrôle.
Déclaration et définition d'une classe
Exemple avec classe Véhicule en Java
class Vehicule {
protected String couleur;
protected int nbRoues;
protected int tonnage;
public Vehicule() { couleur=""; nbRoues = 0; tonnage=0;}
public Vehicule(String couleur, int nbRoue) {
this.couleur=couleur; this.nbRoues = nbRoue; tonnage=0;
}
// ex. de constructeur invalide = même types params. que le précédent public Vehicule(String couleur, int tonnage) { … } // ERREUR COMPIL.
// getter/setter
public void setNbRoues(int nbRoues) { if (nbRoues <0) nbRoues = 0;
this.nbRoues = nbRoues;
} ...
}
Déclaration et définition d'une classe
Remarques :
● Attributs protected/private = utilisation d'un setter pour mettre à jour la valeur.
● Setter contient souvent du code pour vérifier la valeur passée en paramètre.
● Attribut public Þ impossible de forcer l'utilisation du setter Þ absence de vérifications si accès direct Þ erreurs possibles et débogage plus difficile.
● Constructeurs sans type de retour et forcément public.
2 constructeurs ne peuvent avoir le même prototype.
Déclaration et définition d'une classe
Remarques (suite) :
● Appel direct à un constructeur = interdit.
● Cas particulier d'une sous-classe : le constructeur de la sous-classe doit OBLIGATOIREMENT appeler le constructeur de la super-classe.
– en C++, syntaxe spéciale,
– en Java, utilisation du mot-clé super() dans la 1ère ligne d'instruction du constructeur.
Instanciation d'une classe
● Instanciation = appel à un des constructeurs d'une classe.
● Appel à un constructeur = utilisation du mot-clé new.
● Avant tout, l'instanciation permet de réserver un espace mémoire pour contenir les données d'un objet (= les attributs + données de gestion de l'objet).
● Ensuite, les instructions contenues dans le constructeur sont exécutées.
● new renvoie un pointeur vers l'espace mémoire contenant l'objet.
Instanciation d'une classe
// en C++
MaClasse *m1, *m2, *m3 = NULL;
m1 = new MaClasse(...);
m2 = new MaClasse(...);
...
m3 = m1;
// en Java
MaClasse m1, m2, m3;
m1 = new MaClasse(...);
m2 = new MaClasse(...);
...
m3 = m1;
Après les 2 new, 2 objets existent et m1/m2 contiennent respectivement leur adresse en mémoire.
ATTENTION (que ce soit du C++ ou du Java) :
● m3 = m1 N'EST PAS une copie de l'objet m1 dans m3.
● m3 = m1 EST une copie de l'adresse de m1 dans m3.
Þ C'EST une façon d'avoir deux noms pour un même objet.
Mots-clé Java : extends et implements
● extends = déclaration un héritage
● implements = déclaration d'implémentation d'une classe interface.
class SousClasse extends SuperClasse implements Comparable,Throwable { ...
}
ATTENTION :
● héritage d'une seule et unique classe.
● implémentation possible de plusieurs interfaces (cf. TDs)
Mots-clé Java : this
● this = référence l'objet courant.
Þ Pour un objet, utiliser this = dire « moi ... »
ATTENTION ! uniquement 2 cas d'utilisation de this : 1. Ambiguïté entre un attribut et un paramètre.
class MaClasse {
private int value;
...
public void setValue(int value) {
// ambiguïté entre attribut et paramètre value.
// this.value = l'attribut this.value = value;
} ...
}
Mots-clé Java : this
2. L'objet doit se donner lui-même en paramètre à une méthode.
Exemple dans le cas d'un référencement « croisé » :
class A {
private B myB;
...
public void setB(B b) { myB = b;
myB.setA(this);
} ...
}
class B {
private A myA;
...
public void setA(A a) { myA = a;
} ...
}
Cette façon de faire assure que myB et myA soient correctement initialisés.
Mots-clé Java : this
Remarques :
● En dehors de ces 2 cas, utiliser this = INUTILE, SANS EFFET, STUPIDE, ...
● En Python, toute utilisation d'un membre doit être précédée de this Þ complètement débile car utilisation aveugle = incompréhension quant à son utilité = « mon code ne fonctionne pas alors je rajoute this … au cas où »
Mots-clé Java : super
● super(...) = appel au constructeur d'une super-classe
ATTENTION ! Obligatoirement la 1ère ligne d'un constructeur d'une sous-classe.
class B extends A { private String s;
...
public B(String s) { super();
this.s = s;
}
public B(String s, int value) { super(value);
this.s = s;
} ...
} class A {
protected int value;
...
public A() { value = 0;
}
public A(int value) { this.value = value;
} ...
}
Mots-clé Java : super
● super.nom_membre = manipulation d'un membre de la super classe redéfinit dans la sous-classe
class B extends A { private String s;
...
public String toString() {
String m = super.toString();
return m+" s = "+s;
} ...
} class A {
protected int value;
...
public String toString() { return "value = "+value;
} ...
}
Mots-clé Java : final
● final = empêche la modification de l'élément (attribut, méthode, classe, …) devant lequel il est utilisé
final class A {
public final double pi = 3.14159;
...
public final void toto() { ...
} ...
}
● pour class = impossible de créer une sous-classe,
● pour attribut = valeur non modifiable = constante,
● pour méthode = impossible à redéfinir dans une sous-
Mots-clé Java : static
● static :
– devant un attribut : il est partagé par toutes les instances de la classe.
– devant une méthode : peut être appelée sans avoir besoin de créer un objet.
class A {
private static int nb = 0;
...
public A() { nb++; ... } ...
public int getNb() { return nb; } ...
public static void tutu() { ... } ...
}
...
A a1 = new A();
A a2 = new A();
System.out.println(a1.getNb());
System.out.println(a2.getNb());
// affiche deux fois 2 ...
A.tutu(); // appel méthode static a1.tutu(); // fonctionne aussi
Mots-clé Java : instanceof
● instanceof = test de la classe d'instance d'une variable objet. Utilisé essentiellement en cas de polymorphisme.
soient : class A, class B extends A, class C extends A List<A> list = new ArrayList<A>();
list.add(new A());
list.add(new B());
list.add(new C());
...
A a = list.get(index);
if (a instanceof A) { ... }
else if (a instanceof B) { ... } else if (a instanceof C) { ... }
ATTENTION ! instanceof est une hérésie de la POO.
![The ALPINE-ALMA [CII] survey - The nature, luminosity function, and star formation history of dusty galaxies up to z ≃ 6](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==)