5.1. Les packages selon la version du JDK
5.2. Le package java.lang
5.2.1. La classe Object
5.2.1.1. La méthode getClass()
5.2.1.2. La méthode toString()
5.2.1.3. La méthode equals()
5.2.1.4. La méthode finalize()
5.2.1.5. La méthode clone()
5.2.2. La classe String
5.2.3. La classe StringBuffer
5.2.4. Les wrappers
5.2.5. La classe System.
5.2.5.1. L’utilisation des flux d’entrée/sortie standard
5.2.5.2. Les variables d’environnement et les propriétés du système
5.2.6. Les classes Runtime et Process.
5.3. La présentation rapide du package awt java
5.4. La présentation rapide du package java.io
5.5. Le package java.util.
5.5.1. La classe StringTokenizer.
5. Les packages de bases
5.5.2. La classe Random
5.5.3. Les classes Date et Calendar.
5.5.4. La classe SimpleDateFormat
5.5.5. La classe Vector
5.5.6. La classe Hashtable
5.5.7. L’interface Enumeration
5.5.8. La manipulation d’archives zip.
5.5.9. Les expressions régulières
5.5.9.1. Les motifs
5.5.9.2. La classe Pattern
5.5.9.3. La classe Matcher
5.5.10. La classe Formatter
5.5.11. La classe Scanner
5.6. La présentation rapide du package java.net
5.7. La présentation rapide du package java.applet
6. Les fonctions mathématiques
6.1. Les variables de classe
6.2. Les fonctions trigonométriques.
6.3. Les fonctions de comparaisons.
6.4. Les arrondis
6.4.1. La méthode round(n)
6.4.2. La méthode rint(double)
6.4.3. La méthode floor(double)
6.4.4. La méthode ceil(double)
6.4.5. La méthode abs(x)
6.5. La méthode IEEEremainder(double, double)
6.6. Les Exponentielles et puissances
6.6.1. La méthode pow(double, double)
6.6.2. La méthode sqrt(double)
6.6.3. La méthode exp(double)
6.6.4. La méthode log(double)
6.7. La génération de nombres aléatoires
6.7.1. La méthode random()
6.8. La classe BigDecimal
7. La gestion des exceptions
7.1. Les mots clés try, catch et finally
7.2. La classe Throwable
7.3. Les classes Exception, RunTimeException et Error.
7.4. Les exceptions personnalisées
7.5. Les exceptions chaînées
7.6. L’utilisation des exceptions
8. Le multitâche
8.1. L’interface Runnable
8.2. La classe Thread
8.3. La création et l’exécution d’un thread
8.3.1. La dérivation de la classe Thread
8.3.2. L’implémentation de l’interface Runnable
8.3.3. La modification de la priorité d’un thread.
8.4. La classe ThreadGroup
8.5. Un thread en tâche de fond (démon)
8.6. L’exclusion mutuelle
8.6.1. La sécurisation d’une méthode
8.6.2. La sécurisation d’un bloc
8.6.3. La sécurisation de variables de classes
8.6.4. La synchronisation : les méthodes wait() et notify()
9. JDK 1.5 (nom de code Tiger)
9.1. Les nouveautés du langage Java version 1.5
9.2. L’autoboxing / unboxing
9.3. Les importations statiques
9.4. Les annotations ou méta données (Meta Data)
9.5. Les arguments variables (varargs)
9.6. Les generics
9.7. Les boucles pour le parcours des collections
9.8. Les énumérations (type enum)
9.8.1. La définition d’une énumération
9.8.2. L’utilisation d’une énumération
9.8.3. L’enrichissement de l’énumération
9.8.4. La personnalisation de chaque élément
9.8.5. Les limitations dans la mise en oeuvre des énumérations
10. Les annotations
10.1. La mise en oeuvre des annotations
10.2. L’utilisation des annotations
10.2.1. La documentation
10.2.2. L’utilisation par le compilateur
10.2.3. La génération de code
10.2.4. La génération de fichiers
10.2.5. Les API qui utilisent les annotations
10.3. Les annotations standards
10.3.1. L’annotation @Deprecated
10.3.2. L’annotation @Override
10.3.3. L’annotation @SuppressWarning
10.4. Les annotations communes (Common Annotations)
10.4.1. L’annotation @Generated
10.4.2. Les annotations @Resource et @Resources.
10.4.3. Les annotations @PostConstruct et @PreDestroy
10.5. Les annotations personnalisées
10.5.1. La définition d’une annotation.
10.5.2. Les annotations pour les annotations
10.5.2.1. L’annotation @Target
10.5.2.2. L’annotation @Retention
10.5.2.3. L’annotation @Documented.
10.5.2.4. L’annotation @Inherited
10.6. L’exploitation des annotations
10.6.1. L’exploitation des annotations dans un Doclet
10.6.2. L’exploitation des annotations avec l’outil Apt

10.6.3. L’exploitation des annotations par introspection.
10.6.4. L’exploitation des annotations par le compilateur Java
10.7. L’API Pluggable Annotation Processing.
10.7.1. Les processeurs d’annotations.
10.7.2. L’utilisation des processeurs par le compilateur.
10.7.3. La création de nouveaux fichiers
10.8. Les ressources relatives aux annotations.
Partie 2 : Développement des interfaces graphiques.