Objectifs de la formation :

Cette formation est un premier pas dans le monde du développement Java. Elle a pour objectif de familiariser les développeurs et les chefs de projet avec :

• les bases de la programmation orientée objet en Java
• les principales bibliothèques du kit de développement Java
• les bonnes pratiques de la programmation Java
• les outils de développement Java.

Les nombreux travaux pratiques et exercices ont pour but de rendre les participants opérationnels sur le langage à l’issue de la formation.

1. Concepts de base du langage Java

• Historique : les premiers langages objet, les apports des autres langages
• La machine virtuelle Java : code source, compilation, bytecode, exécution
• Les kits de développement Java : contenu, évolution, outils

2. La syntaxe Java

• Structure d’un programme : paquetages, classes, attributs, méthodes, instructions
• Les types primitifs : boolean, float, int, double, char, etc.
• Les variables : déclaration, affectation
• Les opérateurs : opérateurs unaires, opérateurs logiques, opérateurs arithmétiques, etc.
• Les structures de contrôle : les tests (if / then / else, switch / case), les boucles (for, while)
• Les tableaux : déclaration, initialisation statique et dynamique, accès

3. Javadoc

• Présentation de l’outil de documentation automatique
• La syntaxe de Javadoc : insertion dans le code source
• Les balises Javadoc : fonctions, paramètres, valeur de retour, etc.
• Les règles de documentation : bonnes pratiques pour la documentation

4. Rappels sur les objets

• La notion d’objet : variables d’instance, méthodes d’instance
• L’encapsulation : interfaces, variables et méthodes privées ou publiques
• Les messages : destinataire, nom de méthode, paramètres
• Les classes : définition, instanciation, imbrication
• L’héritage : sous-classes, enrichissement, spécialisation et polymorphisme

5. Classes et héritages en Java

• Instanciation, mot-clé new, références, mot-clé this
• Structure d’une classe : variables de classe et d’instance, méthodes de classe et d’instance, mot-clé static
• Les différents niveaux de visibilité : mots-clés private, protected et public
• L’accès aux attributs et aux méthodes : accesseurs (getters et setters)
• Le passage de paramètres : par valeur ou par référence
• Les constructeurs : définition, syntaxe, usage
• Notion de sous-classe et de classe parente, mots-clés extends et super
• Les classes abstraites, mots-clés abstract et final
• Les interfaces : intérêt, syntaxe, usage

6. Les exceptions

• A quoi servent les exceptions ?
• Mécanisme de gestion des exceptions : lancement, interception
• La classe Exception et ses dérivées, chaînage des exceptions
• Lancement d’un exception : mots-clés throw, throws, le cas particulier des RuntimeException
• Interception d’une exception : syntaxe du bloc try / catch
• Le mot-clé finally : intérêt, syntaxe, cas particuliers

7. Le package java.lang

• La classe Object, mère de toutes les classes ; les méthodes de la classe Object
• Les chaînes de caractères : la classe String, manipulation et conversions
• Les wrappers, encapsuleurs de types primitifs : manipulation, conversions
• Les objets représentant des nombres : la classe Number, l’interface Comparable, la classe Math
• La classe Class et ses méthodes de manipulation de classes
• La classe System : les attributs de classe in, out, err et les méthodes de classe utilitaires

8. Le package java.util

• Les collections, les iterateurs et les méthodes d’accès
• Les listes et les tableaux : différences entre Vector, ArrayList et LinkedList ; les piles
• Les ensembles : interface Set et classe HashSet
• Les tables de hachage : différences entre Hashtable et HashMap
• Les classes utilitaires Arrays et Collections pour manipuler tableaux et collections

9. Les entrées/sorties

• Notion de flux, package java.io
• Les flux de caractères (character streams) : interfaces Reader et Writer
• Les flux d’octets (byte streams) : interfaces InputStream et OutputStream
• Les wrappers de flux : utilisation d’un tampon, méthode flush
• Le stockage d’objets Java : la sérialisation
• Les Properties : fichiers de properties, accès aux properties, propriétés système

10. L’accès aux bases de données avec JDBC

• Vue d’ensemble : package java.sql, pilotes spécifiques, séquence d’utilisation
• Le chargement d’un pilote et la connexion à la base de données
• La préparation et l’exécution d’une requête
• L’exploitation des résultats
• Utiliser un pool de connexions

11. L’utilitaire Ant

• Ant : le "makefile" multi-plateformes
• Le fichier de configuration de Ant : build.xml
• Les cibles Ant : balise target et cible par défaut
• Les tâches Ant : tâches natives et tâches optionnelles (echo, property, mkdir, copy, delete, javac, etc.)
• Les types Ant : ensembles de fichiers, de répertoires, classpaths

12. Les tests unitaires avec JUnit

• Les différents types de tests : unitaires, de non régression, intégration, fonctionnels, montée en charge, etc.
• Les tests unitaires : à quoi ça sert ? Que tester ?
• La "programmation extrême" ou XP (Xtreme programming)
• Mise en oeuvre de JUnit, l’outil de tests unitaires de Java
• Les bonnes pratiques des tests unitaires

Pré requis :

• Notions de programmation orientée objet
• Connaissance d’au moins un langage de programmation

Profil des participants :

tout public désirant acquérir une connaissance opérationnelle de la programmation orientée objet en Java, en particulier :

• développeurs
• chefs de projet

Mise en pratique :

L’ensemble de ce séminaire est illustré d’exemples pratiques de mise en œuvre.

Inscription

Pour plus d’information : formation@clever-age.com