Formation aux technologies de l'informatiqueformation java

Les bases du développement Java pour développeur objet

LJ110
Prix inter : 1950 € HT Durée: 5 jours
Prix intra*: 5440 € HT
* jusqu'à 8 personnes
Public
Public : développeurs, chefs de projet
Niveau : débutant
Prochaines sessions
Nous contacter au 06 68 36 54 43 ou par mail
Description

Ce cours s'adresse aux développeurs connaissant la Programmation Objet qui souhaitent apprendre à utiliser le langage Java. Il s'agit d'un cours intensif visant à acquérir la maîtrise des principales API disponibles avec la plateforme JSE. Il permet en outre de découvrir la notation UML, ainsi que la mise en oeuvre de Design Patterns avec Java.

Pré-requis
Les participants doivent posséder des notions de programmation objet (C++, ActionScript, C#...)
Programme
  • Présentation du langage Java

    • Historique et processus de développement de la plate-forme Java
    • Principe de la machine virtuelle Java (JVM)
    • Les éléments constitutifs du Java Development Kit (JDK)
    • Description des principales API de JSE
    • Les caractéristiques du langage
    • Anatomie d'un fichier source, compilation et exécution d'un programme
  • Syntaxe de base du langage Java

    • Ecrire une classe avec une méthode "main" pour lancer un programme
    • Déclarer des variables et utiliser les types primitifs
    • Anatomie d'une méthode : paramètres, type de retour, mot clé "void"
    • Les instructions conditionnelles "if..else" et "switch"
    • Répéter une action avec les boucles "for", "while" et "do..while"
    • Utiliser les opérateurs conditionnels et les opérateurs de comparaison
    • Commenter le code et générer une documentation HTML avec l'outil "javadoc"
  • La programmation Objet en Java

    • Introduction à la conception objet, notions de classes et d'instance
    • Déclarer des champs d'instance et des méthodes d'instance
    • Comprendre la différence entre variable locale et champ d'instance
    • Utiliser le mot clé "this"
    • Principe de la surcharge des méthodes (overloading)
    • Notion de constructeur, rôle des constructeurs dans le processus d'instanciation
    • Le mot clé "static" pour déclarer des champs et des méthodes de classe
    • Utiliser le mot clé "final" avec une variable, cas particulier des constantes
    • Spécificités de Java 5 : paramètres variables, types énumérés, annotation @Deprecated
    • Principe de la destruction des objets avec le garbage collector
  • Organisation des classes et principe d'encapsulation

    • Exploiter la notion de package pour organiser les classes
    • La clause "import" et sa relation avec les packages
    • Comprendre le principe d'encapsulation
    • La notion de visibilité pour contrôler l'accès aux membres d'une classe
    • Rôle des méthodes getter et setter vis à vis de l'encapsulation
    • Notion de propriété Java suivant la norme JavaBean
    • Spécificités Java 5 : les imports statiques
  • Abstraction, héritage et polymorphisme

    • Comprendre la technique d'héritage entre classes
    • Définition et mise en oeuvre du polymorphisme
    • Principe de la redéfinition des méthodes (overriding)
    • Transtypage (up et down casting), mot clé "instance of", annotation @Override
    • Le mot clé "final" appliqué aux méthodes et aux classes
    • Redéfinition des constructeurs, cas particulier du constructeur vide
    • Utiliser le mot clé "super" lors d'une redéfinition
    • Comprendre les notions de classe abstraite et d'interface
  • Tableaux et collections

    • Déclarer et instancier des tableaux de types primitifs et d'objets
    • Accès aux éléments d'un tableau et itération avec une boucle "for"
    • Présentation de l'API de collection : les types Collection, List, Set et Map
    • Parcourir une collection avec un itérateur
    • Trier une collection à l'aide des interfaces Comparable et Comparator
    • Les apports de Java 5 pour gérer les collections : generics et boucle "for each"
  • Mécanisme d'exception

    • Présentation de la notion d'exception en Java
    • Description de quelques exceptions classiques du JDK
    • Comprendre le mécanisme de propagation des exceptions
    • Traiter une exception avec un bloc "try..catch"
    • Utiliser un bloc "finally" lors du traitement d'une exception
    • Rôle des clauses "throw" et "throws" dans la propagation des exceptions
    • Différence entre les exceptions runtime et les exceptions non-runtime
    • Créer des exceptions personnalisées
  • La librairie standard

    • Présentation des classes Object et System
    • Manipuler des chaînes de caractères avec les classes String, StringBuffer et StringBuilder
    • Les classes wrapper des types primitifs et l'autoboxing de Java 5
    • Manipuler les données temporelles avec les classes Date et Calendar
    • Formatter des nombres, dates et heures avec les classes NumberFormat et DateFormat
  • Les flux d'entrées / sorties et les fichiers

    • Principe des flux d'entrées / sorties avec Java
    • Description des classes principales du package java.io
    • Utiliser des flux binaires et des flux de caractères
    • Lire et écrire des fichiers à l'aide des flux d'entrées / sorties
    • Examiner les fichiers et répertoires du file system
    • Principe de la sérialisation des objets
  • Accéder aux bases de données avec JDBC

    • Le modèle de programmation de l'API JDBC
    • Se connecter à la base de données
    • Exécuter des requêtes et exploiter les résultats
    • Mise en oeuvre de la gestion transactionnelle
    • Traitement des exceptions dans une méthode d'accès aux données
  • Programmation des interfaces graphiques avec Swing

    • Présentation des Java Foundation Classes
    • Mise en oeuvre de quelques composants simples : JFrame, JLabel, JTextField, JButton
    • La gestion des évènements : notion de Listener
    • Afficher une collection d'objets dans une JList
  • Structurer le code d'une application

    • Notion de design pattern
    • Présentation des Design Pattern "singleton" et "factory method"
    • Principe de la programmation en couche
Travaux Pratiques
Les stagiaires bâtiront une mini-application graphique au fil des exercices, en commençant par l'écriture des objets métier et en terminant par le développement de la couche présentation en Swing. Les exercices seront réalisés avec l'outil de développement Eclipse.
Intervenants
Olivier Hanny
Olivier est un spécialiste des technologies Java / JEE depuis l'année 2000, après une carrière d'ingénieur dans la sidérurgie. Il est aujourd'hui consultant indépendant, et partage son temps entre des missions de réalisations informatiques (Java, Flex) et l'animation de formations.
Alexis Hassler
Alexis est consultant et formateur indépendant en technologies Objet. Il intervient auprès de ses clients pendant les phases de lancement de projet, pour définir la méthode et l'outillage nécessaires à l'équipe, puis en phase d'analyse et de conception, pour la mise en oeuvre d'UML. Il assiste aussi ses clients dans la définition des architectures techniques, en particulier sur les plateformes Java et JavaEE.