Tutoriel comment ça marche

1
I) Java – Introduction ...................................................................................................................................... 3
Histoire de Java ..................................................................................................................................... 3
Comparaison de Java et de C++ ..................................................................................................... 3
Les versions de Java ............................................................................................................................ 3
II) Java - Caractéristiques du langage ........................................................................................................... 4
Fichier source, compilation et machine virtuelle ...................................................................... 4
Typologie .................................................................................................................................................. 5
Applications et Applets ....................................................................................................................... 5
Ajout de commentaires ....................................................................................................................... 5
III) Java - Le JDK (Java Development Kit) ................................................................................................... 6
Qu'est-ce que le Java Development Kit ........................................................................................ 6
Les versions ............................................................................................................................................. 6
Où se procurer le JDK .......................................................................................................................... 6
Le compilateur ....................................................................................................................................... 6
L'interpréteur ......................................................................................................................................... 6
L'interpréteur d'applets ...................................................................................................................... 6
Javadoc ..................................................................................................................................................... 7
Le compresseur de classes ................................................................................................................ 7
IV) Java - Premier programme ....................................................................................................................... 7
Première application avec Java ....................................................................................................... 7
Première applet avec Java ................................................................................................................. 8
V) Java - Types de données ........................................................................................................................ 10
Les primitives ....................................................................................................................................... 10
Les enveloppeurs (Wrappers) ........................................................................................................ 11
Conversion de type de données (casting) ................................................................................. 12
VI) Java - Les variables ................................................................................................................................ 14
Le concept de variable ...................................................................................................................... 14
La déclaration de variables ............................................................................................................. 15
Affectation d'une donnée à une variable ................................................................................... 15
Initialisation d'une variable ............................................................................................................ 15
Portée (visibilité) des variables ..................................................................................................... 15
Définition de constantes .................................................................................................................. 15
VII) Java - Les opérateurs ............................................................................................................................. 16
Qu'est-ce qu'un opérateur? ............................................................................................................. 16
Les opérateurs de calcul ................................................................................................................... 16
Les opérateurs d'assignation .......................................................................................................... 16
Les opérateurs d'incrémentation .................................................................................................. 16
Les opérateurs de comparaison ..................................................................................................... 17
Les opérateurs logiques (booléens) ............................................................................................. 17
(Les opérateurs bit-à-bit) ................................................................................................................ 17
(Les opérateurs de rotation de bit) .............................................................................................. 17
Les priorités .......................................................................................................................................... 18
VIII) Java - Structures conditionnelles ....................................................................................................... 19
Qu'est-ce qu'une structure conditionnelle? .............................................................................. 19
La notion de bloc ................................................................................................................................. 19
L'instruction if ...................................................................................................................................... 19
L'instruction if ... else ........................................................................................................................ 19
une façon plus courte de faire un test (opérateur ternaire) .............................................. 20
L'instruction switch ............................................................................................................................ 20
Les boucles ............................................................................................................................................ 20
La boucle for ......................................................................................................................................... 20

2
L'instruction while .............................................................................................................................. 21
Saut inconditionnel ............................................................................................................................ 21
Arrêt inconditionnel ........................................................................................................................... 22
IX) Java - Les classes ................................................................................................................................... 23
La notion d'objet ................................................................................................................................. 23
Les classes avec Java......................................................................................................................... 23
Déclaration des données membres .............................................................................................. 23
Déclaration des méthodes ............................................................................................................... 24
X) Java - Les méthodes ............................................................................................................................... 24
La notion de fonction et de méthode .......................................................................................... 24
La déclaration d'une méthode ........................................................................................................ 24
Appel de méthode ............................................................................................................................... 25
Les arguments d'une méthode....................................................................................................... 25
Renvoi d'une valeur par une méthode ........................................................................................ 25
La surcharge de méthode ................................................................................................................ 25
XI) Java - Création d'objets .......................................................................................................................... 26
La création d'objets ............................................................................................................................ 26
Les références (handles) .................................................................................................................. 26
Accéder aux données membres d'un objet ............................................................................... 26
Accéder aux méthodes d'un objet ................................................................................................ 27
Le mot clé this ...................................................................................................................................... 27
XII) Java - Constructeurs ............................................................................................................................... 28
Le constructeur: une méthode particulière ............................................................................... 28
Définir plusieurs constructeurs ..................................................................................................... 28
XIII) Java - L'héritage ................................................................................................................................. 30
La notion d'héritage ........................................................................................................................... 30
L'héritage avec Java .......................................................................................................................... 30
Le mot-clé super .................................................................................................................................. 31
Remplacer une méthode existante de la superclasse ........................................................... 31
Ajouter un comportement à une méthode de la superclasse ............................................. 31
XIV) Java - L'accessibilité .......................................................................................................................... 31
La notion d'accessibilité ................................................................................................................... 31
La protection des données membres ........................................................................................... 31
Les niveaux d'accès ............................................................................................................................ 31
La notion d'accesseur ........................................................................................................................ 32
La notion de mutateur ....................................................................................................................... 32
XV) Java - Les packages ............................................................................................................................... 33
Introduction aux packages ............................................................................................................. 33
L'organisation hiérarchique ............................................................................................................ 33
L'instruction import ............................................................................................................................ 34
Convention de dénomination des packages ............................................................................. 34
packages et accessibilité .................................................................................................................. 34
Packages accessibles par défaut ................................................................................................... 34
Les fichiers .jar ..................................................................................................................................... 34
XVI) Java - Les exceptions ......................................................................................................................... 35
La nécessité de détecter les erreurs ............................................................................................ 35
La notion d'exception ........................................................................................................................ 35
Les exceptions par la pratique ....................................................................................................... 36
Comment les exceptions sont-elles traitées? .......................................................................... 36
XVII) Java – JDBC ...................................................................................................................................... 37
Introduction à JDBC ........................................................................................................................... 37

3
L'accès aux bases de données avec JDBC .................................................................................. 37
Les types de pilotes JDBC ................................................................................................................ 38
La technologie ODBC ......................................................................................................................... 38
La passerelle JDBC-ODBC ................................................................................................................ 38
Connexion à la base de données ................................................................................................... 38
Connexion à la base de données ................................................................................................... 39
Exécution d'une requête SQL ......................................................................................................... 39
Accès aux données ............................................................................................................................. 39
Création d'objets JDBC de plus haut niveau ............................................................................. 40
I) Java – Introduction
Histoire de Java
Java est un langage objet ressemblant au langage C++. Il a été mis au point en 1991 par la firme Sun Microsystems. Le but de Java à
l'époque était de constituer un langage de programmation pouvant être intégré dans les appareils électroménagers, afin de pouvoir les
contrôler, de les rendre interactifs, et surtout de permettre une communication entre les appareils. Ce programme de développement
se situait dans un projet appelé Green , visant à créer une télécommande universelle ( Star 7 ) comprenant un système d'exploitation
capable de gérer l'ensemble des appareils électroménagers de la maison. Etant donné que le langage C++ comportait trop de
difficultés, James Gosling, un des acteurs du projet (considéré désormais comme le père de Java) décida de créer un langage orienté
objet reprenant les caractéristiques principales du C++, en éliminant ses points difficiles, et en le rendant moins encombrant et plus
portable (il devait pouvoir être intégré dans n'importe quel appareil...). Ainsi, ce langage fut baptisé dans un premier temps Oak ( Oak
signifiant chêne ). Toutefois, puisque ce nom était déjà utilisé, il fut rebaptisé Java en l'honneur de la boisson préférée des
programmeurs, c'est-à-dire le café, dont une partie de la production provient de l'île Java.
A la même époque, le Web faisait son apparition, or Java possèdait toutes les caractéristiques faisant de lui un langage approprié pour
le Web :
 Le réseau des réseaux rassemblant sur une même structure des machines différentes, il fallait un langage capable de
fonctionner sur chacune d'entre-elles: Java était conçu pour être portable
 Le web était limité en bande passante: Java était conçu pour être petit
Ainsi, en 1994, l'équipe décida de mettre au point un navigateur (baptisé HotJava ) intégrant Java et capable de faire fonctionner des
applets (des petites applications fonctionnant dans un navigateur). C'est ainsi que fin 1995 Java eut un terrible essor avec le soutien de
Netscape, qui ne tarda pas à inclure Java dans son navigateur...
Comparaison de Java et de C++
Java est très proche du langage C++ étant donné qu'il a quasiment la même syntaxe. Toutefois Java est plus simple que le langage
C++ bien qu'il s'en inspire, car les caractéristiques critiques du langage C++ (celles qui sont à l'origine des principales erreurs) ont été
supprimées. Cela comprend :
 Les pointeurs
 La surcharge d'opérateurs
 L'héritage multiple
 La libération de mémoire est transparente pour l'utilisateur (il n'est plus nécessaire de créer de destructeurs)
 Une meilleure gestion des erreurs
 Les chaines et les tableaux sont désormais des objets faisant partie intégrante du langage
Toutefois Java est beaucoup moins rapide que le langage C++, il perd en rapidité ce qu'il gagne en portabilité...
Les versions de Java
Il existe trois versions majeures de Java :
 Java 1.0: C'est la première version stable du langage, de ce fait la totalité des navigateurs la supporte

4
 Java 1.1: Cette version du langage a été publiée début 1997, elle apporte des améliorations syntaxiques ainsi que des progrès
au niveau de l'interface utilisateur et de la gestion des exceptions
 Java 1.2: La version "2" apporte des améliorations multimédias. Elle permet par exemple l'utilisation d'interface utilisateur
graphique avancée avec Swing, ainsi que la possibilité d'interagir avec elle par le moyen de glisser-déposer
II) Java - Caractéristiques du langage
Fichier source, compilation et machine virtuelle
Le fichier source d'un programme écrit en Java est un simple fichier texte dont l'extension est par convention .java .
Ce fichier source doit être un fichier texte non formatté, c'est-à-dire un fichier texte dans sa plus simple expression, sans mise en forme
particulière ou caractères spéciaux, c'est-à-dire qu'il contient uniquement les caractères ASCII de base.
Lorsque le programme est prêt à être "essayé", il s'agit de le compiler (le traduire en langage machine) à l'aide d'un compilateur.
Toutefois, contrairement aux langages compilés traditionnels, pour lesquels le compilateur crée un fichier binaire directement
exécutable par un processeur donné (c'est-à-dire un fichier binaire contenant des instructions spécifiques à un processeur), le code
source Java est compilé en un langage intermédiaire (appelé pseudo-code ou bytecode) dans un fichier portant le même nom que le
fichier source à l'exception de son extension ( .class ).
Cette caractéristique est majeure, car c'est elle qui fait qu'un programme écrit en Java est portable, c'est-à-dire qu'il ne dépend pas
d'une plate-forme donnée. En réalité le code intermédiaire n'est exécutable sur aucune plate-forme sans la présence d'une machine
virtuelle, un interpréteur (la machine virtuelle est d'ailleurs parfois appelée interpréteur Java ) tournant sur une plate-forme donnée, et
capable d'interpréter le code intermédiaire.

5
Ainsi, pour peu qu'une plate-forme (windows 95, Unix, Linux, Amiga, ...) possède une machine virtuelle fonctionnant sous son système,
celle-ci est capable d'exécuter n'importe quelle application Java!
De cette façon, l'ensemble des navigateurs permettant d'utiliser des applets possèdent une machine virtuelle...
Typologie
La manière d'écrire les choses en Java est importante. Le langage Java est par exemple sensible à la casse (en anglais case sensitive ),
entendez par là qu'un nom contenant des majuscules est différencié du même nom écrit en minuscules. Ainsi, les spécifications du
langage Java précisent que la fonction principale doit être appelée main() et non Main() ou MAIN() .
D'autre part, toute instruction se termine par un point-virgule.
Applications et Applets
Java permet de créer deux types de programmes :
 Les applications: programmes tels qu'on les connaît, c'est-à-dire s'exécutant dans le système d'exploitation à condition
d'avoir installé une machine virtuelle. Voici ce à quoi ressemble une application Java :
 public class Nom_du_programme {
 public static void main (String args[]){
 System.out.println("Hello World");
 }
}
 Les applets (prononcez Applettes , et traduisez Appliquettes , le nom grotesque donné en français) : Il s'agit de petites
applications destinées à fonctionner sur un navigateur. Ainsi une applet a un champ d'action beaucoup plus réduit qu'une application
pour des raisons de sécurité (une applet ne peut par exemple pas accéder au système sur lequel elle s'exécute...). Voici un exemple
d'applet :
 public class Nom_de_l_applet extends java.applet.Applet {
 public void paint (Graphics g){
 g.drawString("Hello World",20,40);
 }
}
Ajout de commentaires
Lorsqu'un programme devient long et compliqué il peut être intéressant (il est même conseillé) d'ajouter des lignes de commentaires
dans le programme, c'est-à-dire des portions du fichier source qui ont pour but d'expliquer le fonctionnement du programme sans que
le compilateur ne les prennent en compte (car il génèrerait une erreur).
Pour ce faire, il est possible d'utiliser des balises qui vont permettre de délimiter les explications afin que le compilateur les ignore et
passe directement à la suite du fichier.
Ces délimiteurs sont /* et */ . Un commentaire sera donc noté de la façon suivante :
/* Voici un commentaire! */
Il y a toutefois quelques règles à respecter :
 Les commentaires peuvent être placés n'importe où dans le fichier source
 Les commentaires ne peuvent contenir le délimiteur de fin de commentaire (*/)
 Les commentaires ne peuvent être imbriqués
 Les commentaires peuvent être écrits sur plusieurs lignes
 Les commentaires ne peuvent pas couper un mot du programme en deux
Le langage permet aussi de mettre toute la fin d'une ligne en commentaire en utilisant le double slash ( // ). Tout ce qui se situe à droite
de ce symbole sera mis en commentaire.
Enfin, un dernier type de commentaires permet de documenter une application, de telle façon que le programme JavaDoc (fourni avec
le JDK, Java Development Kit , le kit permettant de compiler du Java), puisse créer des documents HTML à partir de l'application afin de
la documenter. Ces commentaires, vus comme des commentaires normaux par Java, sont repérés par les délimiteurs /** et */ .