SQLI : 01. JAVA, les fondamentaux de la programmation

Fil Rouge : Mise en place d’une application qui va gérer des comptes bancaires. Un utilisateur possède des comptes (normaux, à seuil, rémunéré), un compte génère des opérations.  

Chapitre 1 : Présentation de java 

• Introduction 
• Historique de Java, positionnement du langage, licence, notion de LTS. 
• Les caractéristiques de Java, retour sur les versions majeures 5, 8, 11 et 17 
• La programmation objet, portabilité, machine virtuelle, garbage collector 
• Installation et prise en main 
• Quoi télécharger : Différences entre JDK et JRE 
• Mise en place de la variable d’environnement JAVA_HOME, du CLASSPATH et du PATH 
• Les outils du JDK : compilateur (javac), JRE (java), les librairies de base, documentation du code (javadoc). 
• Compilation, déploiement, exécution d’un programme Java en ligne de commande. 

Atelier pratique : Installation du JDK puis compilation et lancement d’une première classe qui affiche bonjour dans la console. 

Chapitre 2 : LE DEVELOPPEMENT AVEC JAVA  

• Structure des programmes Java : Module, Package, Classe, Méthode 
• Les mots réservés du Java 17 (record, sealed, …) 
• Types primitifs et opérateurs. 
• Notion de scope/bloc 
• Les variables (déclaration, affectation) 
• Invariants (String, Class, Wrappers) 
• Encapsulation et visibilité, les 4 niveaux en Java 
• Java.lang.Object : La Superclass et ses méthodes 
• Les tableaux. 
• Structures de contrôle. (if, switch, for, while, do while) 
• Evolutions entre les versions 5, 8, 13 et 14 du Java 
• Types énumérés (enum). 
• Le boxing et unboxing 
• Définition, rôle et utilisation des annotations. 
• La généricité (les generics) 
  • Les exceptions 
    • Lancer (throw) 
    • Rattraper (try, catch, finally) 
    • Laisser remonter (throws) 
    • Hiérarchie des exceptions 
    • Utilisation des 'ressources' et multi-catching 

Chapitre 3 : Les outils de développement Eclipse et InteliJ

• Historique : du Visual Studio d'IBM à Eclipse en terminant sur IntelIJ 
• Comparaison des deux chalengeurs 
• Les objectifs et les principes d'un outil de développement
  • Prix
  • Périmètre
  • Points forts / points faibles 
• Installations et mise en place 
• Notions fondamentales : (Workbench, Vues, Perspectives) 
• Création d’un projet Java, d’un package, d’une classe. 
• L’éditeur de code Java, compilation, réorganisation du code (refactoring). 
• Génération du code (get/set, toString, equals, …) 
• Complétion du code (ctrl+espace) 
• Compiler, sauvegarder, Rebuilder, déboguer un projet 
• Objectif et importance des plugins 
• Focus sur l'importance du respect des normes et de la qualité du code 
  • Via les plugins internes aux outils de développement
  • Comparatif des résultats via un exemple d'analyse dans SonarQube (ou SonarCloud) 

Chapitre 4 : Les outils de build Maven/Gradle 

• Objectif d'un outil de build 
• Présentation de Maven et Gradle 
  • Rôles
  • Fonctionnement 
  • Avantages/inconvénients 
• Mise en place sur les projets
• Focus sur la gestion des dépendances via le fichier pom.xml et build.gradle 

Atelier pratique : Reprise des exercices précédents pour faire usage d'un outil de build. Utilisation des goals principaux (clean, compile, package) 

Chapitre 5 : Les APIs incontournables  

• Les chaînes de caractères 
  • String
  • StringBuffer / StringBuilder 
• L’objet System
• Les dates et calendriers
  • Transformer une chaine en date et inversement
  • Manipuler un calendrier (récupérer un jour, un mois …)
  • La gestion des dates en Java 8 et aux dessus 
• Les collections et dictionnaires (List, Map, Set).
  • Implémentations
  • Parcours (itérateurs, boucles, streams). 
  • Comment les trier 
• Les classes utilitaires Collections, Arrays, Math, Random
• Retour sur les wrappers ou comment convertir une chaine en chiffre et inversement
• Utilisation du log à la place de System.out 

Atelier pratique : Calcul de l’âge d’un client à partir de sa date de naissance. Transformation du tableau des comptes en liste puis en dictionnaire. 

Chapitre 6 : L’acces aux SGBD via JDBC  

• Architecture JDBC 
• Les pilotes JDBC de type 1, 2, 3 et 4
• Classes et interfaces de l’API JDBC
  • Connexion
  • Statement / PrepareStatement / CallableStatement
  • ResultSet 
• Les métas données
• Focus sur les problématiques de sécurités 
  • Ne pas écrire les login/pwd dans le code
  • Gérer ses fermetures correctement 
  • Se protéger de l'injection SQL 

Atelier pratique : Branchement des classe entités Compte, Client, … avec de vraies bases de données (MySQL, PostgreSQL, HSQL). Mise en avant de l'importance de l'outil de build pour sa mécanique de gestion de dépendances. 

Chapitre 7 : La base des threads  

• Classes et interfaces principales (Thread et Runnable)
• Utilisation du mot clef synchronized
• Méthodes wait et notify 
• Introduction aux APIs supérieures (Executor, Callable) 

Chapitre 8 : Les entrees/sorties  

• Rappel des différences entre binaire et caractère 
• Classes et interfaces principales
  • InputStream / Reader
  • OutputStream / Writer 
  • File
•  L’usage des méthodes printf
• Introductions à l’API NIO (Files et Paths)
• Focus sur les bonnes pratiques
  • Gestion par buffer, problématique liée aux tailles 
  • Toujours fermer ses flux (finally ou ressources) 

Atelier pratique : Lire deux fichiers textes qui contiennent des noms et des prénoms pour réaliser un troisième fichier. 

Chapitre 9 : Les lambda expressions 

• Les inner classes anonymes
• Les aspects syntaxiques (déclaration, implémentation, passage de paramètres, portée des variables...).
• Le concept de "foncteur" à travers les interfaces "fonctionnelles" et le package java.util.function.
• Utiliser les lambda-expressions pour manipuler les collections. 

Chapitre 10 : Les streams 

• Objectif de l'approche par Stream
• Le pipeline d'opérations d'un Stream
• Les opérations intermédiaires et terminales
• Les Collectors
• Le traitement des opérations en parallèle
• Les Streams infinis
• Recommandations sur l'utilisation de l'API Stream
  • Ne pas en abuser pour des traitements simples
  • Ne sert pas à remplacer une boucle
  • Ne sert pas à remplacer l'usage d'une méthode 

Chapitre 11 : Introduction aux tests unitaires en JUnit 

• Objectif des tests unitaires
• Historique des 3 versions de JUnit (v3, 4 5)
• Annotations principales (JUnit 5)
  • @Test
  • @BeforeEach / @BeforeAll
  • @AfterEach / @AfterAll 
• Les Assertions et Assumptions 
• La gestion des exceptions (Error/Failure) 
• Définition du covrage et comment l'obtenir via son IDE 

Atelier pratique : Reprendre les jeux d'essais réalisés dans la méthode main des exercices précédents pour les faire passer en tests unitaires.