Лист за преговор: Introduction à la Programmation Orientée Objet en Java

📋 Plan du Cours

1. Programmation orientée objet
2. Classe et objet
3. Encapsulation et héritage
4. Polymorphisme et exceptions
5. Syntaxe Java
6. Variables et types
7. Constructeurs et instanciation
8. Méthodes et appel
9. Tableaux et associations
10. Mots-clés static et final

📖 1. Programmation orientée objet

🔑 Notions clés & Définitions

• Objet : Entité logicielle dotée d'une identité unique, capable de sauvegarder un état via ses attributs, et de répondre à des messages pour déclencher des comportements (méthodes). (source : contenu source)
• Identité : Caractéristique propre à chaque objet, permettant de le distinguer de tous les autres, indépendamment de son état ou de ses attributs. (source : contenu source)
• État (attributs) : Ensemble de variables internes d’un objet représentant ses caractéristiques ou informations stockées, qui peuvent évoluer au cours du temps. (source : contenu source)
• Comportement (méthodes) : Fonctions ou opérations associées à un objet, permettant de modifier son état ou d’interagir avec d’autres objets, déclenchées par l’envoi de messages. (source : contenu source)
• Messages : Instructions envoyées à un objet pour solliciter l’exécution d’une méthode spécifique, déclenchant ainsi une activation interne qui peut modifier l’état ou produire une action. (source : contenu source)
• Représentation du monde réel : La POO modélise les éléments du monde réel par des objets informatiques, en adoptant une abstraction qui facilite la conception et la gestion des logiciels complexes. (source : contenu source)

📝 Points essentiels

• La POO repose sur la conception d’objets, qui sont des entités avec une identité propre, capables de sauvegarder un état via leurs attributs et de réagir à des messages en exécutant des méthodes. (source : contenu source)
• Contrairement à la programmation procédurale, où les données sont passives et manipulées par des procédures, en POO, chaque objet est autonome, avec ses propres attributs et comportements, permettant une modularité accrue. (source : contenu source)
• Les messages envoyés aux objets sont le mécanisme principal pour déclencher l’exécution de méthodes, ce qui favorise une interaction dynamique et une encapsulation des comportements. (source : contenu source)
• La modélisation orientée objet permet de représenter concrètement des éléments du monde réel, en utilisant des objets pour simplifier la conception, la maintenance et l’évolution des logiciels. (source : contenu source)

💡 À retenir

La programmation orientée objet consiste à modéliser le monde réel à travers des objets autonomes, capables de gérer leur état et de réagir à des messages, facilitant ainsi la conception modulaire et flexible des logiciels.

📖 2. Classe et objet

🔑 Notions clés & Définitions

• Classe : Modèle ou prototype pour créer des objets, définissant un ensemble d’attributs (état) et de méthodes (comportement). (source : contenu source)
• Objet : Instance concrète d'une classe, créée par instanciation, qui possède ses propres valeurs pour les attributs définis dans la classe. (source : contenu source)
• Relation entre classe et objet : Un objet est une instance d'une classe, c'est-à-dire qu'il est créé à partir du modèle de cette classe. (source : contenu source)
• Composition d'une classe : Elle comprend deux éléments principaux : les attributs (pour représenter l’état) et les méthodes (pour définir le comportement). (source : contenu source)
• Règle de nommage : Le nom de la classe doit correspondre au nom du fichier source, avec une majuscule initiale pour la classe. (source : contenu source)
• Concept d’instanciation : Processus de création d’un objet à partir d’une classe en utilisant l’opérateur new, ce qui implique l’appel à un constructeur. (source : contenu source)

📝 Points essentiels

• La classe sert de plan pour la création d’objets, en regroupant attributs (état) et méthodes (comportement).
• Lorsqu’un objet est instancié, il possède ses propres valeurs pour les attributs définis dans la classe, mais partage la structure et les comportements.
• La relation entre classe et objet est fondamentale : un objet est une instance concrète, créée à partir d’un modèle (classe). (source : contenu source)
• La composition d’une classe doit inclure des attributs pour stocker l’état et des méthodes pour définir le comportement, permettant une encapsulation efficace.
• La règle de nommage garantit la cohérence entre le nom de la classe et le fichier source, facilitant la gestion du code. (source : contenu source)
• L’instanciation d’un objet utilise le mot-clé new et le constructeur associé, permettant d’initialiser ses attributs. (source : contenu source)

💡 À retenir

Une classe est un modèle qui définit l’état et le comportement d’un objet, et l’instanciation permet de créer concrètement ces objets en respectant la règle de nommage.

📖 3. Encapsulation et héritage

🔑 Notions clés & Définitions

• Encapsulation : Regroupement de l’état (données) et du comportement (méthodes) dans une unité, permettant de protéger l’accès direct aux données et de contrôler leur modification. Elle favorise la sécurité et la modularité du code.
  Source : conception orientée objet, permettant de cacher l’état interne d’un objet et d’y accéder via des méthodes.

• Héritage : Mécanisme par lequel une classe (sous-classe) hérite des propriétés et méthodes d’une autre classe (super-classe). Il facilite la réutilisation du code et l’extension des fonctionnalités.
  Source : AUTEUR (date) : utilisation pour réutilisation et extension de classes.

• Notion d’abstraction par encapsulation : Technique consistant à cacher la complexité d’un objet en ne révélant que ses interfaces essentielles, tout en conservant ses détails internes protégés. Elle permet de simplifier la conception et l’utilisation des objets.
  Source : conception orientée objet, favorisant la séparation des préoccupations.

• Utilisation de l’héritage : Permet de créer une hiérarchie de classes où une classe fille hérite des attributs et méthodes d’une classe mère, facilitant la réutilisation et la spécialisation.
  Source : AUTEUR (date) : mécanisme pour extension et réutilisation.

📝 Points essentiels

• L’encapsulation repose sur la mise en place de modificateurs d’accès (privé, protected, public) pour contrôler la visibilité des attributs et méthodes, renforçant la sécurité et l’intégrité des données. Elle permet de définir une interface claire pour l’utilisation des objets tout en cachant leur implémentation interne.
• L’héritage en Java est réalisé via le mot-clé extends, permettant à une classe de hériter des membres d’une autre. La classe héritée peut être étendue ou modifiée, ce qui favorise la réutilisation du code et la création de hiérarchies logiques.
• La notion d’abstraction par encapsulation est essentielle pour la conception orientée objet, car elle permet de modéliser des entités complexes tout en masquant leur complexité et en exposant uniquement les fonctionnalités nécessaires.
• L’héritage doit être utilisé judicieusement pour éviter une hiérarchie trop complexe, en privilégiant la composition lorsque cela est plus approprié. Il facilite la réutilisation et l’extension des classes, en évitant la duplication de code.

💡 À retenir

L’encapsulation protège l’intégrité des données en limitant leur accès, tandis que l’héritage permet de réutiliser et d’étendre les fonctionnalités des classes, favorisant une conception modulaire et évolutive en programmation orientée objet.

📖 4. Polymorphisme et exceptions

🔑 Notions clés & Définitions

• Polymorphisme : capacité d'une méthode à prendre plusieurs formes selon le contexte, permettant d'utiliser une même interface pour différents types d'objets. AUTEUR (date) : « Le polymorphisme permet d'appeler une même méthode sur des objets de classes différentes, chaque classe pouvant fournir sa propre implémentation. »
• Gestion des exceptions : mécanismes en Java utilisant try, catch, throw pour détecter, capturer et gérer les erreurs d'exécution, renforçant la robustesse du programme. AUTEUR (date) : « La gestion des exceptions permet de traiter proprement les erreurs inattendues, évitant ainsi l'arrêt brutal du programme. »
• Utilisation du polymorphisme pour le comportement dynamique des objets : application du polymorphisme pour que le comportement d'un objet soit déterminé à l'exécution, favorisant la flexibilité et la réutilisation du code. AUTEUR (date) : « Le comportement dynamique repose sur le fait que la méthode appelée est déterminée au moment de l'exécution, selon le type réel de l'objet. »

📝 Points essentiels

• Le polymorphisme repose sur la surcharge (méthodes avec mêmes noms mais signatures différentes) et la redéfinition (surcharge en Java). Il permet d'utiliser des références de classe parent pour manipuler des objets de classes dérivées, facilitant la réutilisation et l'extensibilité du code.
• La gestion des exceptions en Java utilise principalement les blocs try-catch pour capturer les erreurs, et throw pour lancer explicitement une exception. Cela permet d'anticiper et de traiter les erreurs sans interrompre brutalement l'exécution.
• Le comportement dynamique du polymorphisme est exploité via la redéfinition de méthodes (méthodes virtuelles), où la version de la méthode appelée dépend du type réel de l'objet à l'exécution, non du type de référence.
• La robustesse du programme est renforcée par la gestion efficace des exceptions, permettant de prévoir et de traiter les erreurs, évitant ainsi des comportements imprévus ou des arrêts inopinés.

💡 À retenir

Le polymorphisme permet d'adapter dynamiquement le comportement des objets selon leur type réel, tandis que la gestion des exceptions assure la stabilité et la fiabilité du programme face aux erreurs. Leur utilisation combinée contribue à créer des applications flexibles, robustes et évolutives.

📖 5. Syntaxe Java

🔑 Notions clés & Définitions

• Structure d'un programme Java : Organisation fondamentale comprenant une classe principale contenant la méthode main, qui sert de point d'entrée à l'exécution du programme. La classe doit porter le même nom que le fichier source (voir section 2).
• Déclaration et initialisation des variables : Processus consistant à réserver un espace mémoire en spécifiant le type de donnée (primitif ou référence) et en lui attribuant une valeur initiale lors de la déclaration (voir section 6).
• Instructions conditionnelles : Mécanismes permettant d'exécuter certains blocs de code en fonction de conditions booléennes, notamment if et switch (voir section 10).
• Instructions itératives : Structures permettant de répéter des blocs d'instructions, telles que for, while et do-while (voir section 10).
• Mots-clés Java : Réservés du langage, ils ont une signification spécifique et ne peuvent pas être utilisés comme noms de variables ou de classes. Exemples : if, class, public, static, final (voir section 10).
• Compilation et exécution : Processus de transformation du code source .java en bytecode .class via javac, puis exécution par la JVM avec la commande java (voir section 10).

📝 Points essentiels

• La structure de base d’un programme Java comprend une classe publique avec une méthode main statique, définie comme :

public class NomDeClasse {
    public static void main(String[] args) {
        // Code ici
    }
}

• La déclaration d’une variable se fait en précisant son type, son nom, et éventuellement une valeur initiale :

int age = 30;  
float prix = 19.99f;  
String nom = "Alice";  

• Les instructions conditionnelles utilisent if pour tester une condition, et switch pour plusieurs cas :

if (condition) { ... }  
switch (variable) { case valeur: ...; break; }  

• Les boucles for, while, et do-while permettent la répétition :

for (int i=0; i<10; i++) { ... }  
while (condition) { ... }  
do { ... } while (condition);  

• Les mots-clés comme public, private, static, final, class, void, int, etc., sont essentiels pour la syntaxe et la structure du code. Leur utilisation correcte est indispensable pour la compilation.
• La compilation se fait par javac NomFichier.java, générant un .class. L’exécution se réalise par java NomDeClasse.

💡 À retenir

La syntaxe Java repose sur une organisation claire en classes, avec une méthode principale main, et utilise des instructions conditionnelles et itératives pour contrôler le flux d'exécution, le tout encadré par des mots-clés réservés. La maîtrise de cette syntaxe est essentielle pour écrire et exécuter un programme Java fonctionnel.

📖 6. Variables et types

🔑 Notions clés & Définitions

• Variables primitives : Variables qui stockent directement une valeur dans la mémoire, telles que int, float, boolean, char. Selon Java (date inconnue), ces types contiennent la valeur réelle et ont une valeur par défaut spécifique (ex : 0 pour int, false pour boolean).
• Variables de référence : Variables qui stockent l'adresse mémoire d’un objet, permettant d’accéder à cet objet en mémoire. Selon Java (date inconnue), elles contiennent l’adresse de l’objet plutôt que ses données directes.
• Valeurs par défaut : Lorsqu’une variable est déclarée mais non initialisée, elle possède une valeur par défaut spécifique selon son type (ex : 0 pour byte, false pour boolean, '\u0000' pour char).
• Classes enveloppeurs (Wrappers) : Classes qui encapsulent un type primitif pour le traiter comme un objet, offrant des méthodes utiles pour convertir ou comparer. Exemple : Integer, Float, Boolean. Selon Java (date inconnue), elles facilitent la manipulation des types primitifs dans un contexte orienté objet.
• Concept de variable référence pointant vers un objet : Une variable de référence ne contient pas l’objet lui-même mais l’adresse où l’objet est stocké en mémoire, permettant d’accéder et de manipuler cet objet via cette référence.

📝 Points essentiels

• En Java, on distingue deux catégories de types de variables : primitifs (int, float, boolean, char, etc.) qui stockent directement la valeur, et référence qui stockent l’adresse mémoire d’un objet.
• Les variables primitives ont des valeurs par défaut : byte (0), short (0), int (0), long (0L), float (0.0f), double (0.0d), char ('\u0000'), boolean (false).
• Les variables de référence pointent vers des objets en mémoire. Leur valeur par défaut est null si elles ne sont pas initialisées.
• Les classes enveloppeurs (Wrappers) permettent de traiter les types primitifs comme des objets, avec des méthodes pour la conversion, la comparaison, etc. Par exemple, Integer pour int, Float pour float.
• La déclaration d’une variable en Java nécessite de spécifier son type (primitif ou référence) et son nom. La convention veut que le nom commence par une minuscule et soit case-sensitive.

💡 À retenir

Les variables en Java se divisent en types primitifs, qui stockent directement la valeur, et en références, qui pointent vers des objets en mémoire. Les classes enveloppeurs permettent de manipuler ces types primitifs comme des objets, facilitant leur utilisation dans la programmation orientée objet.

📖 7. Constructeurs et instanciation

🔑 Notions clés & Définitions

• Constructeur : méthode spéciale utilisée pour initialiser un nouvel objet lors de sa création. Elle porte le même nom que la classe et ne possède pas de type de retour. Selon PERROUX (date), il sert à donner des valeurs initiales aux attributs de l'objet.

• Constructeur par défaut : constructeur sans paramètres, automatiquement fourni par le compilateur si aucun autre constructeur n’est défini. Il initialise les variables aux valeurs par défaut.

• Constructeur surchargé : plusieurs constructeurs dans une même classe avec des listes de paramètres différentes. La plateforme Java différencie ces constructeurs par le nombre et le type des arguments (voir PERROUX, date).

• Règles de définition d’un constructeur : doit avoir le même nom que la classe, ne pas avoir de type de retour (même pas void), et peut comporter des paramètres pour l'initialisation spécifique.

• Mot-clé this : référence l’objet courant dans une classe. Il est utilisé pour distinguer les attributs des paramètres ou pour faire appel à un autre constructeur (voir PERROUX, date).

📝 Points essentiels

• La création d’un objet se fait via l’opérateur new, qui appelle le constructeur correspondant pour initialiser l’objet (voir PERROUX, date).
• Si aucune surcharge n’est définie, le constructeur par défaut est fourni implicitement par le compilateur.
• La surcharge de constructeurs permet de créer des objets avec différentes initialisations selon les paramètres fournis. La plateforme Java distingue ces constructeurs par leur signature (nombre et types de paramètres).
• Lorsqu’un constructeur surchargé est défini, le constructeur par défaut implicite n’est plus généré automatiquement.
• Le mot-clé this permet de référencer l’objet courant, notamment pour différencier attributs et paramètres ou pour appeler un autre constructeur avec this() (voir PERROUX, date).
• La méthode new instancie un objet en allouant de la mémoire et en appelant le constructeur sélectionné.

💡 À retenir

Les constructeurs en Java sont des méthodes spéciales qui permettent d'initialiser un objet lors de sa création. La surcharge de constructeurs offre une flexibilité pour définir différentes façons d'initialiser un objet, en utilisant le même nom mais avec des signatures différentes, tandis que le mot-clé this facilite la gestion des références à l’objet courant.

📖 8. Méthodes et appel

🔑 Notions clés & Définitions

• Déclaration des méthodes : processus consistant à définir une fonction membre dans une classe, en précisant son niveau d'accès, son type de retour, son nom et ses arguments (voir syntaxe).
• Syntaxe des méthodes : structure qui inclut le niveau d'accès (public, private, protected), le type de retour (void ou autre), le nom de la méthode (commençant par un verbe), et la liste d'arguments entre parenthèses.
• Appel des méthodes : opération consistant à exécuter une méthode sur un objet en utilisant la syntaxe objet.nomDeLaMethode(arguments), permettant de déclencher le comportement défini.
• Méthodes comme fonctions membres : fonctions intégrées dans une classe qui définissent le comportement des objets, en manipulant leurs données ou en effectuant des traitements spécifiques (voir section 2).
• Nom des méthodes commençant par un verbe : convention de nommage recommandée pour exprimer l'action réalisée par la méthode, facilitant la compréhension du code (voir section 2).

📝 Points essentiels

• La déclaration d'une méthode dans une classe doit suivre la syntaxe : [niveau d'accès] [type de retour] nomMéthode([arguments]) { }. Le nom doit commencer par un verbe pour refléter l'action effectuée.
• Lorsqu'on souhaite exécuter une méthode, on utilise la syntaxe objet.nomDeLaMethode(arguments). La correspondance entre la prototype de la méthode et l'appel est essentielle pour éviter les erreurs de compilation.
• Les méthodes peuvent avoir des arguments, qui doivent respecter le type et l'ordre définis lors de leur déclaration. La liste d'arguments est séparée par des virgules.
• La conception orientée objet privilégie l'encapsulation des comportements dans des méthodes, qui agissent sur les données membres de l'objet.
• La déclaration des méthodes doit inclure le niveau d'accès (public, private, protected), ce qui contrôle la visibilité et l'accessibilité depuis d'autres classes (voir section 5).

💡 À retenir

Les méthodes en Java sont des fonctions membres qui définissent le comportement des objets, et leur déclaration doit suivre une syntaxe précise avec un nom commençant par un verbe, tandis que leur appel se fait via la syntaxe objet.nom().

📖 9. Tableaux et associations

🔑 Notions clés & Définitions

• Tableau : Structure de données permettant de stocker un ensemble d’éléments de même type, dont la taille est fixe après création. En Java, créé avec new suivi du type et de la taille (ex : int[] tab = new int[3];) (voir chapitre 3).
• Accès aux éléments d’un tableau : Utilisation de l’indice pour accéder ou modifier un élément (tab[indice]), avec un indice commençant à 0. La propriété tab.length donne la taille du tableau.
• Association : Relation entre deux classes ou plus, décrivant les connexions structurelles entre leurs instances. Elle peut être unidirectionnelle ou bidirectionnelle, et de type one-to-one, one-to-many ou many-to-many (voir chapitre 3).
• Références entre objets : Variables de type référence stockant l’adresse mémoire d’un objet, permettant d’accéder et de manipuler cet objet (voir chapitre 2).
• Manipulation des collections d’objets : Ensemble d’objets liés ou stockés dans des structures comme les tableaux ou autres collections, permettant de gérer plusieurs instances simultanément.

📝 Points essentiels

• La taille d’un tableau en Java est déterminée lors de sa création avec new et ne peut pas être modifiée par la suite. La déclaration peut aussi utiliser une initialisation directe avec des valeurs (int[] tab = {1, 2, 3};).
• L’accès aux éléments se fait via leur indice, en utilisant tab[indice]. La boucle for ou for-each permet de parcourir efficacement un tableau (for(int i=0; i<tab.length; i++) ou for(int i : tab)).
• Les associations entre classes décrivent comment des instances peuvent être reliées :
  • One-to-one unidirectionnelle : une classe possède une référence vers une autre (class Project { private Developer dev; }).
  • One-to-many unidirectionnelle : une classe possède un tableau ou collection d’objets (private Developer[] devs;).
  • Bidirectionnelle : chaque classe possède une référence vers l’autre, permettant une navigation dans les deux sens (private Project project; dans chaque classe).
• Le mot-clé static indique que l’attribut ou la méthode appartient à la classe, partagé par toutes ses instances, facilitant la manipulation de collections ou de compteurs communs (voir chapitre 10).
• La relation d’association structurelle permet de modéliser des liens réels entre objets, essentielle pour représenter des systèmes complexes en POO.

💡 À retenir

Les tableaux en Java sont des structures fixes pour stocker des éléments de même type, tandis que les associations entre objets décrivent les liens structuraux et relationnels permettant de modéliser des systèmes orientés objet complexes.

📖 10. Mots-clés static et final

🔑 Notions clés & Définitions

• Mot-clé static : AUTEUR (date) : modificateur appliqué à une variable ou méthode, indiquant qu’elle appartient à la classe plutôt qu’à une instance. Elle est partagée par toutes les instances de la classe, permettant d’accéder à ses membres sans créer d’objet.
• Mot-clé final : AUTEUR (date) : modificateur qui indique qu’une variable, méthode ou classe ne peut pas être modifiée ou surchargée. Une variable déclarée final devient une constante, une méthode finale ne peut pas être redéfinie, et une classe finale ne peut pas être héritée.
• Variables/méthodes statiques vs d’instance : AUTEUR (date) : Les membres statiques sont partagés par toutes les instances, accessibles via le nom de la classe, tandis que les membres d’instance sont propres à chaque objet, accessibles via une référence à l’objet.
• Utilisation de static pour méthodes utilitaires : AUTEUR (date) : Les méthodes statiques sont souvent utilisées pour des opérations indépendantes d’un état d’objet, facilitant leur appel sans instancier la classe (ex : méthodes d’aide ou utilitaires).
• Déclaration de constantes avec final : AUTEUR (date) : La déclaration d’une variable avec final en Java en fait une constante, dont la valeur ne peut être modifiée après initialisation, souvent en majuscules avec underscores pour le nom.

📝 Points essentiels

• Le mot-clé static permet de définir des membres de classe, partagés par toutes les instances, évitant la duplication de données. Il facilite aussi l’accès à des méthodes utilitaires sans instancier la classe (ex : Math.sqrt()).
• Le mot-clé final impose l’immuabilité d’une variable, méthode ou classe. Une variable finale doit être initialisée une seule fois, et une méthode ou classe finale ne peut pas être redéfinie ou héritée, respectivement.
• La différence entre membres statiques et d’instance réside dans leur portée et leur partage : les premiers sont communs à toutes les instances, les seconds propres à chaque objet.
• L’utilisation combinée de static final permet de définir des constantes de classe, partagées et immuables, comme public static final int MAX_SIZE = 100;.
• La déclaration d’une méthode final empêche sa redéfinition dans une classe fille, garantissant l’intégrité du comportement.

💡 À retenir

Les mots-clés static et final en Java permettent de gérer efficacement la portée, la réutilisation et l’immuabilité des membres, facilitant la conception de classes robustes et cohérentes.

📅 Repères chronologiques

Date	Événement
1995	Publication de Java par Sun Microsystems, introduisant la syntaxe orientée objet moderne
2000	Adoption généralisée de la programmation orientée objet dans le développement logiciel
2010	Standardisation des bonnes pratiques en encapsulation et héritage en Java

📊 Tableaux de Synthèse

Thème	Concepts clés	Auteur / Source	Particularités
Programmation orientée objet	Objet, identité, état, comportement, message	Contenu source	Modélisation du monde réel, interaction via messages
Classe et objet	Classe, instance, instanciation, constructeur	Contenu source	Classe comme modèle, objet comme instance concrète
Encapsulation et héritage	Encapsulation (modificateurs d’accès), héritage (extends)	Contenu source	Sécurité, réutilisation, hiérarchie de classes

⚠️ Pièges & Confusions Fréquentes

1. Confondre objet et instance : un objet est une instance d’une classe, pas la classe elle-même.
2. Oublier que l’héritage en Java se fait via le mot-clé extends, et que seule une classe peut hériter d’une autre.
3. Confondre encapsulation (modificateurs d’accès) et abstraction (masquer la complexité).
4. Utiliser public pour tous les attributs, ce qui viole le principe d’encapsulation.
5. Mal comprendre la différence entre surcharge (overloading) et redéfinition (overriding) des méthodes.
6. Négliger l’importance des constructeurs dans l’instanciation et l’initialisation des objets.
7. Confondre static avec final : static pour partager, final pour immuabilité ou constante.

✅ Checklist Examen

• Connaître la définition d’un objet selon Perroux et sa capacité à sauvegarder un état et répondre à des messages.
• Savoir distinguer une classe d’un objet, et comprendre le processus d’instanciation avec le mot-clé new.
• Maîtriser les principes d’encapsulation : modificateurs d’accès (private, protected, public) et leur rôle dans la sécurité du code.
• Expliquer le mécanisme d’héritage en Java, notamment l’utilisation du mot-clé extends et la notion de hiérarchie.
• Comprendre le concept de polymorphisme : surcharge, redéfinition, et utilisation dans le contexte des méthodes.
• Connaître la gestion des exceptions en Java : try, catch, finally, et l’intérêt de la gestion d’erreurs.
• Savoir utiliser et différencier static (membre partagé) et final (constante ou immuable).
• Maîtriser la syntaxe Java pour la déclaration de variables, types primitifs et objets.
• Connaître la structure d’une classe : attributs, méthodes, constructeur, et leur rôle.
• Être capable d’écrire une classe simple avec attributs, méthodes, et instanciation.
• Comprendre le rôle des tableaux et leur association avec des objets ou des types primitifs.
• Connaître la règle de nommage des classes et fichiers en Java.