Fiche de révision : Maîtrise de l'héritage, des classes et interfaces

📋 Plan du Cours

1. Ereditarietà & estensione
2. Visibilità & campi/méthodes
3. Classe final & immutabilità
4. Classe Object & metodi utilità
5. Overriding & binding dinamico
6. Classi astratte & metodi astratti
7. Interfacce & contratti
8. Classi generiche & parametri di tipo
9. Classi wrapper & autoboxing

📖 1. Ereditarietà & extension

🔑 Notions clés & Définitions

• Ereditarietà : Meccanismo per cui una classe (sottoclasse) acquisisce campi e metodi di un’altra classe (superclasse), rispettando il principio "è un".
• Estensione (extends) : Parola chiave in Java che indica che una classe deriva da un’altra, ereditandone le proprietà.
• Visibilità e ereditarietà :
  • Campi/metodi public e protected sono ereditati automaticamente.
  • Campi/metodi senza specificatore sono ereditati solo nello stesso package.
  • Campi private non sono ereditati.
• Classe Object : Classe base implicita da cui derivano tutte le classi Java, contenente metodi di utilità come toString(), equals(), hashCode().
• Final : Keyword che indica che campi, metodi o classi non possono essere modificati o estesi. Campi final sono costanti, classi final non possono essere estese.

📝 Points essentiels

• Una classe può estendere una sola altra classe (extends), ma può implementare più interfacce.
• La relazione di ereditarietà implica che le sottoclassi possono ridefinire (override) i metodi della superclasse, con binding dinamico.
• I metodi public e protected sono ereditati e disponibili nelle sottoclassi; i metodi private no.
• La keyword super permette di chiamare costruttori o metodi della superclasse.
• Le classi astratte (abstract) definiscono metodi astratti (senza implementazione) che devono essere implementati dalle sottoclassi; non sono istanziabili.
• Le interfacce definiscono un contratto di metodi che le classi devono implementare; possono contenere metodi default con implementazione.
• La risoluzione dei metodi ridefiniti avviene tramite binding dinamico, favorendo il polimorfismo.
• La keyword final impedisce l’override di metodi e l’estensione di classi.

💡 À retenir

L’ereditarietà in Java permette di riutilizzare e specializzare il comportamento delle classi, con un controllo preciso sulla visibilità e sulla possibilità di ridefinire i metodi, favorendo il polimorfismo e la progettazione modulare.

📖 2. Visibilità & campi/méthodes

🔑 Notions clés & Définitions

• Visibilité (modificateurs d'accès) : Définissent la portée et la visibilité des membres (champs, méthodes) d'une classe.

  • public : accessible depuis n'importe quelle classe.
  • protected : accessible dans la même package et dans les sous-classes.
  • private : accessible uniquement dans la classe où il est défini.
  • package-private (par défaut) : accessible dans le même package, sans modificateur spécifique.

• Héritage : Mécanisme permettant à une classe (sous-classe) d'acquérir les champs et méthodes d'une autre classe (super-classe).

  • La relation doit respecter le principe "est un" (ex : LivreOOP est un Livre).
  • La classe peut étendre une seule classe (Java).

• Méthodes et champs hérités :

  • Public/protected membres sont automatiquement hérités.
  • Membres sans modificateur (package-private) sont hérités dans le même package.
  • Membres privés ne sont pas hérités.

• Classe Object : Classe racine de toutes les classes Java, fournissant des méthodes fondamentales (equals(), toString(), hashCode(), etc.).

• Override (surcharge) : Redéfinition d'une méthode héritée dans une sous-classe avec la même signature.

  • La liaison dynamique (binding) détermine la méthode appelée à l'exécution selon le type réel de l'objet.

• Binding dynamique : La décision de la méthode à invoquer est prise lors de l'exécution, permettant le polymorphisme.

• Super : Mot-clé permettant d’accéder aux membres ou constructeurs de la super-classe depuis la sous-classe.

• Classe abstraite : Classe qui ne peut pas être instanciée, contenant des méthodes abstraites (sans implémentation) et/ou concrètes.

  • Nécessite que ses sous-classes implémentent les méthodes abstraites.

• Interface : Contrat définissant des méthodes (sans corps) que les classes doivent implémenter.

  • Peut contenir des constantes, méthodes abstraites, méthodes par défaut (default) et méthodes statiques.
  • Une classe peut implémenter plusieurs interfaces.

• Polymorphisme : Capacité à traiter des objets de différentes classes via une interface commune ou une classe parent.

📝 Points essentiels

• La visibilité influence la capacité d'accès aux membres d'une classe, impactant l'encapsulation.
• L'héritage en Java est simple : une classe ne peut étendre qu'une seule classe, mais peut implémenter plusieurs interfaces.
• Les membres public et protected sont hérités automatiquement, private non.
• La méthode toString() de la classe Object peut être redéfinie pour fournir une représentation textuelle d’un objet.
• La conversion de types entre super- et sous-classes peut se faire via upcast (automatique) ou downcast (avec vérification instanceof).
• Le binding dynamique permet la sélection du bon méthode lors de l'exécution, favorisant le polymorphisme.
• Les classes abstraites et interfaces permettent de définir des contrats et des comportements communs sans implémentation concrète.
• Les classes anonymes et génériques facilitent la programmation concise et flexible.

💡 À retenir

La gestion de la visibilité, l'héritage, et le polymorphisme en Java permettent une programmation orientée objet robuste, modulable et réutilisable, tout en respectant le principe d'encapsulation.

📖 3. Classe final & immutabilità

🔑 Notions clés & Définitions

• Classe final : Classe déclarée avec le mot-clé final, elle ne peut pas être étendue (héritée).
• Champ final : Variable déclarée avec final, sa valeur ne peut pas être modifiée après initialisation.
• Immutabilité : Caractère d’un objet dont l’état ne peut pas changer après sa création.
• Constructeur : Méthode spéciale permettant d'initialiser un objet lors de sa création.
• Clé final en Java : Utilisée pour garantir l’immuabilité des champs, méthodes ou classes.
• Classe immuable : Classe dont tous les objets sont immuables, généralement en déclarant tous les champs final et sans méthodes modifiantes.

📝 Points essentiels

• Classe final empêche l’héritage, ce qui garantit que la structure de la classe ne sera pas modifiée par sous-classes.
• Champ final doit être initialisé lors de la déclaration ou dans le constructeur.
• La keyword final ne crée pas une constante en soi, mais empêche la modification de la variable après initialisation.
• Pour créer une classe immuable :
  • Déclarer tous les champs private final.
  • Ne pas fournir de méthodes mutatrices (setters).
  • Initialiser tous les champs dans le constructeur.
  • Si des champs sont des objets mutables, faire une copie défensive lors de l’attribution et de la récupération.
• La classe String en Java est un exemple d’objet immuable.
• La clause final appliquée à une méthode empêche sa redéfinition dans une sous-classe.
• La classe Object est la superclasse de toutes les classes en Java, mais une classe finale ne peut pas être étendue.

💡 À retenir

Une classe déclarée final ne peut pas être étendue, et l’utilisation de champs final permet de garantir l’immuabilité d’un objet, ce qui est essentiel pour la sécurité, la simplicité de gestion et la compatibilité dans la programmation concurrente.

📖 4. Classe Object & metodi utilità

🔑 Notions clés & Définitions

• Classe Object : classe racine de toute hiérarchie en Java, contenant des méthodes fondamentales telles que equals(), toString(), hashCode(), clone(). Toutes les classes héritent implicitement d’elle.
• Héritage : mécanisme permettant à une classe (sous-classe) d’acquérir les propriétés et méthodes d’une autre classe (super-classe). En Java, une classe ne peut étendre qu’une seule classe.
• Overriding (surcharge) : redéfinition d’une méthode héritée dans une sous-classe avec la même signature pour modifier son comportement. La liaison dynamique (binding) détermine la méthode appelée à l’exécution.
• Binding dynamique : mécanisme où la méthode à invoquer est déterminée à l’exécution selon le type réel de l’objet, favorisant le polymorphisme.
• Classe abstraite : classe déclarée avec le mot-clé abstract, pouvant contenir des méthodes abstraites (sans implémentation) et concrètes. Impossible à instancier directement.
• Interface : contrat déclarant des constantes et méthodes abstraites (ou avec implémentation par default). Une classe peut implémenter plusieurs interfaces, définissant un comportement.

📝 Points essentiels

• Héritage de Object : toutes les classes en Java héritent implicitement de Object, ce qui leur donne accès à ses méthodes utilitaires.
• Méthodes de Object : equals() (comparaison d’égalité), toString() (représentation textuelle), hashCode() (code de hachage), clone() (copie d’objet).
• Conversion de types : upcast (automatique, toujours valide) ; downcast (explicite, peut échouer si types incompatibles). Vérifier avec instanceof.
• Override : permet de personnaliser le comportement d’une méthode héritée. La JVM utilise le binding dynamique pour déterminer la méthode à exécuter.
• Utilisation de super : dans le constructeur ou pour appeler une méthode de la super-classe.
• Classes abstraites et interfaces : permettent de définir des comportements génériques ou contractuels. Les classes abstraites peuvent contenir des méthodes concrètes ou abstraites ; les interfaces déclarent uniquement des méthodes (avec ou sans implémentation par défaut).
• Polymorphisme : un même objet peut être référencé par plusieurs types (classe, interface), et la méthode appelée dépend du type réel de l’objet.
• Classes anonymes : classes déclarées et instanciées en une seule étape, souvent pour des implémentations rapides d’interfaces ou classes abstraites.

💡 À retenir

La classe Object constitue la base de toute hiérarchie en Java, offrant des méthodes essentielles pour la gestion et la manipulation des objets. La maîtrise de l’héritage, du overriding, et du polymorphisme est fondamentale pour exploiter pleinement la puissance orientée objet de Java.

📖 5. Overriding & binding dinamico

🔑 Notions clés & Définitions

• Overriding (surcharger ou redéfinir) : La capacité d'une sous-classe à fournir une nouvelle implémentation d'une méthode héritée de la super-classe, en conservant la même signature.
• Binding dynamique (liaison tardive) : La décision de quelle méthode appeler est faite au moment de l'exécution, en fonction du type réel de l'objet, permettant le polymorphisme.
• Binding statique (liaison précoce) : La décision de la méthode à invoquer est prise lors de la compilation, généralement pour les méthodes non redéfinies.
• Polymorphisme : La capacité d’un objet à prendre plusieurs formes, permettant d’appeler la méthode la plus spécifique à l’objet réel, même si référencé par une variable de type super-classe ou interface.
• Super() : Mot-clé utilisé dans le constructeur d'une sous-classe pour invoquer le constructeur de la super-classe.
• instanceof : Opérateur permettant de vérifier si un objet est une instance d'une classe ou d'une sous-classe spécifique, utile pour le downcasting sécurisé.

📝 Points essentiels

• La surcharge (override) nécessite que la signature du méthode soit identique dans la sous-classe.
• La JVM décide, lors de l'exécution, quelle version de la méthode invoquer, favorisant le comportement spécifique de l'objet réel (binding dynamique).
• La méthode super() dans le constructeur permet d’appeler le constructeur de la super-classe, facilitant l'initialisation.
• La vérification instanceof est essentielle pour éviter les erreurs lors du downcast, qui peut échouer si les types ne sont pas compatibles.
• La redéfinition de méthodes comme toString(), equals(), ou hashCode() est courante pour personnaliser le comportement des objets.
• La liaison dynamique permet le polymorphisme, où une référence de type super-classe peut invoquer la version redéfinie dans une sous-classe.

💡 À retenir

Le binding dynamique en Java permet à la JVM de déterminer, au moment de l'exécution, la méthode la plus spécifique à l'objet réel, ce qui est la clé du polymorphisme et de la flexibilité dans la conception orientée objet.

📖 6. Classi astratte & metodi astratti

🔑 Notions clés & Définitions

• Classe abstraite : Classe déclarée avec le mot-clé abstract, ne pouvant pas être instanciée, pouvant contenir des méthodes abstraites (sans implémentation) et concrètes.
• Méthode abstraite : Méthode déclarée sans corps (abstract), doit être implémentée dans les sous-classes concrètes.
• Interface : Contrat définissant un ensemble de méthodes (sans corps, sauf méthodes par défaut) et de constantes, qu'une classe doit respecter en les implémentant.
• Héritage : Mécanisme permettant à une classe d'acquérir les propriétés et comportements d'une autre classe (superclasse).
• Polymorphisme : Capacité à traiter des objets de différentes classes via une référence à une classe ou interface commune, avec la résolution dynamique des méthodes (binding dynamique).

📝 Points essentiels

• Une classe abstraite peut contenir des méthodes abstraites (à implémenter dans les sous-classes) et des méthodes concrètes.
• Les méthodes abstraites doivent être redéfinies dans les sous-classes concrètes ; sinon, la sous-classe doit aussi être abstraite.
• La classe Object est la superclasse implicite de toutes les classes en Java, fournissant des méthodes utilitaires (toString(), equals(), hashCode(), etc.).
• La surcharge de méthodes (override) permet de modifier le comportement hérité, avec un binding dynamique pour la sélection de la méthode à exécuter.
• Les interfaces permettent de définir un contrat de comportement que les classes doivent respecter, supportant la multiple héritage de type.
• La différence entre classe abstraite et interface : la première peut contenir des implémentations, la seconde uniquement des déclarations (sauf méthodes par défaut).
• Les classes abstraites et interfaces favorisent la conception orientée objet en séparant la définition du comportement de son implémentation.

💡 À retenir

Les classes abstraites et interfaces en Java permettent de définir des contrats et des modèles d'objets, favorisant la réutilisation, la modularité et le polymorphisme, tout en empêchant l'instanciation directe de classes trop générales.

📖 7. Interfacce & contrats

🔑 Notions clés & Définitions

• Interface : Contrat de programmation en Java qui déclare un ensemble de constantes et de méthodes sans implémentation. Les classes qui l'implémentent doivent définir ces méthodes.
• Classe abstraite : Classe qui peut contenir des méthodes abstraites (sans corps) et concrètes. Elle ne peut pas être instanciée directement et sert de modèle pour ses sous-classes.
• Implémentation : Processus par lequel une classe fournit le code pour les méthodes déclarées dans une interface ou une classe abstraite.
• Override (surcharge) : Redéfinition d'une méthode d'une superclasse dans une sous-classe, avec la même signature. Permet le polymorphisme dynamique.
• Binding dynamique : Mécanisme par lequel la JVM décide, au moment de l'exécution, quelle version d'une méthode appeler, en fonction du type réel de l'objet.
• Classe générique : Classe paramétrée par des types, permettant de créer des structures de données réutilisables et typées sans duplication de code.

📝 Points essentiels

• Une classe peut implémenter plusieurs interfaces, ce qui favorise la flexibilité et la composition.
• Les méthodes d'une interface sont publiques par défaut, et peuvent avoir des implémentations par défaut (avec default) depuis Java 8.
• Lorsqu'une classe implémente plusieurs interfaces avec des méthodes par défaut identiques, il faut redéfinir la méthode pour résoudre le conflit.
• L'héritage en Java peut combiner classes (avec extends) et interfaces (avec implements), permettant une architecture flexible.
• Les classes abstraites permettent de définir des comportements partagés tout en laissant certaines méthodes à implémenter dans les sous-classes.
• La relation entre interfaces et classes permet de définir des contrats précis pour l'interopérabilité et la modularité du code.
• Les classes génériques facilitent la création de structures de données réutilisables, tout en assurant la sécurité du typage.

💡 À retenir

Les interfaces en Java définissent un contrat que les classes doivent respecter, permettant la programmation orientée contrat et le polymorphisme, tandis que les classes abstraites offrent une base partielle avec des comportements communs, favorisant la réutilisation du code.

📖 8. Classi generiche & parametri di tipo

🔑 Notions clés & Définitions

• Classe generica : Classe parametrée par un ou plusieurs types, permettant de créer des structures de données réutilisables pour différents types sans duplication de code.
• Paramètre de type : Variable de type utilisée dans la déclaration d'une classe ou d'une méthode générique, par exemple <T>.
• Erasure : Processus lors de la compilation où les paramètres de type génériques sont remplacés par Object ou une classe spécifique, limitant la vérification de type à la compilation.
• Classe Wrapper : Classe correspondant à un type primitif en Java (ex. Integer pour int), permettant d'utiliser des types primitifs dans des contextes génériques ou objets.
• Autoboxing / Unboxing : Conversion automatique entre types primitifs et classes Wrapper, simplifiant leur utilisation.

📝 Points essentiels

• La déclaration d'une classe générique se fait avec <T1, T2, ...>, où T représente un type paramétré.
• La création d'une classe générique évite la duplication de code pour différents types, contrairement à la duplication de classes spécifiques (PairInt, PairChar).
• La vérification de type dans les classes génériques est effectuée via la technique de erasure, ce qui limite l'utilisation directe des types primitifs (ex. erreur si Pair<int,int>).
• Les classes Wrapper (Integer, Double, etc.) permettent d'utiliser des types primitifs comme objets, avec des méthodes utilitaires (valueOf, parseInt).
• La syntaxe du autoboxing permet une conversion automatique entre types primitifs et classes Wrapper, simplifiant le code.
• Les méthodes génériques (<T>) permettent de définir des méthodes pouvant traiter différents types sans surcharge.

💡 À retenir

Les classes génériques en Java offrent une flexibilité et une réutilisabilité accrues en permettant de manipuler des types variés de manière sûre, tout en utilisant le processus d'erasure pour assurer la compatibilité. Les classes Wrapper facilitent l'utilisation des types primitifs dans ces structures, notamment grâce à l'autoboxing.

📖 9. Classi wrapper & autoboxing

🔑 Notions clés & Définitions

• Classe Wrapper : Classe Java correspondant à un type primitif, permettant de traiter ces types comme des objets. Exemples : Integer, Double, Boolean, etc.
• Autoboxing : Conversion automatique d’un type primitif en son objet wrapper correspondant lors de l’affectation ou de l’utilisation dans un contexte objet.
• Unboxing : Conversion automatique d’un objet wrapper en son type primitif associé.
• Méthodes de classes wrapper : Méthodes utilitaires telles que valueOf(), parseInt(), intValue(), doubleValue(), etc., pour convertir entre objets wrapper et types primitifs ou chaînes.
• Type générique : Paramètre de classe permettant de définir une classe ou une méthode pouvant manipuler différents types de données, notamment avec des classes wrapper pour gérer la polymorphie dynamique.
• Erasure : Processus lors de la compilation où les paramètres de type générique sont remplacés par Object ou une classe spécifique, limitant la vérification de type à l’exécution.

📝 Points essentiels

• Chaque type primitif (int, char, boolean, etc.) possède une classe wrapper correspondante (Integer, Character, Boolean, etc.).
• L’autoboxing et l’unboxing simplifient la manipulation des types primitifs et des objets wrapper, rendant leur utilisation transparente.
• Les classes wrapper sont immuables, ce qui signifie que leurs instances ne peuvent pas être modifiées après création.
• La conversion entre types primitifs et objets wrapper est automatique dans la plupart des cas, évitant ainsi l’utilisation explicite de méthodes comme valueOf() ou xxxValue().
• Les classes wrapper sont essentielles pour utiliser les types primitifs dans des collections génériques ou des interfaces nécessitant des objets.
• La limitation : on ne peut pas utiliser directement des types primitifs avec des classes génériques sans passer par leurs classes wrapper.

💡 À retenir

Les classes wrapper et l’autoboxing simplifient la manipulation des types primitifs en Java, permettant une intégration fluide entre la programmation orientée objet et les types primitifs, tout en facilitant l’utilisation dans des contextes génériques ou collections.

📊 Tableaux de Synthèse

⚠️ Pièges & Confusions Fréquentes

1. Confondre private et protected : private non hérité, protected hérité dans sous-classes et même dans le même package.
2. Tenter d’étendre une classe final : impossible, cela génère une erreur de compilation.
3. Oublier que private ne permet pas l’accès direct dans une sous-classe, utiliser super pour accéder aux membres protégés ou publics.
4. Mal comprendre le binding dynamique : la méthode appelée dépend du type réel de l’objet, pas du type de référence.
5. Créer une classe immuable sans faire de copie défensive pour les objets mutables contenus.
6. Tenter d’override une méthode final : erreur de compilation.
7. Confondre classe abstraite et interface : une classe abstraite peut contenir des méthodes concrètes, une interface ne peut contenir que des méthodes abstraites (sauf default et static).

✅ Checklist Examen

1. Expliquer la différence entre public, protected, private et package-private en Java.
2. Décrire le rôle de la classe Object et ses méthodes principales.
3. Illustrer le concept d’héritage simple en Java avec un exemple.
4. Expliquer ce qu’est une classe final et ses implications.
5. Définir une classe immuable et donner un exemple.
6. Décrire la différence entre override et surcharge (overloading).
7. Expliquer le binding dynamique et son rôle dans le polymorphisme.
8. Définir une classe abstraite et donner un exemple d’utilisation.
9. Expliquer le contrat d’une interface et comment une classe l’implémente.
10. Décrire comment utiliser le mot-clé super dans une sous-classe.
11. Identifier si une classe peut être étendue ou non si elle est déclarée final.
12. Vérifier si une méthode peut être redéfinie si elle est déclarée final.