Introduction à la programmation Java - BFH

Haute école spécialisée bernoise
Haute école Technique et Informatique, HTI
Section Microtechnique
Introduction à la
programmation Java
Introduction
Aspect procédural de la programmation Java
Introduction à la programmation OO
© 2004, HTI Burgdorf
E. Firouzi
Nom de fichier: Introduction_Java_Partie1
Erstellt am: 11. February 2009
Autor: Elham FIrouzi
Version: 1.0

Introduction à la programmation Java Tables des matières
Version 1.0, 11.02.09 Page II
Tables des matières
1 Introduction......................................................................................................................................................1
1.1 Fondement............................................................................................................................................... 1
1.1.1 Propriété du Java............................................................................................................................. 1
1.1.2 Champ d’application du Java.......................................................................................................... 1
1.1.3 Lecture ............................................................................................................................................ 1
1.1.4 Information disponibles sur le web................................................................................................. 2
1.2 Un premier exemple................................................................................................................................ 2
1.3 Développement de programme en Java................................................................................................... 2
1.3.1 Editeur de texte ............................................................................................................................... 3
1.3.2 Compilateur..................................................................................................................................... 3
1.3.3 Interpréteur...................................................................................................................................... 3
1.3.4 Vue d’ensemble............................................................................................................................... 3
1.4 Les applications....................................................................................................................................... 4
1.5 Les applets............................................................................................................................................... 4
1.6 Avantages et désavantage du Java........................................................................................................... 7
2 Aspect procédural de la programmation Java ..................................................................................................8
2.1 Introduction............................................................................................................................................. 8
2.2 Les éléments lexicographiques................................................................................................................ 8
2.2.1 Jeu de caractères.............................................................................................................................. 8
2.2.2 Indicateur ........................................................................................................................................ 8
2.2.3 Les commentaires............................................................................................................................ 8
2.2.4 Les séquences d’échappement......................................................................................................... 9
2.3 Les mots clés......................................................................................................................................... 10
2.4 Les variables et le type de données élémentaires.................................................................................. 10
2.4.1 Déclaration et initialisation de variable......................................................................................... 10
2.4.2 Type de donnée élémentaire.......................................................................................................... 11
2.4.3 Les changements de type de données............................................................................................ 13
2.4.4 La visibilité ................................................................................................................................... 14
2.4.5 Les variables globales ................................................................................................................... 14
2.5 Les chaînes de caractères ...................................................................................................................... 14
2.5.1 String............................................................................................................................................. 14
2.5.2 StringBuffer................................................................................................................................... 15
2.6 Les tableaux.......................................................................................................................................... 16
2.6.1 Les tableaux unidimensionnels ..................................................................................................... 16
2.6.2 Les tableaux multidimensionnelles ...............................................................................................18
2.7 Les constantes....................................................................................................................................... 18
2.8 Les opérateurs ....................................................................................................................................... 19
2.8.1 Les opérateurs arithmétiques......................................................................................................... 19
2.8.2 Les opérateurs de comparaison ..................................................................................................... 20
2.8.3 Les opérateurs logiques................................................................................................................. 20
2.8.4 Les opérateurs de traitement des bits ............................................................................................ 20
2.8.5 Les opérateurs d’affectation.......................................................................................................... 21
2.8.6 L’opérateur point d’interrogation.................................................................................................. 22
2.8.7 L’opérateur cast............................................................................................................................. 22
2.8.8 Les opérateurs supplémentaires pour la programmation OO........................................................ 22
2.9 Les structures de contrôle...................................................................................................................... 23
2.9.1 Introduction................................................................................................................................... 23
2.9.2 L’instruction if............................................................................................................................ 23
2.9.3 L’instruction switch................................................................................................................... 24
2.9.4 La boucle while.......................................................................................................................... 25

Introduction à la programmation Java Tables des matières
Version 1.0, 11.02.09 Page III
2.9.5 La boucle do while................................................................................................................... 26
2.9.6 La boucle for............................................................................................................................... 27
2.9.7 Contrôle des boucles avec les instructions break et continue ............................................... 28
2.10 Les méthodes......................................................................................................................................... 29
2.10.1 Nom, Liste de paramètres et valeur de restitution......................................................................... 29
2.10.2 Signature, prototype et sur chargement (overloading) .................................................................. 31
2.10.3 La récursion................................................................................................................................... 32
2.11 La méthode principale main()............................................................................................................ 32
3 Introduction à la POO avec Java....................................................................................................................34
3.1 Introduction........................................................................................................................................... 34
3.1.1 Les problèmes des langage de programmation procédural............................................................ 34
3.1.2 Les types de donnée abstraits........................................................................................................ 34
3.1.3 Exigences pour les langage de programmation OO ...................................................................... 35
3.2 Caractéristiques des langages OO......................................................................................................... 35
3.2.1 Abstraction à l’aide d’objet........................................................................................................... 35
3.2.2 Encapsulation................................................................................................................................ 36
3.2.3 Héritage et polymorphisme........................................................................................................... 36
3.2.4 Caractéristiques de Java................................................................................................................ 37
3.3 Les classes et les objets......................................................................................................................... 37
3.3.1 Définition ...................................................................................................................................... 37
3.3.2 La syntaxe..................................................................................................................................... 38
3.3.3 Les attributs................................................................................................................................... 38
3.3.4 Les méthodes................................................................................................................................. 38
3.3.5 Modificateur d’accès..................................................................................................................... 39
3.3.6 Les diagrammes de classe............................................................................................................. 40
3.3.7 Les méthodes et les attributs de classe.......................................................................................... 41
3.3.8 Instancier un objet, constructeur ................................................................................................... 42
3.3.9 Destructeur et collecteur d’ordure (Garbage Collection) .............................................................. 44
3.3.10 Transmission et retour des objets.................................................................................................. 46
3.3.11 Les classes internes....................................................................................................................... 47
3.4 Héritage................................................................................................................................................. 48
3.4.1 Fondement..................................................................................................................................... 48
3.4.2 Ordre des constructeurs et des destructeurs................................................................................... 51
3.4.3 Les classes et méthodes abstraites................................................................................................. 53
3.4.4 Polymorphisme ............................................................................................................................. 56
3.4.5 Les casting des classes .................................................................................................................. 57
3.5 Relation entre les classes....................................................................................................................... 58
3.6 Les interfaces ........................................................................................................................................ 60
3.7 Les paquets............................................................................................................................................ 62
3.7.1 Utilisation et importation .............................................................................................................. 63
3.7.2 Les paquets mis à disposition par Java..........................................................................................64
3.7.3 Définition des paquets propres...................................................................................................... 64
3.7.4 Visibilité........................................................................................................................................ 66
3.8 Le design OO........................................................................................................................................ 66
3.8.1 UML.............................................................................................................................................. 66

Introduction à la programmation Java Introduction
Version 1.0, 11.02.09 Page 1
1 Introduction
1.1 Fondement
Java est un langage de programmation moderne, qui a développé par SUN Microsystems. Java a été introduit
officiellement en 1995 et est disponible avec sous licence Open Source depuis 1999.
1.1.1 Propriété du Java
Le langage de programmation Java possède les propriétés suivantes :
• Orienté objet : Tous les composants, mis à part les types de donnée simple comme les integer, character ou
boolean sont des objets.
• Indépendant de la plateforme : Les programmes Java peuvent être utilisés presque sur toutes les
plateformes (PC, Mac, Workstation ...) et systèmes d’opération (Windows, MAC-OS, Linux etc.).
• Interprété : Le code Byte du langage de programmation Java est interprété par la machine virtuelle, en
anglais Virtual Machine (VM). Le code byte peut être interprété soit sous forme d’applet (dans un
explorateur Internet) ou en tant qu’application indépendante.
• Robuste: Plusieurs dispositifs ont été mis à disposition pour éliminer les erreurs typiques de programmation
(pas de pointer, Garbage Collection ...).
• Sur : Des modèles de sécurité sont mis à disposition.
• Dynamique : Java charge uniquement les classes nécessaires à l’application, à travers le réseau.
• Ouvert : Les modules, qui ont été programmés dans un autre langage, peuvent être intégrés au programme
Java.
• Applicable en réseau : Une implémentation simple des systèmes en réseau est possible.
• Graphique: La programmation d’interface graphique (GUI) simple et indépendant de la plateforme est
possible.
• Multithreading : Java permet d’exécuter des tâches en parallèle et met à disposition des mécanicismes pour
les synchroniser.
• Bibliothèque de classes : Java met à disposition des multiples bibliothèques.
1.1.2 Champ d’application du Java
Java fut d’abord utilisé dans les secteurs classiques, comme celui des ordinateurs et des applications Internet.
Aujourd’hui Java est de plus en plus utilisé dans les consoles portables (en anglais handheld) comme les
téléphones portables, les agendas électroniques, Set-Top-Boxen etc. Toutefois, Java n’a toujours pas pu
s’affirmer dans le domaine des applications temps réel (voir chapitre 1.6).
1.1.3 Lecture
Go To Java 2, Guido Krüger, Addison-Wesley, ISBN 3-8273-1370-8

Introduction à la programmation Java Introduction
Version 1.0, 11.02.09 Page 2
1.1.4 Information disponibles sur le web
Documentation originale de SUN:
http://java.sun.com/docs
http://java.sun.com/docs/books/tutorial
1.2 Un premier exemple
Un premier exemple pour démontrer la simplicité du code Java :
/**
* First example of java code
*
* @author (FUE1)
* @version (1.0 17.11.03)
*/
public class Ex01
{
/**
* Principal program main()
* @The parameter args[0] contains the number of students
*/
public static void main(String args[])
{
int nbrStudents;
System.out.println("Hello"); // Displays "Hello"
if(args.length > 0) // Contains the program arguments
{ // yes --> define the number of students
nbrStudents = Integer.parseInt(args[0]);
System.out.println("The class contains " + nbrStudents + " students(s)");
}
System.exit(0); // end the program
}
}
Le code source Java ne se distingue guère d’un programme C/C++. Les remarques suivantes ont un caractère
introductif. Ils seront traités plus en détail dans les chapitres suivants :
• Un programme Java est composé de plusieurs classes.
• Chaque classe devrait être définie dans un fichier séparé.
• Les commentaire sont définis à l’aide de « /* */ » ou « / / ».
• Les instructions sont définies à l’aide de point-virgule.
• Chaque programme (à l’exception des applets) doit contenir la méthode principale
« public static void main (args[]) ».
• System.out.println() permet d’afficher un texte sur la sortie standard. Les chaînes de caractères peuvent
enchaînées à l’aide de « + ».
• System.exit() termine le programme.
1.3 Développement de programme en Java
SUN met à disposition gratuitement sur son site (www.java.sun.com) le JDK (Java Development Kit), qui
contient les outils suivants :
javac : Java-Compiler, traduit le code source en code byte