Variables static et final

Spécificateurs

• "static" et "final" sont des spécificateurs importants en programmation orientée objet

Membres Statiques

• Les membres "static" ne sont pas liés à une instance particulière d'une classe.
• Ils existent avant même toute instanciation.
• Ils ne peuvent pas accéder aux membres non "static" (d'instance).
• Ils sont partagés par toutes les instances de la classe.
• Ils sont initialisés une seule fois lors du chargement de la classe.

Syntaxe des membres statiques

• Pour déclarer un attribut ou une méthode statique, utilisez le mot-clé "static" dans la définition de la classe:
  • class NomClasse { accès static type attribut; accès static type methode(...) { ... } }

Attributs de Classe

• Les attributs "static" sont initialisés lors du chargement de la classe.
• L'accès se fait via la classe elle-même ou une instance.
• Ils sont utilisés pour stocker des informations communes à toutes les instances, comme des constantes ou des compteurs.

Méthodes de Classe

• Les méthodes "static" ne peuvent accéder qu'aux membres statiques de la classe.
• Elles sont accessibles via la classe ou une instance.
• Utiles pour des opérations utilitaires (comme les méthodes de la classe Math) ou pour manipuler des instances de la classe.

Initialisateur Statique

• Un initialisateur "static" permet d'effectuer des initialisations complexes de membres "static".
• Syntaxe: class NomClasse { static { // instructions } }

L'importance de "final"

• "final" signifie non modifiable

Significations de "final" selon le contexte

• "final type attribut": l'attribut est une constante. Si le type est simple, sa valeur ne peut être modifiée. Si c'est une classe, sa référence ne peut être changée.
• "type nomMethode(final type param, ...)": Le paramètre ne peut être modifié dans la méthode.
• "final type nomMethode(...)": La méthode ne peut être redéfinie dans les classes héritées. Ce comportement est similaire à une méthode "private".
• "final class NomClasse ...": La classe ne peut être dérivée, c'est-à-dire qu'aucune classe ne peut hériter de celle-ci.

Constantes

• Toute constante doit être initialisée soit à la déclaration, soit dans le constructeur (ou initialisateur static)
• L'initialisation peut avoir lieu à la compilation (valeur disponible et placée en dur) ou à l'exécution.

Types de Constantes

• Constante d'instance: Initialisée à l'instanciation, chaque instance a sa propre constante.
• Constante de classe: Déclarée "static", initialisée au chargement, une seule constante pour toute la classe.
• Il est conseillé d'indiquer "final" pour tout attribut qui ne subit jamais d'affectation.

Types Énumérés

• Un type énuméré définit explicitement un ensemble ordonné de valeurs possibles.
• La définition d'un enum peut être interne (inline) ou externe (public ou non) à une classe.

Syntaxe et propriétés des énumérations

• Un "enum" est une classe dérivée de "java.lang.Enum".
• Les valeurs d'un enum sont implicitement "public static final".
• La comparaison des valeurs peut se faire avec "==" ou "equals()".
• Un enum implémente l'interface "java.lang.Comparable".
• Les énumérations disposent des méthodes "toString()" et "valueOf()".
• "ordinal()" donne la position de l'énumération et "values()" permet l'itération.

Réutilisation des Classes

• La réutilisation peut se faire par association (composition/agrégation) ou par héritage.

"A un" vs "Est un"

• La relation « a un » : l'association (composition/agrégation) ; une classe a pour attribut une classe.
• La relation « est un » : l’héritage ; une classe (dérivée) est définie à partir d’une autre classe (base).

Vocabulaire de l'héritage

• Hériter, étendre, dériver sont des termes équivalents.
• Super-classe signifie classe de base ou classe mère.
• Sous-classe signifie classe dérivée ou classe fille.

Caractéristiques de l'héritage

• Création d'un nouveau type.
• La classe fille contient les membres (méthodes et attributs) de la classe de base.
• Les objets des classes filles acceptent les messages des objets de la classe de base.
• Une classe dérivée est du même type que sa classe de base.

Différencier une nouvelle classe

• On peut ajouter de nouveaux comportements ou redéfinir (changer) des comportements existants.

Héritage en Java

• Syntaxe: class ClasseFille extends ClasseMere { // attributs // constructeurs et méthodes }

Super et Super(...)

• "super" permet d'accéder aux attributs (en cas de masquage) et aux méthodes de la classe mère.
• "super(...)" appelle un constructeur de la classe mère.
• Java ne permet pas l'héritage multiple.

Types de Polymorphisme

• Ad-hoc (surcharge) : méthodes de même nom avec des fonctionnalités similaires dans la même classe ou des classes différentes.
• Par héritage (spécialisation) : redéfinition d'une méthode d'une classe mère dans une classe fille. Permet d'envoyer un message à un objet sans se soucier de son type réel.
• Paramétrique (généricité) : Permet de définir des méthodes génériques (abstraction des types).

Surcharge

• Créer une méthode de même nom qu'une autre, mais avec une signature différente (ordre, type et nombre de paramètres).
• Le choix de la méthode à appeler se fait à la compilation (invocation statique).

Redéfinition

• Créer une méthode avec la même signature qu'une méthode de la classe mère, ce qui modifie le comportement pour un même envoi de message.
• Le choix de la méthode à appeler se fait à l'exécution (invocation dynamique).

Masquage

• Dans une classe fille, un membre (attribut ou méthode) de même nom qu'un membre de la classe mère masque ce dernier. Pour y accéder, on utilise "super".

Utilité du Polymorphisme

• Définir un comportement commun dans une classe de base.
• Décliner un comportement différent dans des sous-classes.
• Ne pas se soucier du type manipulé (le type de la classe de base est suffisant).

Covariance en Java

• Fait référence à la possibilité d'utiliser un type plus spécifique que celui initialement spécifié.
• Java accepte la covariance sur les types de retours lors des redéfinitions de méthodes.

Constructeurs et héritage

• Les constructeurs ne sont pas hérités.
• Appel des constructeurs des classes de base en premier.

Fonctionnement des constructeurs

• Par défaut, le constructeur appelle le constructeur par défaut de la classe mère.
• Pour appeler un constructeur spécifique de la classe mère, on utilise "super(...)".

Constructeurs et méthodes polymorphes

• Si un constructeur d'une classe mère appelle une méthode redéfinie dans une classe fille, c'est cette version redéfinie qui est exécutée.

Classe Objet

• "Object" est la super-classe de toutes les classes en Java ("java.lang.Object"), l'héritage est implicite.

Méthodes de Object

• "toString()", "clone()", "equals(Object)", "hashCode()", "finalize()", "getClass()", "notify()", "notifyAll()", "wait()".

La méthode toString()

• Retourne une chaîne descriptive de l'objet (par défaut, le nom de la classe et le "hashCode"). Est appelée automatiquement quand une chaîne est nécessaire.
• Il est recommandé de redéfinir cette méthode pour retourner l'état de l'objet (valeurs des attributs).

la méthode equals()

• Permet de tester l'égalité entre deux objets. Par défaut, vérifie si les deux références pointent vers le même objet.

Des règles sont à respecter pour la méthode equals()

• non null x.equals(null)==false
• réflexive x.equals(x)==true
• symétrique x.equals(y)==y.equals(x)
• transitive x.equals(y)==true et y.equals(z)==true -> x.equals(z)==true
• stable tant que x ou y ne sont pas modifiés x.equals(y) donne la même valeur
• hashcode x.equals(y) x.hashCode()==y.hashCode()

Structure Typique Redéfinition (squelette classique)

• class Demo { ... public boolean equals(Object o) { // ------ VERSION LOURDE ------ if (o==this) // pas indispensable return true; if (o==null || this.getClass() != o.getClass()) // éviter instanceof => pb symétrie return false; // test des attributs puis retour du résultat return ...; // ------ VERSION SIMPLIFIÉE ------ return test type && exprBool1 && exprBool2... } public int hashCode() { // combinaison des hashCode des attributs return 13 * att1.hashCode() + 17 * att2.hashCode(); } } Programmation - Classes et Héritage -

La méthode clone()

• Permet de créer une copie d'un objet.

Fonctionnement de base

• Méthode d'Object = copie bit à bit
• Copie de surface (shallow copy).
• Est "protected" dans Object, donc doit être redéfinie en "public".
• Utilise la covariance dans le type de retour.
• Doit implémenter l'interface "Cloneable".

Squelette de base pour la meéthode clone()

• class Demo implements Cloneable { // attributs public Demo clone() { Object copie=null; try { copie=super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(System.err); } // code de copie spécifique du contenu de l'objet return (Demo)copie; } }