Programmation Orientée Objet avec

JAVA
Présenté par Abdoul Aziz Ciss
Docteur en Cryptologie, Consultant ITSec
LACGAA/FST/UCAD
Email: alekciss@gmail.com
Web : www.alekciss.com
Tel: 77 451 92 95
Plan
1. Introduction au langage Java
2. Techniques de base du langage
3. Les types primitifs
4. Les structures de contrôle
5. Programmation Orientée Objet
6. Les tableaux
7. Les chaines de caractères
8. L’héritage
9. La gestion des exceptions
10. Les Threads
11. Interfaces graphiques avec l’API Swing
12. Les Entrées/Sorties
13. Java Database Connectivity
14. Collections et Algorithmes
15. Applets
Introduction au langage Java
 Introduction
Java est un langage de programmation à usage général, évolué et
orienté objet, créé par James Gosling et Patrick Naughton employés
de Sun Microsystems. Sa syntaxe est proche du C. Ses caractéristiques
ainsi que la richesse de son écosystème et de sa communauté lui ont
permis d’être très largement utilisé pour le développement
d’applications de grande envergure.

Java est notamment largement utilisé pour le développement

d’applications d’entreprises et mobiles.
 Caractéristiques de Java
Un langage interprété:
Le code source est compilé en pseudo code ou byte code puis
exécuté par un interpréteur Java: la JVM (Java Virtual Machine). Ce
concept est à la base du slogan WORA ( Write Once, Run
Anywhere). Le byte code, s’il ne contient pas de code spécifique à
une plateforme particulière peut être exécuté et quasiment obtenir
les mêmes résultats sur toutes les machines disposant d’une JVM.

Des applications portables( indépendantes de toute plate-forme):

Le byte code reste indépendant de la machine sur laquelle il
s’exécute. Un programme Java peut être exécuté (dans la plupart des
cas) sur tous les environnements qui possèdent une JVM
 Caractéristiques de Java
Java est orienté objet:
Chaque fichier source contient la définition d’une ou plusieurs classes qui sont
utilisées les unes avec les autres pour former une application

Simplicité:
Pas de pointeurs, pas d’héritage multiple

Java est fortement typé:

Toutes les variables sont typées et il n’existe pas de conversion automatique qui
risquerait une perte de données.

Gestion de la mémoire:
L’allocation de la mémoire pour un objet est automatique à sa création et Java
récupère automatiquement la mémoire inutilisée grâce au garbage collector qui
restitue les zones mémoires laissées libres suite à la destruction d’un objet.
 Caractéristiques de Java
Sécurité:
La sécurité fait partie intégrante du système d’exécution du compilateur.
Un programme Java planté ne menace pas l’OS. Il ne peut pas y avoir
d’accès directe à la mémoire. L’accès au disque dur par une Applet est
règlementé.

Java est économe:

Le pseudo code a une taille relativement petite car les bibliothèques de
classes requises ne sont liées qu’à l’exécution.

LesThreads:
Java permet l’utilisation des threads qui sont des unités d’exécution isolées.
La JVM, elle-même, utilise plusieurs threads.
 Application et Applet
Il existe deux types de programmes avec les versions standards de
Java: les applications et les applets. Une application autonome (stand
alone program) est un programme qui s’exécute sous le contrôle de
l’OS. Une applet est une application qui est chargée par un navigateur
et qui est exécuté sous le contrôle d’un plugin de ce dernier.

Les principales différences entres les applets et les applications sont:

Les applets n’ont pas de méthodes main
Les applets ne peuvent pas être testées avec l’interpréteur mais doivent
être intégrés dans des pages HTML
 Brève historique
Mai 1995: premier lancement commercial
Janvier 1996: sortie du JDK 1.0.1
Décembre 1998: lancement de J2SE 1.2
Décembre 1998: lancement de J2EE
Janvier 2006: Java EE 5
Décembre 2006: Java SE 6.0
Décembre 2009: Java EE 6
Janvier 2010: rachat de Sun par Oracle
Juillet 2011 : Java SE 7
Java SE 8 en développement
Les différentes éditions et versions de Java
Sun fournit gratuitement un ensemble d’outils et d’API pour permettre le
développement de programmes avec Java. Ce kit, nommé JDK, est librement
téléchargeable.
Le JRE (Java Runtime Environment) contient uniquement l’environnement
d’exécution des programmes. Le JDK contient lui-même le JRE. Le JRE seul doit
être installé sur les machines où des applications Java doivent être exécutées.

Depuis sa version 1.2, Java a été renommé Java 2. Les numéros de version 1.2 et 2
désignent donc la même version. Le JDK a été renommé J2SK (Java 2 Software
Developement Kit) mais la dénomination JDK reste encore largement utilisée.
Les différentes éditions et versions de Java
Sun définit trois plateformes d'exécution (ou éditions) pour Java pour des
cibles distinctes selon les besoins des applications à développer :

Java Standard Edition (J2SE / Java SE): Environnement d’exécution et

ensemble complet d’API pour des applications de types desktop. Cette
plateforme sert de base en tout ou partie aux autres plateformes.

Java Enterprise Edition (J2EE / Java EE): environnement d’exécution reposant

intégralement sur Java SE pour le développement d’applications d’entreprises.

Java Micro Edition (J2ME / Java ME): environnement d’exécution et API pour
le développent d’applications sur appareils mobiles et embarqués dont les
capacités ne permettent pas la mise en œuvre de Java SE.
 Installation du JDK
Le JDK et la documentation sont librement téléchargeables sur le site web
d’Oracle : http://www.oracle.com

Pour un bon fonctionnement du JDK, il est recommandé de paramétrer

correctement deux variables systèmes: la variable PATH qui définit les
chemins de recherches des exécutables et la variable CLASSPATH qui
définit les chemins de recherche des classes et bibliothèques Java.

Il est aussi utile de définir la variable d'environnement JAVA_HOME avec

comme valeur le chemin d'installation du SDK.
Techniques de base du langage
 Compilation et exécution
Un programme Java est composé d’un ou plus généralement de plusieurs
fichiers sources. N’importe quelle éditeur de texte peut être utilisé pour
éditer un fichier source Java.

Ces fichiers sources possèdent l’extension .java. Ils peuvent contenir une
ou plusieurs classes ou interfaces mais il ne peut y avoir qu’une seule classe
ou interface déclarée publique par fichier. Le nom de ce fichier source doit
obligatoirement correspondre à la casse près au nom de cette entité
publique suivi de l’extension .java.

Il est nécessaire de compiler le source pour le transformer en J-code ou

byte-code Java qui sera lui exécuté par la JVM.
 Compilation et exécution
Un compilateur Java, par exemple l’outil javac (Java Compiler) fourni
avec le JDK est utilisé pour compiler chaque fichier en fichier de classe
possédant l’extension .class. Cette compilation génère pour chaque fichier
source un ou plusieurs fichiers .class qui contiennent du byte-code.
 Un premier exemple
Contenu du fichier source MaClasse.java :

public class MaClasse{

public static void main (String args[]){
System.out.println("Bonjour le monde ");
}
}

Compilation (génération du byte-code MaClasse.class)

javac MaClasse.java

Exécution ( du byte-code)
java MaClasse

Résultat: Affichage de « Bonjour le monde » à l’écran.

 Structure du programme
public class MaClasse: entête de la classe
Le mot clé public dans public class sert à définir les droits
d’accès des autres classes
Le mot clé static précise que la méthode main n’est liée à aucune
instance de la classe.
Le paramètre String args est un tableau de chaînes de caractères
qui permet de récupérer des arguments transmis au programme au
moment de son exécution
Le mot clé public dans public static void main est
obligatoire pour que le programme s’exécute. Il s’agit d’une convention
qui permet à la JVM d’accéder à la méthode main.
 Un second exemple
Le compilateur génère autant de fichier .class que de classes et interfaces définies
dans le fichier source.

public class MaClasse {

public static void main(String[] args) {
System.out.println("Bonjour le monde");
}
}

class MonAutreClasse {
public static void afficher(String message) {
System.out.println(message);
}
}

Après compilation du source, MaClasse.java, on obtient deux fichiers .class,

MaClasse.class et MonAutreClasse.class
 Les packages
Les fichiers sources peuvent être organisés en packages. Les packages
définissent une hiérarchie de noms, chaque nom étant séparé par le
caractère point. Le nom d'un package est lié à une arborescence de sous
répertoire correspondant à ce nom.
Ceci permet de structurer les sources d'une application car une application
peut rapidement contenir plusieurs centaines voir milliers de fichiers
source. Les packages permettent aussi d'assurer l'unicité d'une classe grâce
à son nom pleinement qualifié (nom du package suivi du caractère "."
suivi du nom de la classe).
 Les packages
Le package est précisé dans le fichier source grâce à l'instruction
package. Le fichier doit donc dans ce cas être stocké dans une
arborescence de répertoires qui correspond au nom du package.
Exemple:
package dev.ciss.test;

public class MaCLasseTest {

public static void main(String t[]) {
System.out.println("Bonjour");
}
}
 Les packages
Si les sources de l'application sont dans le répertoire
C:\Documents and Settings\CiZ\workspace\Tests,
alors le fichier MaCLasseTest.java doit être dans le répertoire
C:\Documents and Settings\CiZ\workspace\Tests\dev\
ciss\test.

Si aucun package n'est précisé, alors c'est le package par défaut

(correspondant au répertoire courant) qui est utilisé. Ce n'est pas une
bonne pratique d'utiliser le package par défaut sauf pour des tests.
 Déploiement sous la forme d’un jar
Il est possible de créer une enveloppe qui va contenir tous les fichiers d'une
application Java ou une portion de cette application dans un fichier .jar
(Java archive). Ceci inclus : l'arborescence des packages, les fichiers .class,
les fichiers de ressources (images, configuration, ...), ... Un fichier .jar est
physiquement une archive de type Zip qui contient tous ces éléments.
L'outil jar fourni avec le JDK permet de manipuler les fichiers jar.

Exemple:
jar -cvf MaClasse.jar MaClasse.class

Le fichier .jar peut alors être diffusé et exécuté s’il contient au moins une
classe avec une méthode main().
java –cp MaClasse.jar MaClasse
 Règles de base
Java est sensible à la casse.
Les blocs de code sont encadrés par des accolades. Chaque instruction se
termine par un caractère ';' (point virgule).
Une instruction peut tenir sur plusieurs lignes

L'indentation est ignorée du compilateur mais elle permet une meilleure

compréhension du code par le programmeur.
 Les identificateurs
Chaque objet, classe, programme ou variable est associé à un nom :
l'identificateur qui peut se composer de tous les caractères
alphanumériques et des caractères _ et $. Le premier caractère doit
être une lettre, le caractère de soulignement ou le signe dollar.

Rappel : Java est sensible à la casse.

 Mots réservés
Un identificateur ne peut pas appartenir à la liste de mots réservés de
Java:
 Les commentaires
Les commentaires facilitent la lecture et la compréhension du source.
Ils ne sont pas pris en compte par le compilateur et ne sont donc pas
inclus dans le byte-code. Il existe deux types de commentaires en
lignes.

Exemples de commentaires:
//Commentaire sur une seule ligne
int cpt = 1 ; // Déclaration du compteur

/* Ceci est un commentaire

sur deux lignes */
 Les commentaires
Un bon commentaire permet d’utiliser une fonction sans même
consulter le code.
Il indique à l’aide d’une phrase le rôle de la fonction en faisant intervenir
le nom de tous les paramètres.
Il précise le rôle de chaque paramètre
Il indique la signification du résultat retourné

Commenter si nécessaire des fragments de codes difficiles.

Eviter les commentaires inutiles du genre
x = 3 ;// x prend la valeur 3
Les types primitifs
 Les types primitifs
Java dispose d’un certain nombre de types de base dits primitifs,
permettant de manipuler des entiers, des flottants, des caractères et
des booléens.

Ce sont les seuls types du langage qui ne sont pas des classes.
Les types primitifs(au nombre de 8) se répartissent en quatre grandes
catégories selon la nature des informations qu’ils permettent de
manipuler:
Les entiers
Les flottants
Les caractères
Les booléens
 Les type entiers
Ils servent à représenter les nombres entiers relatifs, ils sont au
nombre de 4:
byte (8 bits) : [-128; 127]
short (16 bits) : [−2^16 ; 2^16 - 1]
int (32 bits) : [−2^32 ; 2^32 - 1]
long (64 bits): [−2^64 ; 2^64 - 1]

Les types élémentaires ont une taille identique quelque soit la plateforme
d’exécution
 Les types flottants
Ils permettent de représenter, de manière approchée, une partie des
nombres réels. Il existe deux types de flottants en Java:
float (32 bits)
double (64 bits)

Exemple :
float pi = 3.141f; //suffixe f obligatoire
double valeur = 3d; // suffixe d non obligatoire
float flottant1 = 2e10f, flottant2 = 1.6f ;
 Les caractères
Un caractère est codé sur 16 bits car il est conforme à la norme
Unicode. Il doit être entouré par des apostrophes. Une valeur de type
char peut être considérée comme un entier non négatif de 0--65535.

Une variable de type caractère se déclare:

char c1, c2 ; // c1 et c2 sont des variables de types
//caractères
 Le type booléen
Ce type sert à représenter une valeur logique du type vrai/faux. Il ne
peut donc prendre que deux valeurs (true ou false).

En Java, un booléen se déclare:

boolean ok = false ;
 Initialisation des variables
Exemple:
int nombre ; // Déclaration de la variable nombre
nombre = 100 ; // initialisation de la variable
int nombre1 = 150 ; // déclaration et initialisation
//de la variable nombre1

Remarque:
Une variable manipulée dans une méthode (variable locale) ou un
bloc devra toujours être initialisée avant toute utilisation.
La déclaration d’une variable réserve de la mémoire pour stocker sa
valeur.
 Initialisation des variables
En Java, toute variable appartenant à un objet (définie comme étant un
attribut de l’objet) est initialisée avec une valeur par défaut en accord avec
son type au moment de sa création.

Cette initialisation ne s’applique pas aux variables locales des méthodes de

la classe.

Type Valeur par défaut

boolean false
byte, short, int, long 0
float, double 0.0
char u\000
objet null
 Utilisation des variables
package dev.ciss.test;

public class UtilVar{

static String chaine ;//chaine est initialisée à null
static double solde ; // solde est initialisé à 0.0

public static void main (String args[]){

System.out.println("valeur de solde: "+solde);
affiche() ; // erreur de compilation
}

public static void affiche (){

int nombre;
System.out.println("valeur de nombre: "+nombre) ;
}
}
 Variables finales (constantes)
En Java, une constante (variable finale) se déclare avec le mot clé final. Une
constante est déclarée et initialisée au même moment. Une tentative de
modification de la valeur de celle-ci entrainera des erreurs de compilation.

package dev.ciss.test;

public class VarFinale {

static final int MIN = 150 ;

public static void main (String []args ){

System.out.println("Valeur de MIN "+MIN)
}
}
 Les opérateurs arithmétiques usuels
package dev.ciss.test;

public class Operateurs {

public static void main (String []args ){

int a = 89, b = 4 ;
int add, sous, prod, quot ;

add = a + b ;
sous = a – b ;
prod = a * b ;
quot = a / b ;
System.out.println("a + b = "+add);
System.out.println("a - b = "+sous);
System.out.println("a * b = "+prod);
System.out.println("a / b = "+quot);
}
}
 Conversions implicites
Les opérateurs arithmétiques ne sont définies que lorsque les deux opérandes sont
de même type. Mais on peut écrire des expressions mixtes dans lesquelles
interviennent des opérandes de types différents.
Exemple:

public class ConversionImplicite{

public static void main(String args []){
int a = 10 ;
float p = 14 ;
double d = p + a;
System.out.println("la valeur de l'expression
mixte (p+a) est :"+d);
}
}
Résultat: 24.0
 Ajustement de type
Une conversion telle que int en float est appelée ajustement de
type.

Elle ne peut se faire que suivant une hiérarchie qui permet de ne pas
dénaturer la valeur initiale:
int long float double

Remarque:
Une conversion de double en float n’est pas légale.
Pour l’exemple précédent, on ne peut pas faire:

int k = p + a ; //erreur de compilation

 Promotion numérique
Les opérateurs numériques ne sont pas définies pour les types byte, char
et short.
Toute opération qui utilise l’un de ces types nécessite une conversion
préalable dans le type int. Cette conversion porte le nom de promotion
numérique.
Exemple:

public class PromotionNum{

public static void main(String chaine[]){
char car = ‘d’ ;
short s = 0 ;
int n = c + s ; //conversion de c et de s
//en int puis stock de c+s dans n
System.out.println("c + s = "+n) ;
}
}
 Opérateur de cast
L’expression suivante
byte b = 3 ;
b = b + 1 ;

n’est pas correcte mais on peut écrire ceci:

byte b = 3 ;
b = (byte) (b + 1) ;
Dans ce cas, b + 1 est converti d’abord en int puis on force le
résultat dans le type byte et l’affecte à b.
L’opérateur, (type), permettant de réaliser cette opération est
appelé opérateur de cast
 Opérateurs de comparaison
Opérateur Exemple Signification
> a > 10 strictement supérieur
< a < 10 strictement inférieur
>= a >= 10 supérieur ou égal
<= a <= 10 inférieur ou égal
== a == 10 Égalité
!= a != 10 diffèrent de
&& a && b ET logique (pour expressions
booléennes)
|| a || b OU logique (pour expressions
booléennes) :
?: a?b:c opérateur conditionnel : renvoie
la valeur b ou c selon l'évaluation
de l'expression a
Les structures de contrôle
 Choix: if…else
Syntaxe:

if (condition){
expression1 ;
}
else{
expression2;
}

condition est une expression de type booléenne, expression1 et

expression2 sont des suites d’instructions.
Si condition est vérifié expression1 sera exécutée. Dans le cas
contraire, c’est expression2 qui sera exécutée.
 Choix: if…else
Exemple:

double note ;
…
if (note >= 16)
System.out.println("Mention Très bien") ;
else if ((note > 12) && (note < 14) )
System.out.println("Mention Bien") ;
else
System.out.println("Mention Passable") ;
 Choix: switch
Syntaxe:
switch (expression) {
case constante1: instruction1 ; break ;
case constante2: instruction2 ; break ;
…
case constanteN : instructionN ; break ;
default : instcution ;
}

On ne peut utiliser switch qu’avec des types primitifs d’une taille

maximum de 32 bits (byte, short, char, int).
Si une instruction case ne contient pas d’instruction break alors les
traitements associés au case suivant sont exécutés.
 Choix: switch
Exemple:

char option;
int x , n ;
…
switch (option){
case 'C' : x = carre (n) ; break ;
case 'F' : x = factorielle(n); break ;
default :
System.out.println("Fonction non définie !");
}
 L’instruction while
Syntaxe:
while (expression ) {
instruction ;
}

il s’agit d’une boucle: tant que expression ( de type booléen) est

vraie (ie = true), instruction sera exécutée.
 L’instruction while
Exemple:

int i = 1, Max = 14 ;

while (i <= Max) {

System.out.println("i = "+i);
i++ ;
} //valeurs de i de 1 à 14
 L’instruction do … while
Syntaxe:
do {
instruction ;
} while (expression ) ;

l’instruction do...while a un fonctionnement globalement

similaire à celui d’une boucle while mise à part le fait que le corps
de la boucle est exécuté avant que l’expression de contrôle soit
évaluée
 L’instruction do…while
Exemple:

int i = 1, Max = 14 ;

do {
System.out.println("i = "+i);
i++ ;
} while ( i <= Max) ;
//valeurs de i de 1 à 14
 L’instruction for
Syntaxe:
for(expression1 ; expression2 ; expression3)
{
instructions
}

expression1 et expression3 peuvent être n’importe quelle

expression, expression2 est une expression de contrôle
(expression booléenne).
 L’instruction for
Exemple:

int Max = 14 ;
for (int i = 0 ; i < Max ; i++) {
System.out.println("i = "+i);
}
/* valeurs de i de 0 à 13 */
 L’instruction break
L’instruction break s’emploie principalement au sein d’une boucle. Elle set à
interrompre le déroulement de la boucle, en passant à l’instruction suivant la
boucle.

Exemple:
public class Break {
public static void main (String args []){
for (int i = 0; i < 10; i++){
if (i==4)
break ;
System.out.println("i = "+i) ;
}
}
}

Résultat: i = 0, i = 1, i = 2, i = 3
 L’instruction continue
L’instruction continue permet de passer prématurément au tour de boucle suivant.

Exemple:
public class Continue {
public static void main (String args []){
for (int i = 0; i < 10; i++){
if ((i==4) || (i==7) )
continue ;

System.out.println("i = "+i) ;
}
}
}
Résultat: i = 0, i = 1, i = 2, i = 3, i = 5, i = 6, i =
8, i = 9