Programmation orientée objet en Java

GRI - Jean-Philippe Steck CIE303 - Programmation Orientée Objet en Java
02.02.2013 [1]
Module 303
Programmation
orientée objet
en Java
Version 1.0
(Fortement inspiré et traduit de « The Java Tutorial » http://docs.oracle.com/javase/tutorial/)

GRI - Jean-Philippe Steck CIE303 - Programmation Orientée Objet en Java
02.02.2013 [2]
1. Table des matières
Sommaire
1. Table des matières ........................................................................................................................................... 2
2. Présentation de Java ........................................................................................................................................ 4
2.1. Situation .................................................................................................................................................... 4
2.2. Caractéristiques ........................................................................................................................................ 4
2.3. Différentes éditions et versions ................................................................................................................ 6
2.4. La numérotation des versions .................................................................................................................. 6
2.5. La communauté Java ............................................................................................................................... 7
2.6. Les API, les outils, les frameworks ........................................................................................................... 7
3. Le concept orienté-objet en Java ..................................................................................................................... 8
3.1. Les objets ................................................................................................................................................. 8
3.2. Les classes ............................................................................................................................................... 9
3.3. L’héritage ................................................................................................................................................ 10
3.4. Les interfaces ......................................................................................................................................... 11
3.5. Les packages ......................................................................................................................................... 12
3.6. Questions ............................................................................................................................................... 12
4. Éléments de base ........................................................................................................................................... 14
4.1. Les variables .......................................................................................................................................... 14
4.1.1. Les noms des variables ....................................................................................................................... 15
4.1.2. Types de base (types primitifs) ........................................................................................................... 16
4.1.3. Valeurs littérales .................................................................................................................................. 17
4.1.4. Les tableaux ........................................................................................................................................ 18
4.1.4. Questions ............................................................................................................................................ 20
4.2. Les opérateurs ........................................................................................................................................ 21
4.3. Les expressions, les instructions et les blocs ......................................................................................... 25
4.4. Les instructions de contrôle .................................................................................................................... 25
5. Les classes et les objets ................................................................................................................................ 33
5.1. Les classes ............................................................................................................................................. 34
5.2. Les objets ............................................................................................................................................... 37
5.3. Le mot clé « this » .................................................................................................................................. 38
5.4. Contrôler l’accès ..................................................................................................................................... 38
5.5. Le mot clé « static » ................................................................................................................................ 38
5.6. Les classes internes ............................................................................................................................... 40
5.7. Les types énumérés ............................................................................................................................... 41
5.8. Les annotations ...................................................................................................................................... 42
6. Liste des mots réservés ................................................................................................................................. 44
7. Les interfaces et l’héritage ............................................................................................................................. 48
7.1. Les interfaces ......................................................................................................................................... 48
7.2. L’héritage ................................................................................................................................................ 49
7.3. Surcharger une méthode ........................................................................................................................ 52
7.4. Polymorphisme ....................................................................................................................................... 53
7.5. Le mot clé final ....................................................................................................................................... 53
7.6. Le mot clé abstract ................................................................................................................................. 54
8. Les nombres et les chaînes de caractères ..................................................................................................... 55
8.1. Les nombres ........................................................................................................................................... 55

GRI - Jean-Philippe Steck CIE303 - Programmation Orientée Objet en Java
02.02.2013 [3]
9. Les génériques ............................................................................................................................................... 57
10. Les exceptions ............................................................................................................................................... 59
11. Les collections ............................................................................................................................................... 64
12. Architecture ................................................................................................................................................... 65
12.1. Application simple ................................................................................................................................ 65
12.2. Application client-serveur ..................................................................................................................... 65
12.3. Le modèle 3-tiers ................................................................................................................................. 65
13. Java et les bases de données ....................................................................................................................... 67
13.1. JDBC .................................................................................................................................................... 67
13.1. Architecture .......................................................................................................................................... 68
13.2. Les limites de JDBC ............................................................................................................................. 69
13.1. JPA – Java Persistence API ................................................................................................................ 70
14. Interfaces utilisateurs graphiques .................................................................................................................. 71
14.1. Interfaces graphiques avec Swing ....................................................................................................... 73
14.1. Le positionnement des composants ..................................................................................................... 73
14.2. Les événements ................................................................................................................................... 75
15. Applications Web en Java ............................................................................................................................. 77
15.1. JSP – Java Server Pages .................................................................................................................... 78
15.1. JSF – Java Server Faces ..................................................................................................................... 78
15.1. Vaadin .................................................................................................................................................. 79
15.2. Technologies natives ........................................................................................................................... 79

GRI - Jean-Philippe Steck CIE303 - Programmation Orientée Objet en Java
02.02.2013 [4]
2. Présentation de Java
Ce chapitre présente les caractéristiques de Java et son environnement.
2.1. Situation
Java est actuellement le langage de programmation le plus utilisé dans le monde. Il y aurait plus de 9 millions
de développeurs Java. Et l’environnement d’exécution Java est téléchargé plus d’1 milliard de fois chaque année.
Sa richesse et sa communauté en font en langage utilisé pour le développement de toute sorte d’applications,
des applications d’entreprise jusqu’aux applications mobiles.
Initialement développé par Sun, la première version de la JVM date de 1995. Sun a été racheté par Oracle en
janvier 2010. La version actuelle est Java SE 7, sorti en juillet 2011.
2.2. Caractéristiques
Interprété
“Write once, run anywhere” (Écrit une fois, exécuté partout) : Java est un langage interprété. Le code Java est
compilé en bytecode, puis exécuté par un interpréteur : la JVM (Java Virtual Machine).
Indépendant de la plate-forme d’exécution
Il n'y a pas de compilation spécifique à chaque plate forme. Le code reste indépendant de la machine sur laquelle
il s'exécute. Il est possible d'exécuter des programmes Java sur tous les environnements qui possèdent une Java
Virtual Machine.

GRI - Jean-Philippe Steck CIE303 - Programmation Orientée Objet en Java
02.02.2013 [5]
Cette indépendance fait que Java peut être un petit peu plus lent que du code natif, mais, avec les avancées du
compilateur et de la machine virtuelle, les performances s’approchent du code natif, en conservant la portabilité.
Orienté-objet
Comme la plupart des langages de programmation récents, Java est orienté-objet. Toutefois, contrairement aux
langages purement orientés objet comme SmallTalk, où tout est objet, Java définit des types primitifs qui ne sont
pas des objets.
Simple
Les auteurs de Java ont volontairement abandonné les éléments mal compris ou mal exploités des autres
langages de programmation, comme les pointeurs ou l’allocation de la mémoire. Le langage est plus simple et il y
a moins de risque de bug dû à une mauvaise utilisation du langage.
Fortement typé
Java est fortement typé : toute variable a un type et il n’y a pas de conversion automatique, le développeur est
donc en quelque sorte contraint de mieux maîtriser ses variables.
Gestion de la mémoire automatique
L'allocation de la mémoire pour un objet est automatique lors sa création et Java récupère automatiquement la
mémoire inutilisée grâce au garbage collector qui restitue les zones de mémoire laissées libres suite à la
destruction des objets.
Multi-tâche
Il permet l'utilisation de threads qui sont des unités d'exécutions isolées. La JVM, elle même, utilise plusieurs
threads.