Classes et objets
Cycle de vie d'un objet (1/2)
* Exemple de déclaration d'une classe
public class Personne {
...
public Personne(String nom,String prenom) { ... }
...
}
* Variable = référence sur un objet
* Déclaration d'une variable ==> référence nulle
* Personne p;
* Opérateur "new" ==> création + construction d'un objet
* p = new Personne("Nawouak","Bruno");
* Création = allocation de l'espace mémoire pour l'objet
* Construction = initialisation de l'état de l'objet
* Réalisée par l'exécution d'un "constructeur" de la classe
* Constructeur = méthode portant le nom de la classe
Cycle de vie d'un objet (2/2)
* Inutile de détruire explicitement un objet
* Lorsqu'il n'est plus référencé, il est détruit
* Equivalent d'un "smart pointer"
* Destruction automatique
* Par le "garbage collector" (ou "ramasse-miettes")
* Pour demander la destruction d'un objet: p = null;
* "null" = référence sur rien
* Périodiquement, le garbage collector détruit les objets non référencés
* Destruction objet ==> appel méthode "finalize"
* Redéfinition de cette méthode très rare
* Forcer l'exécution du garbage collector
* System.gc();
* Nécessaire lors de la création / destruction rapide d'objets
* Fréquence du garbage collector trop faible ==> surconsommation de mémoire
Définition d'une classe (1/2)
* class nom_classe { ... }
* Accessibilité d'une classe
* public: accessible par tous
* Par défaut: "friendly", accessible par les classes du même package seulement
* Une classe contient des membres
* Attributs
* Méthodes
* Classes internes
* Accessibilité d'un membre
* public: accessible par tous
* protected: accessible par les classes filles ou du même package
* private: accessible par la classe seulement
* Par défaut: "friendly", accessible par les classes du même package seulement
Définition d'une classe (2/2)
* Exemple
public class Personne {
private String nom;
private String prenom;

public String getNom() { return nom; }
public String getPrenom() { return prenom; }
public Personne(String n,String p) {
nom = n;
prenom = p;
}
...
}
Membres de classe (1/3)
* Membre d'instance: propre à un objet
* Par défaut
* Accessible uniquement par l'intermédiaire d'un objet
* Membre de classe: propre à une classe
* Mot-clé "static"
* Pas nécessairement accessible par l'intermédiaire d'un objet
* Exemple: System.out
* Constante
* Combinaison des mots-clé "static" et "final"
* static final int MAX = 100;
Membres de classe (2/3)
* Exemple: compter les instances créées
public class Personne {
private static int compteur = 0;
public static int getCompteur() { return compteur; }
public Personne(String n,String p)
{ nom = n; prenom = p; ++compteur; }
...
}
...
Personne p1 = new Personne("Nawouak","Bruno");
Personne p2 = new Personne("Dupont","Jean");
System.println.out("Nombre de personnes"
+ Personne.getCompteur());
Membres de classe (3/3)
* Attribut de classe ==> initialisation placée dans la déclaration
* static int[] sequence = {1,1,2,3,5,8,13,21,34,55};
* Initialisation déclenchée au chargement de la classe
* Pour une initialisation plus complexe: le bloc d'instructions "static"
* Exécuté au chargement de la classe
* Après l'initialisation des attributs de classe
* Exemple
public class Serie {
protected static int[] sequence = new int[10];
...
static {
sequence[0] = sequence[1] = 0;
for (int i = 2; i < 10; ++i)
sequence[i] = sequence[i-2] + sequence[i-1];
}
}
Convention de nommage
* Classe: MaClasse
* Attribut: monAttribut
* Méthode: maMethode
* Accesseurs: getMonAttribut et setMonAttribut
* Cas des booléens: isMonAttribut et setMonAttribut
* Constantes: MA_CONSTANTE
* Package: monpackage
Héritage (1/2)
* Mot-clé "extends"
* class B extends A { ... }
* B hérite des membres publics et protégés de A
* Attention aux constructeurs: ils ne sont pas hérités
* Héritage possible
* Si classe A visible par B
* Publique ou même package
* Si classe A non "finale"
* finale = n'est pas dérivable
* mot-clé "final": final class A { ... }
Héritage (2/2)
* Classe générale: forme géométrique
public class Forme {
protected double x;
protected double y;
public Forme(double a,double b) { x = a; y = b; }
public double aire() { return 0.0; }
}
* Classe plus spécifique: cercle
public class Cercle extends Forme {
protected double rayon;
protected static final double PI = 3.1415;
public Cercle(double a,double b,double r)
{ x = a; y = b; rayon = r; }
public double aire() { return (PI*rayon*rayon); }
}
Polymorphisme
* Polymorphisme = une méthode peut avoir plusieurs formes
* Définir une nouvelle forme ==> "surcharge" ou "redéfinition"
* Deux types de polymorphismes
* Polymorphisme statique
* "Overloading" / "surcharge"
* Méthodes avec même nom mais signatures différentes
* Détection de la bonne méthode à la compilation
* Polymorphisme dynamique
* "Overriding" / "redéfinition"
* Une sous-classe redéfinit une méthode d'une classe mère
* Détection de la bonne méthode à l'exécution
Polymorphisme dynamique
* Par défaut, une méthode est "virtuelle"
* Elle peut être redéfinie
* Pour empêcher la redéfinition ==> mot-clé "final"
* Méthode "finale" ==> ne peut pas être redéfinie
* Conseil: déclarer les accesseurs en méthodes finales
* public final String getNom() { return nom; }
* Virtualité ==> mauvaises performances ?
* Polymorphisme dynamique
==> recherche de la méthode à appeler à l'exécution
* Optimisation à la compilation plus difficile
* Techniques d'"inlining / unrolling" impossibles
* Attention aux 2 phases de compilation: javac et JIT
* Optimisation faite par JIT
* Depuis version 1.3: HotSpot VM
* Optimisation / déoptimisation en temps réel
Mots-clé "this" et "super" (1/2)
* Appel à une méthode d'instance ==> exécution sur un objet
* x.f() ==> exécution de la méthode "f" sur l'objet "x"
* Dans une méthode, "this" = l'objet qui subit
* Dans "f", "this" représente l'objet "x"
* "super" représente également l'objet qui subit
* Mais vu de la super-classe
* this ==> accès aux membres de la classe courante
* super ==> accès aux membres de la classe mère
* super(): appel au constructeur de la super-classe
* super.m(): appel à la méthode "m" de la super-classe
* super.a: appel à l'attribut "a" de la super-classe
* super.super.a: incorrect
Mots-clé "this" et "super" (2/2)
* Exemple de constructeur
public Cercle(double a,double b,double r) {
super(a,b);
this.rayon = r;
}
* Exemple de méthode redéfinie
public class Texte extends Rectangle {
protected String message;
...
protected void tracerMessage() { ... }
...
public void tracer() {
super.tracer(); // Trace le rectangle
this.tracerMessage(); // Trace le message
}
}
Conversion de type (1/2)
* Possibilité de convertir une variable d'un type vers un autre
* Opérateur de conversion (ou "coercition"): (type)
* Conversion entre types primitifs
* double pi = 3.14;
* int arrondi = (int)pi;
* Conversion entre classes
* Forme f = new Cercle(27,14,38);
* Cercle c = (Cercle)f;
* Conversion ==> autre solution pour accéder à la classe mère
* Dans une classe B qui hérite d'une classe A
* "(A)this" équivalent de "super"
* Si la conversion n'a aucun sens ==> erreur à la compilation
* Lorsque les deux types n'ont aucun lien de parenté
* Exemple: Cercle ==> Personne
Conversion de type (2/2)
* Si la conversion a du sens ==> ok pour la compilation
* Lorsque les deux types ont un lien de parenté
* Vérification éventuelle à l'exécution
* Conversion ascendante ("upcast")
* Spécifique vers général: classe fille vers classe mère
* Toujours possible ==> aucune vérification à l'exécution
* Cercle c = new Cercle(27,14,38);
* Forme f = c;
* Conversion descendante ("downcast")
* Général vers spécifique: classe mère vers classe fille
* Pas toujours possible ==> vérification pouvant lever une exception
* Forme f1 = new Cercle(27,14,38);
Forme f2 = new Rectangle(0,0,320,200);
* f1.rayon() ==> erreur à la compilation
* ((Cercle)f1).rayon() ==> ok à l'exécution
* ((Cercle)f2).rayon() ==> erreur à l'exécution