Lernzettel: Principes fondamentaux de la programmation Java

📋 Plan du Cours

1. Lecture et écriture de données en Java, types de base et opérateurs logiques
2. Gestion des dates en programmation orientée objet avec constructeurs et méthodes
3. Gestion des exceptions en Java : levée, capture et enchaînement des blocs catch
4. Passage par valeur et passage par référence en Java, impact sur les variables et objets
5. Extension de classes et redéfinition de méthodes dans la gestion de comptes bancaires
6. Décomposition récursive des problèmes et définition de la récursivité directe et indirecte
7. Gestion de la mémoire et modèle d’exécution des appels récursifs en Java
8. Manipulation de listes chaînées : insertion, parcours et suppression d’éléments en Java
9. Utilisation des tableaux et chaînes de caractères en Java, gestion des références et exceptions
10. Exemples pratiques de récursivité : calcul de factorielle, nombres pairs/impairs et suites récursives
11. Construction et modification dynamique de listes avec insertion en fin et élimination d’éléments
12. Trouver la condition d’arrêt de récursivité et la solution dans ce cas - Vérifier que la condition d’arrêt est atteinte après un

📖 1. Lecture et écriture de données en Java, types de base et opérateurs logiques

🔑 Notions clés & Définitions

• Solde : Variable d’instance représentant la quantité d’argent dans un compte, initialisée à 0 par défaut, modifiable par des méthodes comme deposer().
• Main : Solde; } } // fait 2 choses
• Jour : Attribut d’un objet Date représentant le jour du mois, modifiable par des méthodes comme passerAuLendemain().
• Variables d’instance : Variables déclarées dans une classe, propres à chaque objet créé, et accessibles via this pour manipuler l’état de l’objet.

📝 Points essentiels

• Le type int occupe 32 bits en mémoire, char 16 bits, double 64 bits, boolean 1 bit.
• La lecture au clavier se fait avec Terminal.lireInt() et l’écriture à l’écran avec Terminal.ecrireInt() ou Terminal.ecrireIntln().

💡 À retenir

Comprendre les types primitifs et les opérateurs logiques est fondamental pour manipuler les données et interagir avec l’utilisateur en Java.

📖 2. Gestion des dates en programmation orientée objet avec constructeurs et méthodes

🔑 Notions clés & Définitions

• Classe : Type d’objet définissant ses attributs (variables d’instances) et ses méthodes, servant de prototype pour créer des objets.
• This : Mot-clé utilisé dans une méthode pour faire référence à l’objet courant, permettant d’accéder ou modifier ses variables d’instance.
• New Date : Même espace que pour: Personne p = new Personne() pour l’instant, ne contient aucune adresse

📝 Points essentiels

• Le constructeur new Date() réserve l’espace mémoire et initialise un objet Date.
• La méthode passerAuLendemain() modifie les attributs jour, mois, année en fonction de la longueur du mois et des années bissextiles.

💡 À retenir

Le constructeur new Date() réserve l’espace mémoire et initialise un objet Date.

📖 3. Gestion des exceptions en Java : levée, capture et enchaînement des blocs catch

🔑 Notions clés & Définitions

• Déclaration : = throws exception1, exception3 ….

📝 Points essentiels

• Une exception levée dans une méthode non capturée continue son trajet jusqu’à un bloc catch approprié.
• Plusieurs exceptions peuvent être capturées en enchaînant plusieurs blocs catch dans l’ordre.
• La déclaration throws est obligatoire pour les méthodes qui lèvent des exceptions vérifiées (non RuntimeException).
• Les 2 variables référencent le même objet donc toute modification de l’une modifie l’autre. Invoquer des méthodes sur les objets →invoquer les méthodes non statiques de la classe sur les objets instance. ex: c1.afficher(); c2.afficher(); appel sur l’objet courant (objet instance) 5 Les méthodes non statiques - définissent un comportement de l’objet courant, auquel elle font référence avec this dans leur corps - appel avec les noms d’objets, ex: d2.afficherDate(); - déclaration des objets d’instances de la classe - notation pointée sur ces objets → accès à l’état de l’objet (valeur de ses variables d’instances) ou applique une des méthodes de la classe dont il est une instance ex: c1 = objet d’instance de la classe compte. c1. titulaire → accès au titulaire de ce compte c1.deposer(800) → invoque la méthode déposer sur c1 Arguments des méthodes non statiques Argument d’entrée implicite, ne figure pas dans les arguments de la méthode = l’objet courant ex: afficher() de la classe compte n’a besoin d’aucune information supplémentaire à l’objet courant. peut avoir des arguments: ex: déposer prend un montant = information supplémentaire à l’objet sur lequel est invoquée la méthode. Arguments nécessaires = informations nécessaires à la manipulation de l’objet courant. Le corps des méthodes non statiques peuvent consulter/ modifier l’état de l’objet courant pas dans les arguments → this

💡 À retenir

Maîtriser la levée et la capture des exceptions permet de gérer proprement les erreurs et d’assurer la robustesse des programmes Java.

📖 4. Passage par valeur et passage par référence en Java, impact sur les variables et objets

🔑 Notions clés & Définitions

• Passage par valeur : Type primitifs: teste si les entiers contenus sont les mêmes type référence: teste si les adresses sont égales, si elles référencent le même objet exécution: n == m (même valeur) d1 == d2 (adresse du même objet) d1!

📝 Points essentiels

• Les arguments primitifs sont passés par valeur, leur modification locale ne change pas la variable d’appel.
• Les objets sont passés par référence de l’objet, ce qui permet la modification des attributs de l’objet appelé.
• Il est interdit de modifier la valeur des arguments primitifs dans la méthode appelée.
• = fait référence à l’objet sur lequel sera invoquée la méthode ex: void afficher(){ Terminal.ecrireString("solde"+ this.solde); } this.solde = valeur de la variable d’instance solde de l’objet sur lequel est invoquée la méthode. Si pas d’ambiguité → peut omettre this. Invocation de méthodes avec arguments ex: c1.deposer(800); → méthode deposer() prend 1 argument, invoqué sur l’objet en lui passant une valeur Lorsque les méthodes modifient l’état de l’objet ex: méthode deposer() modifie l’état de l’objet courant. Lorsque les méthode retournent un résultat → méthodes non statiques peuvent retourner des valeurs class Compte { int solde; String titulaire; int numero; void afficher(){ Terminal.ecrireString("solde"+ this.solde); } int depot(int montant){ this.solde = this.solde + montant; return this.solde; } } // fait 2 choses = modifie l’état de l’objet courant + retourne l’entier correspond au nouveau solde. public class testDepot { 6 public static void main (String [] arguments){ Compte c1 = new Compte(); c1.solde =100; c1.numero=218; c1.titulaire="Dupont"; Terminal.ecrireIntln(c1.deposer(800)); } } Les types de variables d’instances peuvent être des classes dans une classe: peut utiliser comme type pour les variables d’instances n’importe quel type existant. public class Personne{ Date naissance; // type Date à définir String nom; } public class Date { int jour; int mois; int

💡 À retenir

Les arguments primitifs sont passés par valeur, leur modification locale ne change pas la variable d’appel.

📖 5. Extension de classes et redéfinition de méthodes dans la gestion de comptes bancaires

🔑 Notions clés & Définitions

• Public : Classes filles pas accès aux propriétés privées de la mère, doivent aussi utiliser les méthodes publics 47 - +
• Super : DecouvertMax
• Méthode retrait : Méthode qui effectue le retrait d'un montant sur un compte bancaire, pouvant être redéfinie dans une classe dérivée pour gérer des cas spécifiques comme un découvert autorisé.
• Classe CompteBancaire : Classe de base qui définit les variables d'instance et les méthodes communes à tous les comptes bancaires, telles que le solde et les opérations de dépôt et retrait.

📝 Points essentiels

• La classe CompteAvecDecouvert étend CompteBancaire et hérite de ses attributs et méthodes.
• La méthode retirer est redéfinie dans CompteAvecDecouvert pour gérer un découvert autorisé, permettant de retirer un montant même si le solde est insuffisant, tant que le découvert maximal n'est pas dépassé.
• Le constructeur super permet d’appeler le constructeur de la classe mère avec les paramètres appropriés.
• Un objet de la classe dérivée peut accéder aux méthodes héritées non redéfinies comme si elles appartenaient à la classe dérivée.
• CompteRemunere 48 Accès aux propriétés protected et privé dans la classe, ex / méthode depot super() = appel au constructeur de la superclasse → que dans les constructeurs des classes filles 49 Redéfinition de méthodes héritées (polymorphisme de méthode): - surdéfinition (surcharge), dans la même classe: plusieurs méthodes, même nom dans une même classe, avec signature différente, pour que le système puisse s'y retrouver (cas des constructeurs multiples dans une classe). - redéfinition, que / l’héritage: une nouvelle définition d'une méthode d'une classe : même nom que la méthode parente + signature rigoureusement identique. La redéfinition d'une méthode dans une classe fille cache la méthode d'origine de la classe mère. → Si on a redéfini en classe fille → devient prioritaire lors de l’appel de la méthode → @Override : forcément un héritage Polymorphisme de variable : = quand une même variable peut référencer des objets de types différents, liés à l’héritage. ex: Animal a; a = new Chien(); a = new Chat(); a de type animal, peut contenir Chien ou chat → type réel change comment connaitre le type de l'instance ??? d1 instanceof compteRemunere 50 instanceof = savoir de quel type est l’instance d’objet comme CompteRemunere hérite de CompteBancaire → possible de dire qu’il est du même type que la classe mère = polymorphisme → permet d’appeler la bonne méthode Continuité avec les

💡 À retenir

La classe CompteAvecDecouvert étend CompteBancaire et hérite de ses attributs et méthodes.

📖 6. Décomposition récursive des problèmes et définition de la récursivité directe et indirecte

🔑 Notions clés & Définitions

• Liste : Structure de données permettant de stocker une séquence d’objets d’un même type, accessible séquentiellement en passant d’un élément au suivant, comme dans une liste chaînée.
• Exemple : 3 Récursivité directe et indirecte récursivité directe = Sous-programme fait appel à lui-même récursivité indirecte
• Tableau : Structure de données offrant un accès immédiat à n’importe quel élément par son indice, avec une taille fixe.
• Conclusion : Synthèse indiquant que la décomposition récursive permet de résoudre un problème en le divisant en sous-problèmes plus simples jusqu’à atteindre un cas élémentaire.
• Décomposition en sous-problèmes : Méthode consistant à diviser un problème complexe en sous-problèmes plus simples, eux-mêmes décomposés jusqu’à un niveau d’opérations élémentaires.

📝 Points essentiels

• La récursivité directe correspond à un sous-programme qui s’appelle lui-même.
• La récursivité indirecte implique au moins deux sous-programmes s’appelant mutuellement en boucle.
• 54 En programmation, le sous-programme qui traite le problème fait un appel à lui-même (!) pour traiter le cas plus simple ⇒ appel avec des paramètres différents (“plus simples”) = = appel récursif.

💡 À retenir

La récursivité directe correspond à un sous-programme qui s’appelle lui-même.

📖 7. Gestion de la mémoire et modèle d’exécution des appels récursifs en Java

🔑 Notions clés & Définitions

📝 Points essentiels

• Chaque appel récursif crée une nouvelle instance de sous-programme avec ses propres variables locales.
• La pile d’appels mémorise ces instances jusqu’à la condition d’arrêt.
• La phase de descente correspond aux appels successifs, la phase de remontée correspond au calcul des résultats et retour des valeurs.
• 1 objet = une instance de classe - créé avec new + appel du constructeur, ex: Date d2=new Date(12,6,2003) - valeur propre pour chacune des variables d’instances - application des méthodes de la classe dont ils sont l’instance Définir une classe: - nom - variables d’instances = données caractéristiques des objets de la classe → état - méthodes = pouvant être invoquées sur les objets de la classe → actions sur l’état Variables d’instance - nom + type - au niveau de la classe (ex: solde, titulaire, numero) pour chaque objet instance de la classe compte → valeur pour chacune des 3 variables Les méthodes: premier aperçu Das la classe: autant de méthodes qu’il y a d’opérations utiles sur les objets de la classe - type de retour, nom, arguments + types - méthode d’objet → pas le mot static - peut être utilisée sur n’importe quel objet de la classe Utiliser une classe Déclarer des objets instances de la classe ex: classe compte.

💡 À retenir

Comprendre le modèle mémoire des appels récursifs est essentiel pour anticiper le comportement et éviter les débordements de pile.

📖 8. Manipulation de listes chaînées : insertion, parcours et suppression d’éléments en Java

🔑 Notions clés & Définitions

• Null : GetSuivant(); // on saute le 1er elem, le 2eme devient le nouveau premier } else { // sinon on cherche dans la liste ElementListe precedent
• Trouve : Parcours partiel de la liste : cherche l’élément jusqu’à le trouver ou atteindre la fin de la liste ref!= null
• Variante itérative : Méthode d'implémentation d'opérations sur listes chaînées utilisant des boucles pour parcourir les éléments, évitant ainsi la récursivité.
• Liste chaînée : Structure de données linéaire composée d'éléments appelés maillons, chacun contenant une valeur et une référence vers l'élément suivant, permettant un parcours séquentiel et une gestion dynamique des éléments.

📝 Points essentiels

• L’insertion d’un élément en fin de liste conserve l’ordre d’introduction des éléments.
• Le parcours s’effectue en suivant les références successives des éléments.
• La suppression peut cibler la première occurrence d’une valeur spécifique dans la liste.
• 0). Doit garder les elem dans l’ordre dans lequel ils sont introduits. Une valeur doit être stockée une fois dans la liste Ensuite, lit une autre suite de valeurs, terminée par 0, avec laquelle il construit une autre liste, sans se soucier de l’ordre des élem. les elem de la second liste devront être éliminés de la liste initiale. pour garder les élem dans l’ordre d’instruction, l’insertion d’un nouvel élem doit se faire en fin de liste. on suppose écrire la méthode ajouterAlaFin + méthode contient public class ExempleListes{ public static void main(String[] args){ //1. Creation premiere liste Terminal.ecrireStringln("Entrez les valeurs terminées par un 0"); Liste liste = new Liste(); //liste a construire // premier -> null do{ int val = Terminal.lireInt(); if(val==
• Donc insertion à la place qui préserve l’ordre des éléments (et non en début de liste).

💡 À retenir

La maîtrise des opérations fondamentales sur listes chaînées permet de gérer efficacement des collections dynamiques d’éléments.

📖 9. Utilisation des tableaux et chaînes de caractères en Java, gestion des références et exceptions

🔑 Notions clés & Définitions

• Tableau : Mais l’objet référencé par b a été modifié: 4, 1, 2000 27 Retour sur les tableaux et les strings Tableaux

📝 Points essentiels

• Les tableaux sont des objets dont la référence peut être copiée, mais pas les éléments eux-mêmes.
• Les chaînes de caractères sont des objets immuables, ne pouvant pas être modifiées après leur création.
• L’accès hors limites d’un tableau génère une exception ArrayIndexOutOfBoundsException.

💡 À retenir

Les tableaux sont des objets dont la référence peut être copiée, mais pas les éléments eux-mêmes.

📖 10. Exemples pratiques de récursivité : calcul de factorielle, nombres pairs/impairs et suites récursives

🔑 Notions clés & Définitions

• Exemple : Une illustration concrète utilisée pour démontrer l'application d'un concept ou d'une méthode, notamment en programmation.
• Décomposition récursive (a) Elément de récursivité : Une méthode de résolution de problème qui consiste à exprimer la solution d'un problème en fonction de la solution de sous-problèmes plus simples, souvent en appelant la même fonction de manière répétée.

📝 Points essentiels

• Le calcul de la factorielle utilise un appel récursif avec une condition d’arrêt à n=1, où la fonction s'appelle elle-même pour calculer (n-1)! avant de multiplier par n.
• Les nombres pairs et impairs peuvent être définis par récursivité indirecte, par exemple par des appels mutuels entre deux fonctions qui se réfèrent l'une à l'autre.
• Les suites récursives peuvent être définies par des relations entre termes précédents, utilisant des appels mutuels pour modéliser leur évolution.

💡 À retenir

Les exemples concrets de récursivité montrent comment modéliser des calculs complexes en utilisant des appels successifs de fonctions et des conditions d’arrêt pour éviter une récursion infinie.

📖 11. Construction et modification dynamique de listes avec insertion en fin et élimination d’éléments

🔑 Notions clés & Définitions

• Liste : ⇒ définition qui donne une décomposition récursive des listes cdd générale d’arrêt

📝 Points essentiels

• L’insertion en fin de liste garantit que l’ordre d’introduction est conservé.
• L’élimination d’éléments peut être réalisée en parcourant une seconde liste de valeurs à supprimer.
• La suppression s’arrête si la liste devient vide ou si tous les éléments à supprimer ont été traités.
• 0). Doit garder les elem dans l’ordre dans lequel ils sont introduits. Une valeur doit être stockée une fois dans la liste Ensuite, lit une autre suite de valeurs, terminée par 0, avec laquelle il construit une autre liste, sans se soucier de l’ordre des élem. les elem de la second liste devront être éliminés de la liste initiale. pour garder les élem dans l’ordre d’instruction, l’insertion d’un nouvel élem doit se faire en fin de liste. on suppose écrire la méthode ajouterAlaFin + méthode contient public class ExempleListes{ public static void main(String[] args){ //1. Creation premiere liste Terminal.ecrireStringln("Entrez les valeurs terminées par un 0"); Liste liste = new Liste(); //liste a construire // premier -> null do{ int val = Terminal.lireInt(); if(val==

💡 À retenir

La gestion dynamique des listes permet d’adapter leur contenu en fonction des besoins tout en préservant l’ordre des éléments introduits.

📖 12. Trouver la condition d’arrêt de récursivité et la solution dans ce cas - Vérifier que la condition d’arrêt est atteinte après un

🔑 Notions clés & Définitions

• Cas de base : Condition spécifique dans une fonction récursive qui permet d’arrêter la récursion en fournissant une solution directe sans appel récursif.

📝 Points essentiels

• La condition d’arrêt doit être clairement définie pour éviter une récursivité infinie.
• La vérification de la condition d’arrêt se fait avant ou après l’appel récursif selon le problème.
• Le cas de base correspond à la solution directe sans appel récursif.

💡 À retenir

La condition d’arrêt, correspondant au cas le plus simple résolu directement, doit être rigoureusement identifiée et vérifiée pour garantir la terminaison et la validité des algorithmes récursifs.

📊 Tableaux de Synthèse

Comparaison des structures de données

Type de structure	Accès aux éléments	Taille	Utilisation principale
Liste chaînée	Par références successives	Dynamique	Insertion/suppression efficace en début/fin
Tableau	Accès direct par indice	Fixe	Stockage et accès rapides

Récursivité directe vs indirecte

Type de récursivité	Appel du sous-programme	Cas d'utilisation
Directe	Le sous-programme s'appelle lui-même	Problèmes simples ou récursifs classiques
Indirecte	Deux ou plusieurs sous-programmes s'appellent mutuellement	Problèmes complexes ou décompositions multiples

⚠️ Pièges & Confusions Fréquentes

1. Confusion entre passage par valeur et passage par référence, notamment sur la modification d'objets.
2. Oublier la condition d'arrêt dans une récursion, menant à une récursion infinie.
3. Mauvaise gestion des exceptions, notamment ne pas capturer toutes les exceptions possibles.
4. Utiliser des méthodes non statiques sans créer d'instance appropriée.
5. Inversion de l'ordre lors de l'insertion en début de liste, perdant l'ordre d'insertion.
6. Ne pas vérifier le type réel d'une instance avec instanceof, menant à des erreurs de casting.
7. Confusion entre la mémoire allouée par new et la gestion automatique en Java.

✅ Checklist Examen

1. Maîtriser la déclaration et la gestion des exceptions en Java.
2. Savoir utiliser this pour accéder aux variables d'instance.
3. Comprendre la différence entre passage par valeur et référence.
4. Savoir créer et manipuler des listes chaînées en Java.
5. Connaître les cas de base pour la récursivité.
6. Savoir décomposer un problème en sous-problèmes récursifs.
7. Vérifier la condition d'arrêt dans une fonction récursive.
8. Utiliser les constructeurs et méthodes pour gérer des objets Date.
9. Manipuler les tableaux et chaînes de caractères en Java.
10. Gérer la mémoire lors des appels récursifs.
11. Différencier récursivité directe et indirecte.