Table des matières

• Chapitre 1  Notes de cours
  • 1.1  Introduction
    • 1.1.1  Hello World!
    • 1.1.2  Formats de fichiers
    • 1.1.3  Machine virtuelle
    • 1.1.4  Linkage
  • 1.2  Variables
    • 1.2.1  Définition
    • 1.2.2  Déclaration
    • 1.2.3  Affectation
    • 1.2.4  Saisie
    • 1.2.5  Affichage
    • 1.2.6  Entiers
    • 1.2.7  Flottants
    • 1.2.8  Caractères
    • 1.2.9  Chaînes de caractères
  • 1.3  Opérateurs
    • 1.3.1  Généralités
    • 1.3.2  Les opérateurs unaires
    • 1.3.3  Les opérateurs binaires
    • 1.3.4  Formes contractées
    • 1.3.5  Opérations hétérogènes
    • 1.3.6  Les priorités
  • 1.4  Conditions
    • 1.4.1  Le bloc if
    • 1.4.2  Si ... Alors ... Sinon
    • 1.4.3  Switch
    • 1.4.4  Booléens
    • 1.4.5  Les priorités
  • 1.5  Boucles
    • 1.5.1  Définitions et terminologie
    • 1.5.2  while
    • 1.5.3  do ... while
    • 1.5.4  for
    • 1.5.5  Accolades superflues
  • 1.6  Survol du langage
    • 1.6.1  Structure d’une classe
    • 1.6.2  Variables
    • 1.6.3  Entrées-sorties
    • 1.6.4  Sous-programmes
    • 1.6.5  Main
    • 1.6.6  Instructions de contrôle de flux
    • 1.6.7  Exemple récapitulatif
    • 1.6.8  Packages
  • 1.7  Tableaux
    • 1.7.1  Déclaration
    • 1.7.2  Instanciation
    • 1.7.3  Accès aux éléments
    • 1.7.4  Longueur d’un tableau
    • 1.7.5  Tableaux à plusieurs dimensions
  • 1.8  Les sous-programmes
    • 1.8.1  Les procédures
    • 1.8.2  Variables locales
    • 1.8.3  Passage de paramètres
    • 1.8.4  Les fonctions
    • 1.8.5  Passages de paramètre par référence
  • 1.9  Objets
    • 1.9.1  Création d’un type
    • 1.9.2  Les méthodes
    • 1.9.3  L’instanciation
    • 1.9.4  Les packages
    • 1.9.5  Le mot-clé this
  • 1.10  Encapsulation
    • 1.10.1  Exemple
    • 1.10.2  Visibilité
    • 1.10.3  Constructeur
    • 1.10.4  Accesseurs
    • 1.10.5  Surcharge
    • 1.10.6  Collections
  • 1.11  Héritage
    • 1.11.1  Héritage
    • 1.11.2  Polymorphisme
    • 1.11.3  Redéfinition de méthodes
    • 1.11.4  Interfaces
    • 1.11.5  Classes Abstraites
  • 1.12  Exceptions
    • 1.12.1  Rattraper une exception
    • 1.12.2  Méthodes levant des exceptions
    • 1.12.3  Propagation d’une exception
    • 1.12.4  Définir une exception
    • 1.12.5  Lever une exception
    • 1.12.6  Rattraper plusieurs exceptions
    • 1.12.7  Finally
    • 1.12.8  RuntimeException
  • 1.13  Interfaces graphiques
    • 1.13.1  Fenêtres
    • 1.13.2  Un premier objet graphique
    • 1.13.3  Ecouteurs d’événements
    • 1.13.4  Premier exemple
    • 1.13.5  Classes anonymes
    • 1.13.6  Gestionnaires de mise en forme
    • 1.13.7  Un exemple complet : Calcul d’un carré
  • 1.14  Tests unitaires
    • 1.14.1  Exemple
    • 1.14.2  Test à la bourrin
    • 1.14.3  Test des fonctions
    • 1.14.4  Test des fonctions automatisé
    • 1.14.5  Tests unitaires
    • 1.14.6  Logs
  • 1.15  Collections
    • 1.15.1  Types paramétrés
    • 1.15.2  Paramètres et héritage
    • 1.15.3  Collections standard
  • 1.16  Threads
    • 1.16.1  Le dîner des philosophes
    • 1.16.2  Lancement
    • 1.16.3  Synchronisation
    • 1.16.4  Mise en Attente
  • 1.17  Persistance
    • 1.17.1  Fichiers
    • 1.17.2  Serialization
    • 1.17.3  JDBC
    • 1.17.4  L’attaque par injection
  • 1.18  Hibernate
    • 1.18.1  Introduction
    • 1.18.2  Un premier exemple
    • 1.18.3  Un gestionnaire de contacts en quelques lignes
    • 1.18.4  Un exemple de relations entre les classes
• Chapitre 2  Exercices
  • 2.1  Variables
    • 2.1.1  Saisie et affichage
    • 2.1.2  Entiers
    • 2.1.3  Flottants
    • 2.1.4  Caractères
  • 2.2  Opérateurs
    • 2.2.1  Conversions
    • 2.2.2  Opérations sur les bits (difficiles)
    • 2.2.3  Morceaux choisis (difficiles)
  • 2.3  Conditions
    • 2.3.1  Prise en main
    • 2.3.2  Switch
  • 2.4  Boucles
    • 2.4.1  Compréhension
    • 2.4.2  Utilisation de toutes les boucles
    • 2.4.3  Choix de la boucle la plus appropriée
    • 2.4.4  Morceaux choisis
    • 2.4.5  Extension de la calculatrice
  • 2.5  Tableaux
    • 2.5.1  Exercices de compréhension
    • 2.5.2  Prise en main
    • 2.5.3  Indices
    • 2.5.4  Matrices
  • 2.6  Les sous-programmes
    • 2.6.1  Initiation
    • 2.6.2  Géométrie
    • 2.6.3  Arithmétique
    • 2.6.4  Passage de tableaux en paramètre
    • 2.6.5  Décomposition en facteurs premiers
    • 2.6.6  Pour le sport
  • 2.7  Objets
    • 2.7.1  Création d’une classe
    • 2.7.2  Méthodes
  • 2.8  Encapsulation
    • 2.8.1  Prise en main
    • 2.8.2  Implémentation d’une pile
    • 2.8.3  Collections
    • 2.8.4  Refactoring de la pile avec des ArrayList
    • 2.8.5  Refactoring de la pile avec des listes chaînées
  • 2.9  Héritage
    • 2.9.1  Héritage
    • 2.9.2  Polymorphisme
    • 2.9.3  Interfaces
    • 2.9.4  Classes abstraites
    • 2.9.5  Un dernier casse-tête
  • 2.10  Exceptions
  • 2.11  Interfaces graphiques
    • 2.11.1  Prise en main
    • 2.11.2  Maintenant débrouillez-vous
  • 2.12  Tests unitaires
    • 2.12.1  Prise en main
    • 2.12.2  Pour aller plus loin
  • 2.13  Collections
    • 2.13.1  Types paramétrés
    • 2.13.2  Collections
    • 2.13.3  Morceaux choisis
  • 2.14  Threads
    • 2.14.1  Prise en main
    • 2.14.2  Synchronisation
    • 2.14.3  Débrouillez-vous
  • 2.15  Persistance
    • 2.15.1  Remember my name
    • 2.15.2  Hachage
    • 2.15.3  Morceaux choisis
  • 2.16  Hibernate
    • 2.16.1  Prise en main
    • 2.16.2  Contacts

Chapitre 1  Notes de cours

• Introduction
  • Hello World!
  • Formats de fichiers
  • Machine virtuelle
  • Linkage
• Variables
  • Définition
  • Déclaration
  • Affectation
  • Saisie
  • Affichage
  • Entiers
  • Flottants
  • Caractères
  • Chaînes de caractères
• Opérateurs
  • Généralités
  • Les opérateurs unaires
  • Les opérateurs binaires
  • Formes contractées
  • Opérations hétérogènes
  • Les priorités
• Conditions
  • Le bloc if
  • Si ... Alors ... Sinon
  • Switch
  • Booléens
  • Les priorités
• Boucles
  • Définitions et terminologie
  • while
  • do ... while
  • for
  • Accolades superflues
• Survol du langage
  • Structure d’une classe
  • Variables
  • Entrées-sorties
  • Sous-programmes
  • Main
  • Instructions de contrôle de flux
  • Exemple récapitulatif
  • Packages
• Tableaux
  • Déclaration
  • Instanciation
  • Accès aux éléments
  • Longueur d’un tableau
  • Tableaux à plusieurs dimensions
• Les sous-programmes
  • Les procédures
  • Variables locales
  • Passage de paramètres
  • Les fonctions
  • Passages de paramètre par référence
• Objets
  • Création d’un type
  • Les méthodes
  • L’instanciation
  • Les packages
  • Le mot-clé this
• Encapsulation
  • Exemple
  • Visibilité
  • Constructeur
  • Accesseurs
  • Surcharge
  • Collections
• Héritage
  • Héritage
  • Polymorphisme
  • Redéfinition de méthodes
  • Interfaces
  • Classes Abstraites
• Exceptions
  • Rattraper une exception
  • Méthodes levant des exceptions
  • Propagation d’une exception
  • Définir une exception
  • Lever une exception
  • Rattraper plusieurs exceptions
  • Finally
  • RuntimeException
• Interfaces graphiques
  • Fenêtres
  • Un premier objet graphique
  • Ecouteurs d’événements
  • Premier exemple
  • Classes anonymes
  • Gestionnaires de mise en forme
  • Un exemple complet : Calcul d’un carré
• Tests unitaires
  • Exemple
  • Test à la bourrin
  • Test des fonctions
  • Test des fonctions automatisé
  • Tests unitaires
  • Logs
• Collections
  • Types paramétrés
  • Paramètres et héritage
  • Collections standard
• Threads
  • Le dîner des philosophes
  • Lancement
  • Synchronisation
  • Mise en Attente
• Persistance
  • Fichiers
  • Serialization
  • JDBC
  • L’attaque par injection
• Hibernate
  • Introduction
  • Un premier exemple
  • Un gestionnaire de contacts en quelques lignes
  • Un exemple de relations entre les classes

Chapitre 2  Exercices

• Variables
  • Saisie et affichage
  • Entiers
  • Flottants
  • Caractères
• Opérateurs
  • Conversions
  • Opérations sur les bits (difficiles)
  • Morceaux choisis (difficiles)
• Conditions
  • Prise en main
  • Switch
• Boucles
  • Compréhension
  • Utilisation de toutes les boucles
  • Choix de la boucle la plus appropriée
  • Morceaux choisis
  • Extension de la calculatrice
• Tableaux
  • Exercices de compréhension
  • Prise en main
  • Indices
  • Matrices
• Les sous-programmes
  • Initiation
  • Géométrie
  • Arithmétique
  • Passage de tableaux en paramètre
  • Décomposition en facteurs premiers
  • Pour le sport
• Objets
  • Création d’une classe
  • Méthodes
• Encapsulation
  • Prise en main
  • Implémentation d’une pile
  • Collections
  • Refactoring de la pile avec des ArrayList
  • Refactoring de la pile avec des listes chaînées
• Héritage
  • Héritage
  • Polymorphisme
  • Interfaces
  • Classes abstraites
  • Un dernier casse-tête
• Exceptions
• Interfaces graphiques
  • Prise en main
  • Maintenant débrouillez-vous
• Tests unitaires
  • Prise en main
  • Pour aller plus loin
• Collections
  • Types paramétrés
  • Collections
  • Morceaux choisis
• Threads
  • Prise en main
  • Synchronisation
  • Débrouillez-vous
• Persistance
  • Remember my name
  • Hachage
  • Morceaux choisis
• Hibernate
  • Prise en main
  • Contacts

Ce document a été traduit de L^AT_EX par H^EV^EA