1. this : Le mot-clé this est utilisé à l'intérieur d'une méthode pour désigner l'objet qui appelle cette méthode ; dans un constructeur, this représente l'objet en cours d'initialisation. this permet d'accéder aux variables d'instance, aux méthodes et aux constructeurs, souvent employé dans les setters pour différencier les variables d'instance des paramètres passés.
2. Compréhension de this : Il fait référence à l'objet courant (dans une méthode) ou en cours de création (dans un constructeur).
3. Appel de propriétés et méthodes via this (méthodes non statiques) : Habituellement, une méthode invoquée sur un objet peut accéder aux propriétés ou méthodes de cet objet ; on peut préfixer avec "this." pour indiquer l'appartenance, mais cette notation est généralement omise. Si un paramètre local porte le même nom qu'une variable d'instance, "this." est obligatoire pour les distinguer : avec "this.", il s'agit de la variable d'instance, sinon c'est une variable locale.
De même, dans un constructeur, on peut utiliser "this." pour accéder aux propriétés ou méthodes de l'objet en création, mais cela est souvent omis. En cas de conflit de noms entre paramètres et variables d'instance, "this." est nécessaire pour identifier les variables d'instance.
4. Appel de constructeurs via this :
a. Dans un constructeur, on peut utiliser "this(liste de paramètres)" pour appeler un autre constructeur de la même classe ;
b. "this(liste de paramètres)" doit être la première instruction du constructeur courant ;
c. Il ne peut y avoir qu'un seul appel "this(liste de paramètres)" dans un constructeur ;
d. Si une classe possède N constructeurs, au plus N-1 d'entre eux peuvent contenir un appel "this(liste de paramètres)".
- L'héritage en POO
1. Vue d'ensemble :
Approche descendante : On définit une classe A, puis une classe B qui ressemble fonctionnellement à A ; B peut hériter de A.
Approche ascendante : Pour des classes B, C, D avec des attributs et méthodes similaires, on extrait ces éléments communs dans une classe A, dont B, C, D héritent, évitant ainsi la duplication.
2. Avantages de l'héritage :
(1) Réduction de la redondance et amélioration de la réutilisabilité du code ;
(2) Facilitation de l'extension des fonctionnalités ;
(3) Établissement d'une relation "est-un" entre classes, préalable au polymorphisme.
3. Syntaxe de l'héritage en Java :
public class Parent {
// attributs et méthodes
}
public class Enfant extends Parent {
// attributs et méthodes
}
La classe Parent est appelée superclasse ; la classe Enfant est la sous-classe. L'enfant hérite de tous les attributs et méthodes du parent, mais en raison de l'encapsulation, il peut ne pas y accéder directement. L'enfant peut étendre ses propres fonctionnalités.
4. Classe racine par défaut : Toute classe sans déclaration explicite de parent hérite implicitement de java.lang.Object.
5. Remarques :
(1) Java supporte l'héritage multiniveau (hiérarchie d'héritage) : il existe des parents directs et indirects ;
(2) Une classe parent peut avoir plusieurs enfants, mais une classe enfant n'a qu'un seul parent (héritage simple).
- La redéfinition de méthode
L'enfant hérite de toutes les méthodes déclarées dans le parent. Il peut modifier une méthode héritée, ce qu'on appelle la redéfinition (ou override). À l'exécution, la méthode de l'enfant remplace celle du parent.
1. Définition : L'opération de modification par l'enfant d'une méthode héritée du parent est la redéfinition.
2. Règles de redéfinition :
(1). La méthode redéfinie et la méthode parent doivent avoir le même nom et la même liste de paramètres ;
(2). Le modificateur d'accès de la méthode redéfinie dans l'enfant ne doit pas être moins restrictif que celui de la méthode parent, mais l'enfant ne peut pas redéfinir une méthode déclarée private dans le parent ;
(3). Si la méthode parent a un type de retour void, la méthode redéfinie doit aussi avoir void ;
(4). Si la méthode parent retourne un type primitif, la méthode redéfinie doit avoir le même type de retour ;
(5). Si la méthode parent retourne un type référence (classe), la méthode redéfinie peut retourner le même type ou un sous-type ;
(6). Il n'y a pas d'exigence spécifique sur le corps des méthodes ;
(7). La méthode redéfinie peut lancer le même type d'exception ou une sous-classe d'exception que la méthode parent.
3. Différence entre surcharge et redéfinition :
(1) Surcharge : Même nom, paramètres différents ;
(2) Redéfinition : Après héritage, l'enfant remplace une méthode parent avec le même nom et les mêmes paramètres.
- Le mot-clé super
Dans une classe enfant, super permet d'appeler des méthodes, attributs et constructeurs de la classe parent.
1. Structures appelables avec super :
(1) Attributs et méthodes : Après héritage, l'enfant peut accéder aux attributs ou méthodes du parent (sous réserve d'encapsulation) en utilisant "super." pour les identifier. En général, "super." peut être omis, mais il est nécessaire si l'enfant redéfinit une méthode ou possède un attribut homonyme.
(2) Constructeurs :
a. L'enfant n'hérite pas des constructeurs du parent, mais peut appeler un constructeur parent spécifique via "super(liste de paramètres)" ;
b. "super(liste de paramètres)" doit être la première instruction du constructeur enfant ;
c. Si le constructeur enfant ne contient ni "this(liste de paramètres)" ni "super(liste de paramètres)" explicite, il appelle par défaut "super()" (constructeur parent sans paramètres) ;
d. Chaque constructeur enfant doit soit appeler un autre constructeur de la même classe (via this), soit appeler un constructeur parent (via super), mais pas les deux ;
e. Si une classe possède n constructeurs, au plus n-1 utilisent "this(liste de paramètres)", et le reste utilise "super(liste de paramètres)".
2. Processus d'instanciation d'un objet enfant : Lors de la création d'un objet enfant via son constructeur, ce constructeur appelle directement ou indirectement un constructeur du parent, ce qui charge les attributs et méthodes du parent en mémoire pour l'objet enfant.
- Le polymorphisme
1. Formes et manifestation : Le polymorphisme représente une entité sous plusieurs formes.
2. Manifestation en Java : Polymorphisme d'objet enfant : une référence parent pointe vers un objet enfant (un objet enfant est assigné à une référence parent).
3. Application : appel de méthode virtuel : Dans un contexte polymorphe, à la compilation, la méthode est celle du type déclaré à gauche (parent), mais à l'exécution, c'est la méthode redéfinie par l'enfant qui est exécutée.
4. Prérequis : (1) Relation d'héritage entre classes ; (2) Redéfinition de méthode.
5. Applicabilité : Concerne les méthodes, pas les attributs.
6. Avantages et inconvénients :
(1) Réduction de la redondance, sans nécessiter de surcharges multiples ;
(2) Dans un contexte polymorphe, même si l'objet enfant est créé, la référence parent empêche l'accès direct aux attributs et méthodes spécifiques de l'enfant.
7. Upcast et Downcast :
(1) Upcast : Le type de la variable à gauche (parent) est plus large que le type de l'objet à droite (enfent). À la compilation, on traite selon le type parent, sans accès aux membres spécifiques de l'enfant.
(2) Downcast : Le type de la variable à gauche (enfant) est plus restreint que le type de l'objet à droite (parent). Cela peut causer une ClassCastException ; il est recommandé d'utiliser instanceof (a instanceof A) avant le downcast pour éviter les exceptions.
Si un objet a est une instance de A (a instanceof A retourne true), alors a est aussi une instance de toute superclasse de A (a instanceof superA retourne true).
- La classe Object
1. Compréhension de la classe racine : La classe java.lang.Object est la racine de la hiérarchie des classes ; toutes les autres classes en héritent directement ou indirectement. Object fournit des structures universelles.
(1) Object n'a pas d'attributs déclarés ;
(2) Object fournit un constructeur sans paramètres.
2. Méthodes courantes de Object :
(1) equals()
Applicabilité : Utilisable sur tout type référence.
Description :
a. Pour une classe personnalisée sans redéfinition de equals(), la méthode Object compare les adresses des objets (s'ils référencent la même instance en mémoire) ;
b. Pour String, File, Date et les classes enveloppantes, equals() a été redéfini pour comparer le contenu des objets ;
c. En développement, pour comparer des objets personnalisés par leurs attributs, il faut redéfinir equals().
Opérateur == :
a. Utilisation : types primitifs et types référence ;
b. Pour les primitifs, compare les valeurs ; pour les références, compare les adresses (si elles pointent vers le même objet).
equals() :
a. Applicable seulement aux types référence ;
b. Pour une classe, le comportement diffère selon que equals() est redéfini ou non.
(2) toString()
Définition dans Object :
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Lors de l'appel de System.out.println() avec une référence d'objet, toString() est invoquée. Pour une classe personnalisée sans redéfinition, c'est la méthode Object qui est appelée. Les sous-classes comme String, File, Date redéfinissent toString() pour retourner le contenu de l'objet. En développement, il est courant de redéfinir cette méthode pour afficher le contenu pertinent.
(3) clone() : Copie un objet donné, retourne un Object.
(4) finalize() : Appelée par le ramasse-miettes avant la suppression de l'objet ; les sous-classes peuvent la redéfinir pour effectuer des opérations spécifiques avant la libération.