Programmation Orientée Objet , Java

Java SE 8 (1Z0-803)

Pr. Chiheb CHAIEB ©

Plan du cours (1/4)

1. Introduction générale et historique

 Le langage de programmation Java
 La plateforme Java
2. Première application en Java
3. Syntaxe et sémantique de Java
 Identificateurs
 Types primitifs et types de référence
 Tableaux et chaînes de caractères
 Arithmétique et opérateurs
 Instructions de contrôle
4. Premiers concepts de l’orienté objets
 Programmation procédurale v/s Programmation OO
 Concepts de l’OO
 Représentations UML
2
Plan du cours (2/4)

5. Programmation orientée objets en Java

 La création d’objets: Constructeurs et mot-clé « new »
 Les variables: Déclaration et portée
 Les méthodes: Déclaration, interface et surcharge
 L’encapsulation: « public », « private » et « protected »
 Les membres d’instance et de classe: « static »
 Utilisation de l’héritage: « this » et « super »
 Conversion de types
 Polymorphisme
 Classes abstraites
 Interfaces
» 3
Plan du cours (3/4)

6. Structure des API de Java

7. La gestion des Exceptions
 Principes et hiérarchie des classes d’exceptions
 Interception par bloc try – catch – finally
 Lancement par mots-clés throws et throw
8. Multithreading (en Exposé)
 Définition
 Raison d’être
 Création
 Gestion
9. Annexes
 Java et ses concurrents
 Les utilitaires de Java
Objectifs du cours (1/2)

 Décrire les éléments-clé de la plate-forme Java

 Compiler et exécuter une application Java
 Comprendre et utiliser la documentation en ligne de Java
 Décrire la syntaxe du langage
 Comprendre le paradigme OO et utiliser Java pour le
mettre en œuvre
 Comprendre et utiliser les exceptions
 Comprendre les bases du multithreading *

» 5
Références Médias graphiques
Ouvrages :
 Claude Delannoy : programmer en java, Eyrolles 2012
 H. Bersini, La programmation orientée objet, Cours et exercices en
UML 2, avec Java, C# 2, C++, Python, PHP 5 et LINQ, Eyrolles 2008
 C.Delannoy, S'initier à la programmation : Avec des exemples en C,
C++, C#, Java et PHP, Eyrolles, 2008
 C.S. Horstmann, G. Cornell, au cœur de Java 2, Campus Press 2005.
 G.Clavel, et al., Java, La synthèse, Dunod 2003.
Sites Web :
 Site officiel Java français : http://www.java.com/fr/:
 The Java Tutorial from Sun : http://java.sun.com/docs/books/tutorial/
 The Java Developer Connection :
http://developer.java.sun.com/developer/index.html
Introduction à Java

I. Introduction et historique
Survol du chapitre

 Qu’est-ce que Java ?

 Java comme langage de programmation
 La plateforme Java
 La Java Virtual Machine (JVM)
 Les interfaces de programmation d’application (API)
 Déploiement d’un programme
 Quelques notions historiques
Qu’est-ce que Java ?

 Java est un langage de programmation

 Un programme Java est compilé et interprété
 Java est une plateforme
 La plateforme Java, uniquement software, est exécutée sur la
plateforme du système d’exploitation
 La « Java Platform » est constituée de :
 La « Java Virtual Machine » (JVM)
 Des interfaces de programmation d’application (Java API)
 JDK Java Developpement Kit installe un environnement soft
pour le développement plus une JVM (API, JavaC, Java, javaDoc,
Jar, Swing, JDBC …)
Java comme langage de programmation

Java est un langage de programmation particulier qui

possède des caractéristiques avantageuses:
 Simplicité et productivité:
 Intégration complète de l’OO
 Gestion mémoire (« Garbage collector »)
 Robustesse, fiabilité et sécurité
 Indépendance par rapport aux plateformes
 Ouverture:
 Support intégré d’Internet
 Connexion intégrée aux bases de données (JDBC)
 Support des caractères internationaux
 Distribution et aspects dynamiques
 Performance
Java comme langage de programmation
Simple et orienté objet

 Java est un langage de programmation simple

 Langage de programmation au même titre que
C/C++/Perl/Smalltalk/Fortran mais plus simple
 Les aspects fondamentaux du langage sont rapidement assimilés
 Java est orienté objet :
 La technologie OO après un moment de gestation est maintenant
complètement intégrée
 En java, tout est un objet (à la différence du C++ par ex.)
 Simple aussi parce qu’il comporte un grand nombre
d’objets prédéfinis pour l’utilisateur
 Java est familier pour les programmeurs C++
Java comme langage de programmation
Robuste et sécurisé
 Conçu pour créer des logiciels hautement fiables
 Oblige le programmeur à garder à l’esprit les erreurs
hardware et software
 Vérifications complètes à l’exécution et à la compilation
 Existence d’un « garbage collector » qui permet d’éviter
les erreurs de gestion de la mémoire
 Portable grâce à l’exécution par une machine virtuelle : «
Write once, run everywhere »
 Multi-tâches (thread)
 Ouvert sur le Web (API Java EE)
Java comme langage de programmation
Neutre architecturalement

 Il existe une grande diversité de

MyProgram.java
systèmes d’exploitation
 Le compilateur Java génère un
bytecode, c’est à dire un format
Java Compiler
intermédiaire, neutre
architecturalement, conçu pour
faire transiter efficacement le
code vers des hardware MyProgram.class
différents et/ou plateformes = bytecode
différentes
 Le bytecode ne peut-être JVM JVM JVM
interprété que par le
Mac Windows Unix
processeur de la JVM
Déploiement d’un programme (1/2)
Paradigme classique de la compilation

MyProgram.c

Exécuté une seule fois Génère du code natif directement

Mais différent pour Compiler exécutable, mais spécifique à
chaque environnement chaque environnement

MyProgram.o

010110…
Déploiement d’un programme (2/2)
Changement de la vision traditionnelle de la compilation
 Chaque programme est compilé et interprété
 « Write once run everywhere »

MyProgram.java

Traduit le programme en un code intermédiaire

Exécuté une seule fois Compiler Appelé bytecode – indépendant de la machine

MyProgram.class

Chaque fois que le

programme est exécuté Interpreter Lit le bytecode et exécute sur la machine

010110…
Langage interprété

Cas de Java
Avant exécution Exécution

Autres byte code

Fichier
Byte code Machine virtuelle
de code Compilation
Java (JVM)
Java
javac MaClasse.class java
MaClasse.java

16
Java, Atouts
 Java a su faire une synthèse efficace de bonnes idées
issues de sources d'inspiration variées :
 Smalltalk, C++, Ada, etc.
 Connectivité aux bases de données
 JDBC: Java DataBase Connectivity
 Offre des facilités de connexions à la plupart des BD du
marché (MYSQL, Oracle, SQLServer, Informix , ODBC etc..)
 Support des caractères internationaux
 Java utilise le jeu de caractères UNICODE
 JVM adapte automatiquement les paramètres régionaux en
fonction de ceux de la machine sur laquelle elle tourne
 Support intégré d’Internet
 La Class URL
 Communication réseaux TCP et UDP
 RMI, CORBA, Servlets, JSP
17
Java, Atouts (2)

 Considération basique
 Exécution ralentie à cause de l’interpréteur ?
 Plusieurs processus peuvent être exécutés en même
temps
 Comparable au multitâche d’un OS
 Le temps du CPU est divisé (sliced)
 Toutes les bibliothèques Java

 Edition de lien effectuée à l’exécution du programme

 Codes exécutables chargés depuis un serveur distant
permet la mise à jour transparente des applications
Java comme Plateforme

 Plateforme = environnement hardware ou software sur

lequel le programme est exécuté.
 La Java « Platform » se compose de:
 la Java Virtual Machine (Java VM)
 la Java Application Programming Interface (Java API)
L’API de Java
Java fournit de nombreuses librairies de
classes remplissant des fonctionnalités
très diverses : c'est l'API Java
 API (Application and Programming Interface
/Interface pour la programmation d'applications) :
Ensemble de bibliothèques permettant une
programmation plus aisée car les fonctions
deviennent indépendantes du matériel.
Ces classes sont regroupées, par
catégories, en paquetages (ou
"packages").

20
L’API de Java (2)

 Les principaux paquetages

 java.util : structures de données classiques
 java.io : entrées / sorties
 java.lang : chaînes de caractères, interaction avec l'OS,
threads
 java.applet : les applets sur le web
 java.awt : interfaces graphiques, images et dessins
 javax.swing : package récent proposant des composants
« légers » pour la création d’interfaces graphiques
 java.net : sockets, URL
 java.rmi : Remote Method Invocation (pas abordé dans ce
cours)
 java.sql : fournit le package JDBC (pas abordé dans ce
cours)
21
L’API de Java (3)

La documentation de Java est standard,

que ce soit pour les classes de l'API ou
pour les classes utilisateur
 possibilité de génération automatique avec
l’outil Javadoc.
Elle est au format HTML.
 intérêt de l'hypertexte pour naviguer dans
la documentation

22
L’API de Java (4)
Pour chaque classe, il y a une page HTML
contenant :
 la hiérarchie d'héritage de la classe,
 une description de la classe et son but général,
 la liste des attributs de la classe (locaux et hérités),
 la liste des constructeurs de la classe (locaux et
hérités),
 la liste des méthodes de la classe (locaux et hérités),
 puis, chacune de ces trois dernières listes, avec la
description détaillée de chaque élément.

23
L’API de Java (5)
Où trouver les informations sur les classes de
l’API
 sous le répertoire jdk1.x/docs/api dans le JDK
 les documentations de l’API se téléchargent et
s’installent (en général) dans le répertoire dans
lequel on installe java.
Par exemple si vous avez installer Java dans le
répertoire D:/Apps/jdk1.4/, vous décompresser le
fichier zip contenant les documentations dans ce
répertoire.
Les docs de l’API se trouveront alors sous :
D:/Apps/jdk1.4/docs/api/index.html
 Sur le site de Sun, on peut la retrouver à
http://java.sun.com/docs/index.html

24
L’API de Java (6)

25
Outil de développement : le JDK
Environnement de développement fourni par
Sun
JDK signifie Java Development Kit (Kit de
développement Java).
Il contient :
 les classes de base de l'API java (plusieurs centaines),
 la documentation au format HTML
 le compilateur : javac
 la JVM (machine virtuelle) : java
 le visualiseur d'applets : appletviewer
 le générateur de documentation : javadoc
 etc.
26
Java comme Plateforme
Java Virtual Machine (JVM) (1/2)
 « An imaginery machine that is implemented by emulating
it in software on a real machine. Code for the JVM is
stored in .class files, each of which contains code for at
most one public class »
 Définit les spécifications hardware de la plateforme
 Lit le bytecode compilé (indépendant de la plateforme)
 Implémentée en software ou hardware
 Implémentée dans des environnements de
développement ou dans les navigateurs Web
Java comme Plateforme
Java Virtual Machine (2/2)
La JVM définit :
 Les instructions de la CPU
 Les différents registres
 Le format des fichiers .class
 Le tas (« Heap ») des objets « garbage-collectés »
 L’espace mémoire
Java comme Plateforme
Java Runtime Environment (JRE)
Trois tâches principales :
 Charger le code (class loader)
 Vérifier le code (bytecode verifier)
 Exécuter le code (runtime interpreter)

D’autres THREAD s’exécutent :

 Garbage collector : est une fonctionnalité de la JVM qui a pour rôle
de gérer la mémoire notamment en libérant celle des objets qui ne
sont plus utilisés.
Bref Historique
 Le langage Java est un langage de
programmation informatique orienté objet créé par James
Gosling et Patrick Naughton, employés de Sun Microsystems,
avec le soutien de Bill Joy (cofondateur de Sun
Microsystems ),
 présenté officiellement le 23 mai 1995 au SunWorld.1995 :
 rachetée en 2009 par la société Oracle
 Intégration de la JVM dans Netscape
 Apparition des Applets
 Explosion d’Internet  attrait grandissant pour Java , Java EE
 Versions :
 Java 2 SE 1.2, Java 2 SE 1.3, Java 2 SE 1.4, Java 2 SE 5.0, Java 2 SE
1.2, Java SE 6 (12/12/2006) , Java SE 7, Java SE 8 (2015), Java SE 9
(2017).
INTRODUCTION A LA PROGRAMMATION
ORIENTEE OBJET
Concepts de Base de l’Orienté Objet
Approche Fonctionnelle

 L’approche fonctionnelle trouve son origine dans les

langages procéduraux (comme le langage C , Pascal ...).
 Elle propose une décomposition hiérarchique
descendante et modulaire pour résoudre un problème à
fin de développer le programme correspondant.
 Dans une telle approche, les programmes sont composés
d'une série de fonctions regroupant des instructions
pour produire à la fin de l’exécution des résultats.
Approche Objet
 Le concept ‘orienté objet’ consiste à modéliser
informatiquement un ensemble d'éléments d'une partie du
monde réel (et pas les fonctions) en un ensemble
d'entités informatiques. Ces entités informatiques sont
appelées objet. Il s'agit de données informatiques
regroupant les principales caractéristiques des éléments
du monde réel , comme une voiture , une personne, une
ville, un produit, un equipement etc,
 L'intérêt principal est que les fonctions qui permettent de
manipuler les objets sont directement associées à l'objet
lui-même, Chaque objet accomplit quelques tâches
associées
Approche Objet
 Si un objet dépend d’une tâche qui n’est pas de sa
responsabilité, il doit avoir accès à un autre objet capable
d’accomplir cette tâche.
 Le premier demande au second d’accomplir la tâche en
question (version plus généralisée des appels de
fonctions en programmation traditionnelle).
 En programmation O.O., on identifie d’abord les classes
(concepts), et c’est ensuite seulement que l’on cherche
les méthodes.
Concepts de Base de la P.O.O

 La POO se base principalement sur les concepts

suivants :
 Objet
 Classe
 Encapsulation
 Héritage
 Polymorphisme.
Concept Objet

 Définition
On peut qualifier un objet de la façon suivante: « un
objet est quelque chose de réel ou d'abstrait, de
tangible ou d'intangible, à propos duquel on
emmagasine des données et les méthodes permettant
de les manipuler».©
• La structure d’un objet est composée de 2
catégories de champs :
Les Attributs
Les Méthodes
 Réf: [Objet2000] ©: Bouzeghoub M., Gardarin G., Valduriez P., Les objets,
Eyrolles, 2000
Concept Objet

 Les attributs (ou champs de données ou propriétés) qui

décrivent les caractéristiques de l'objet. La valeur des
données membres définit l'état de l'objet. Les
comportements peuvent évidemment changer l'état d'un
objet.
 Les méthodes (fonctions, actions) qui décrivent les
comportements dont l'objet est doté. Ces
"comportements" agissent en général sur les valeurs des
attributs. Ces opérations permettent de faire réagir l’objet
aux sollicitations extérieures (ou d’agir sur les autres
objets).
Concept Objet

Les opérations sont étroitement liées aux

attributs, car leurs actions peuvent dépendre des
valeurs des attributs, ou bien les modifier.
Concept Objet
 Chaque objet associe des données et des méthodes
agissant exclusivement sur les données de l’objet.
 Exemple : l’objet Cercle, caractérisé par un rayon (r),
l’abscisse et l’ordonnée du centre.
Cercle Classe Cercle
r : double
c-x : int Attributs (r : rayon , c-x : abscisse , c-y :ordonnée)
c-y : int

Périmètre() : double
Méthodes

Surface() : double
Move (dx, dy) : void

 En résumé : Objet = identité + attributs + méthodes

Concept Classe
 Une classe est un type, un modèle abstrait d'objet. Définir
une classe consiste donc en la description d'un ensemble
d'objets de mêmes caractéristiques et de mêmes
comportements. En effet une classe n’est rien d’autre
qu’une description d’un type d’objet.
 Un objet est une instance de cette classe, c'est-à-dire un
élément concret, un exemplaire de cette classe.
 Une fois la classe déclarée, on peut créer autant
d'instances (d’objets) de cette classe que l'on veut. Tous
ces objets auront la même description (attributs avec des
valeurs spécifiques) et des comportements communs
(méthodes).
 En particulier, aucune méthode (fonction) n'est définie
indépendamment et en dehors d'une classe.
Concept Classe
 Classe = instanciations+ attributs (variables d'instances)+
opérations
 L’instanciation :
L’objet possède une identité, qui permet de le distinguer
des autres objets, indépendamment de son état.
L'instanciation représente la relation entre un objet et sa
classe d'appartenance qui a permis de le créer.
 Les attributs (appelés aussi variables d'instances):
Ils ont un nom et soit un type de base ou complexe,
 Les opérations (appelées aussi méthodes):
Elles sont les opérations applicables à un objet de la
classe. Elles peuvent modifier tout ou en partie de son état,
Concept Classe
Objet 2 : Cercle C2

Objet 1 : R = 2.1
Cercle C1 Instance 2 c‐x= 35
Instance 1
R = 1.75 c‐y = 8
c‐x=
c 10, c‐y=
y= 8

Surface() Périmètre()
Move() Méthodes

r :double +
c-x :int
c-y :int
Attributs

La Classe Cercle et ses Instances (Objets C1 et C2)

Introduction à Java

II. Première application en Java

Comment développer une application?

Deux façons d’écrire des programmes Java:

 En écrivant le code dans un simple éditeur de texte
 Compilation et exécution du code en ligne de commande DOS

 En utilisant un environnement de développement (IDE)

 Eclipse (https://eclipse.org/downloads/)
 Netbeans (http://www.netbeans.com)
 Borland JBuilder (http://www.borland.com/jbuilder)
 IBM WebSphere Studio (http://www.ibm.com/software/awdtools)
 Sun ONE Studio (http://wwws.sun.com/software/sundev)
 Microsoft .Net Studio (http://msdn.microsoft.com/vstudio)
 …
Une première application
Application versus Applet
 Une application Java
 est composée d’une classe possédant une méthode main() :
public static void main (String[] args){
//code à exécuter pour initialiser l’application
}
 L’environnement d’exécution dépend de l’OS de la machine
 Pas de restriction au niveau des API

 Une applet Java

 Comprend une classe publique dérivant de java.applet.Applet
 L’environnement d’exécution dépend du browser Web
 Restrictions au niveau des API
 Généralement pas autorisée à lire ou écrire sur des fichiers locaux.
 Interdiction d’ouvrir des connections réseaux vers d’autres systèmes que la machine
hôte qui a chargé l’applet
 …
Une première application EX 2.1

Application HelloWorld
 Créer un fichier texte : HelloWorld.java
 Règle de bonne pratique : 1 classe par fichier et 1 fichier par classe

public class HelloWorld La première ligne du programme doit être la

déclaration de la classe
{
public static void main (String[]args) Tout programme doit contenir une classe
main qui comporte la méthode
{
main qui porte la signature ci-contre
System.out.println("Hello the World");
Écrire à l’écran “Hello the World”
}
} Fermer les accolades

 Compiler le programme : javac HelloWorld.java

 Le compilateur génère le bytecode dans le fichier : HelloWorld.class
 Exécuter l’application : java HelloWorld
 « Hello the World » s’affiche à l’écran
Une première application EX 2.1

Application HelloWorld
 Le mot-clé static précise que la méthode main() n’est pas liée
à une instance (objet) particulière de la classe : c’est la
fonction principale
 Le paramètre « String[] args » qui est obligatoire permet de
récupérer des arguments transmis au programme au moment
de son lancement.
 Le mot-clé public dans public class HelloWorld sert à définir
les droits d’accès des autres classes.
 Le mot-clé public dans public static void main est obligatoire
pour permettre à la machine virtuelle d’accéder à la méthode
main.
 System.out.println correspond à une méthode d’affichage
dans la fenêtre console, associée à l’objet System.out
Etapes d’exécution d’un programme Java EX 2.1

 L’exécution d’un programme JAVA suit 3 étapes (cf Figure 5) :

 Edition du code source JAVA :
Le fichier source d’un programme Java est un fichier texte écrit avec la
syntaxe du langage Java. Une application se compose d’un ou de
plusieurs fichiers sources. Ces fichiers possèdent l’extension
« .java ». un fichier contiendra la classe principale qui démarre
l’exécution de l’application. Cette classe contient la méthode main().
 Compilation :
Les sources Java doivent être compilées afin de générer le Byte Code.
Les fichiers générés ont l’extension « .class ».
 Interprétation :
Pour exécuter une application Java, on doit lancer une machine
virtuelle Java (JVM) en lui spécifiant ce qu’il faut exécuter.
Celle-ci va charger dynamiquement les fichiers « .class » liés à
l’application et ceux des API nécessaires.
Une première Applet Java : Applet HelloWorldApplet (1/2) EX 2.2

 Créer un fichier texte : HelloWorldApplet.java

 Règle de bonne pratique: 1 classe par fichier et 1 fichier par classe

import java.applet.Applet; Importation des classes externes

import java.awt.Graphics;
nécessaires (issues des API Java)

Déclaration de la classe qui hérite de la

public class HelloWorldApplet extends Applet classe prédéfinie « Applet »
{
public void paint(Graphics g) La méthode paint détermine l’affichage dans
la fenêtre de l’Applet
{
g.drawString("Hello the World", 50, 25);
Écrire à l’écran “Hello the World”
}
}
Fermer les accolades

 Compiler le programme : javac HelloWorldApplet.java

 Le compilateur génère le bytecode dans le fichier : HelloWorldApplet.class
 N’oublier pas d’indiquer le path de java : set PATH=%PATH%;C:\Program
Files\Java\jdk1.7.0_15\bin
Une première application EX 2.2

Applet HelloWorldApplet (2/2)

 Les applets s’exécutent dans une page HTML
 Pour intégrer l’applet dans une page HTML, il suffit d’utiliser la balise <APPLET>
 Le paramètre « CODE » de la balise <APPLET> indique le nom de la classe
principale de l’applet
<HTML>
<HEAD>
<TITLE> A Simple Program </TITLE>
</HEAD>
<BODY> Here is the output of my program:
<APPLET CODE="HelloWorldApplet.class" WIDTH=150 HEIGHT=75>
</APPLET>
</BODY>
</HTML>

 Ouvrir la page HTML dans un navigateur, l’applet se lance automatiquement au

sein de la page (Pas nécessaire d’avoir un serveur Web pour exécuter la page)
Langage Java

III. Syntaxe du langage Java

Survol du chapitre
 Structure d’un programme Java
 Conventions d’écriture
 Commentaires dans le code source
 Identificateurs
 Mots-clé
 Types primitifs et types de références
 Les tableaux (« Array »)
 La classe String
 Arithmétique et opérateurs
 Instructions de contrôle
 If, then, else
 For
 While
 Do… While
 Break et Continue
 Packages
Structure Générale d’un Programme Java
 En Java, tout se trouve dans une classe. Il ne peut pas y
avoir de déclaration ou de codes en dehors du corps
d’une classe.
 Une classe ne contient pas directement de code. Elle
contient des déclarations de variables (attributs) et des
fonctions (méthodes).
 Une méthode peut contenir du code et des déclarations
des variables locales
 Tout fichier source doit porter le nom de la classe
publique qu’il contient avec l’extension « .java ».
 Un programme java comporte des classes, parmi
lesquelles on trouve une classe principale comportant la
méthode main()
Structure Générale d’un Programme Java
public class MaClasse {
Déclarations des attributs
Déclarations et définition des Méthodes
}
Exemples :
public class Cercle {
private double r, abX, ordY;
public double surface(){
return r*r*3.14;
}
… autres méthodes
} // fin définition classe
Exemples des Programmes en Java
public class PremProg {
public static void main (String args[])
{
System.out.println ("Salut les apprenants du Java") ;
System.out.println (" Cours : Programmtion orietée objet
avec Java") ;
System.out.println (" Enseignant : Pr. Chiheb CHAIEB") ;
}
}
Exemples des Programmes en Java
public class Exemple {
public static void main (String [] args)
{
int n ;
double x, y ; L’exécution du programme donne :
n=5; n=5
x = 11.5
x = 2*n + 1.5 ; valeur de y : 69.5
System.out.println ("n = " + n) ;
System.out.println ("x = " + x) ;
y = n * x + 12 ;
System.out.println ("valeur de y : " + y) ;
}
}
Conventions d’écriture
Classes
class BankAccount (CamelCase)
class GestionCommerciale
Interfaces
interface Account
Méthodes
deposit()
setSalaire()
getName()
Packages
package gestionClient
Variables
int accountNumber
Constantes
MAXIMUM_SIZE
PI
Commentaires dans le code source

Trois façons d’inclure des commentaires :

 Tout texte entre « // » et la fin de la ligne
// Commentaires sur une seule ligne

 Tout texte entre « /* » et « */ »

/* Commentaires
sur un nombre important voire très important
de lignes */

 Les textes entre « /** » et « */ » sont utilisés pour créer des commentaires que
l’exécutable JAVADOC pourra traiter afin de produire une documentation (cf.
documentation de l’API Java)
/** Commentaires destinés
à la documentation */
Identificateurs

 Un identificateur (identifier) permet de désigner une classe, une

méthode, une variable …
 On ne peut utiliser ce que l’on veut :
 Interdiction d’utiliser les mots-clés
 Commencent par :
 Une lettre : nomClient, x1,
 Un « $ » ! : $v1 ,
 Un « _ » (underscore) : _code1 , _calcul()
 Ne commencent pas par :
 Un chiffre
 Un signe de ponctuation autre que « $ » ou « _ »
Mots-clé

abstract double int strictfp **

boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto * protected transient
const * if public try
continue implements return void
default import short volatile
do instanceof static while

* Indique un mot clé qui est peu utilisé

** A partir de la plate-forme Java2
Types primitifs et types de référence

 Java est un langage fortement typé

 Le type de données précise
 les valeurs que la variable peut contenir
 les opérations que l’on peut réaliser dessus
 Deux types de données:
 Donnée primitive: contient physiquement la valeur
(caractère, nombre, booléen)
 Référence: contient l’adresse mémoire où l’information relative à l’objet,
l’interface, etc. est réellement stockée

Référence: Adresse
Types primitifs et types de référence
Types de données primitifs (1/4)

Primitive Data Types

Integral Floating

byte 8bits -128 to 127 float 32bits 1.4E-45 3.4E38

short 16bits -32768 to 32767 double 64bits 4.9E-324 1.8E308
int 32bits -2^31 to 2^31-1
long 64 bits -2^63 to 2^63-1

Textual Logical

char 16bits 0 to 65535 one bit : true or false

Types primitifs et types de référence
Types de données primitifs (2/4)
 Explication:
 byte : codé sur 8 bits  28 valeurs  (–27) to (27–1) = -128 à 127
 int : codé sur 32 bits  232 valeurs  (–231) to (231–1)

 Déclaration et initialisation :
 int int x=12;
 short short x= 32; (short x=33000; // Hors limite)
 long long x= 200L; // Nombre accolé à un L
 byte byte x=012; // Nombre commençant avec un 0
 double double x=23.2323;
 float float x= 23.233F; // Nombre accolé à un F
 char char c=‘a’; char c=‘\u0061’; char c=(char)97;
 boolean boolean b=true;
Types primitifs et types de référence
Types de données primitifs (3/4)
Déclaration, Initialisation et Assignation des types primitifs

int t; Déclaration d’un entier t (t est l’identificateur)

int u = 3; Déclaration et initialisation d’un entier
t=7; Initialisation de t à la valeur 7
u=t; Assignation (affectation) de la valeur de t à u
m=9; Erreur déclaration préalable nécessaire
char c; Déclaration
c=‘a’; Initialisation
Types primitifs et types de référence
Types de données primitifs (4/4)
Exemple:

int a = 5;
Déclaration et initialisation de 2 entiers: a et b
int b = 8;

a=b; Affectation de la valeur de b à a

Désormais, il existe deux variables en mémoire qui ont la

a=8 b=8 même valeur
Types primitifs et types de référence
Types de référence
 Tous les types hormis les types primitifs (tableau, chaine, objet, etc.)
 « Pointeur implicite » sur un objet

Référence: Adresse N°
Rue
localité
ville
Application (TD / Labo)

Développer le projet cercle composé d'une classe Cercle avec la structure

suivante :
public class Cercle {
double r;
int x,y;
double surface(){
return Math.PI*r*r;
}
double perimetre () { .......}
void move (int dx, dy ) {………//déplace le centre de dx, et dy .}
void affiche () {
………………affiche les infos du cercle }
public void static main(String args[] )
{ ………….}
Les tableaux (“Array”) (1/3)

 Un tableau est utilisé pour stocker une collection de variables de

même type
 On peut créer des tableaux de types primitifs ou de types de
références.
Avant l’usage du tableau, il doit être :
 Déclaré Pour déclarer une variable tableau
 Créé on indique le type des éléments du
tableau et le nom de la variable tableau
 Ses variables initialisées suivi de [ ]
 Les Indices du tableau commencent à 0
int[] nombres; // ou int nombres[] déclaration
nombres = new int[10]; // création
int[] nombres = new int[10]; // déclaration et création
nombres[0] = 28; // initialisation
nombres[1] = 28; ..
String Tnames[] = new String[15]//tableaux de 15 chaines
Tnames[0]= "Ali Baba";
Les tableaux (“Array”) (2/3)
 On peut construire des tableaux à plusieurs dimensions
 Des tableaux à plusieurs dimensions sont en fait des tableaux de tableaux
 chaque élément est initialisé par la valeur nulle du type primitif ou null pour
les tableaux à objets.
 Les indices des tableaux commencent par 0.
 L’attribut length permet d’extraire la longueur d’un tableau : n=T.length

« matrice » est une référence vers

int matrice[][]= new int[3][]; un tableau contenant lui-même 3
tableaux de taille non définie
matrice[0] = new int[4]; Le premier élément de la matrice
matrice[1] = new int[5]; est une référence vers un tableau
matrice[2] = new int[3]; de 4 entiers,…
Le premier élément du premier
matrice[0][0] = 25; tableau de la matrice est un entier
de valeur 25
Les tableaux (“Array”) (3/3)
public class Tab2
{
Mémoire
public static void main (String args[])
{ 0x0258
String tab[ ] ;
tab = new String[4]; 0x0106
tab[0]=new String(" Errazi"); 0x0116
0x0126
tab[1]=new String("Khawarezmi"); 0x0136
tab[2]=new String(" Ibn Rochd");
tab[3]=new String(" Ibn Sina"); Errazi
}
} khawarizmi

Ibn Rochd

Ibn Sina
La classe String
 JAVA offre dans sa librairie (API) java.lang une classe appropriée
aux chaînes de caractères nommée String (non pas un type
primitif), très riche en fonctionnalités.
 Déclaration de deux String: String s1, s2;
 Initialisation :
s1 = "Hello";
s2 = "le monde";
 Déclaration et initialisation : String s3 = "Hello";
 Concaténation : String s4 = s1 + " " + s2;
 boolean chaine1.equals(String chaine2) : comparaison sémantique des
deux chaînes
 String ch1.concat(String ch2) : concaténation de 2 chaînes dans ch1
 int ch.length() : retourne la longueur de la chaîne ch .
La classe String (Exemple)
class TestString {
public static void main(String args[]){
String ch1,ch2;
ch1="programmation";
ch2=ch1;
System.out.println("ch1:" + ch1); //programmation
System.out.println("ch2 :" + ch2); // affiche programmation
ch1+="en java";
System.out.println("ch1:" + ch1); //programmation en java
System.out.println("ch2 :" + ch2); //programmation
String s1 = "bonjour";
String s2 = new String("bonjour");
System.out.println(s1.equals(s2)); //retourne la valeur true
}
}
Arithmétique et opérateurs
Arithmétique élémentaire
 Quelle est la valeur de : 5+3*4+(12/4+1) (21 )
 Règles de précédences sur les opérateurs:

Niveau Symbole Signification

1 () Parenthèse
* Produit
2 / Division
% Modulo
+ Addition ou concaténation
3
- Soustraction
Arithmétique et opérateurs
Opérateurs de comparaison
 Pour comparer deux valeurs:
Opérateur Exemple Renvoie TRUE si
> v1 > v2 v1 plus grand que v2
>= v1 >= v2 Plus grand ou égal
< v1 < v2 Plus petit que
<= v1 <= v2 Plus petit ou égal à
== v1 == v2 égal
!= v1 != v2 différent

 Opérateurs logiques:
Opérateur Usage Renvoie TRUE si
&& expr1 && expr2 expr1 et expr2 sont vraies
& expr1 & expr2 Idem mais évalue toujours les 2 expressions
|| expr1 || expr2 Expr1 ou expr2, ou les deux sont vraies
| expr1 | expr2 idem mais évalue toujours les 2 expressions
! ! expr1 expr1 est fausse
!= expr1 != expr2 si expr1 est différent de expr2
Arithmétique et opérateurs
Opérateurs d’assignation (d’affectation)
 L’opérateur de base est ‘=‘
 Il existe des opérateurs d’assignation qui réalisent à la fois
 une opération arithmétique, logique, ou bit à bit
 et l’assignation proprement dite

Opérateur Exemple Équivalent à

+= expr1 += expr2 expr1 = expr1 + expr2

-= expr1 -= expr2 expr1 = expr1 – expr2

*= expr1 *= expr2 expr1 = expr1 * expr2

/= expr1 /= expr2 expr1 = expr1 / expr2

%= expr1 %= expr2 expr1 = expr1 % expr2

Opérateur de casting
 Cet opérateur est utilisé pour la conversion de types, appelé le
transtypage.
 On peut forcer la conversion d’une expression quelconque
dans un type au choix, à l’aide de l’opérateur cast.
 Si, par exemple, n et p sont des variables de type int,
l’expression :
 (double) ( n/p ) : aura comme valeur celle de l’expression
entière n/p convertie en double.
 Exemple :
 int n=5, p=2 ;
 double d = (double)(n/p) ;
En exécutant ce code la variable d vaut 2.0. en effet
l’expression entière n/p vaut 2, le cast convertit l’entier 2 vert le
double 2.0.
Opérateur de casting

 Le transtypage est nécessaire quand il risque d’y avoir

perte d’information, comme lors de l’affectation d’un
entier long (64 bits) à un entier int (32 bits), ou d’un réel
double vers un réel float.
 Conversion Implicite :
 byte -> short -> int -> long -> float -> double
 char -> int -> long -> -> float -> double
 Les conversions pouvant provoquer une perte de valeurs
ne sont pas autorisées de manière implicite. Elles doivent
être demandées explicitement (exemple : float vers int).
float f=12.5f;
int i = f // provoque une erreur , faire un casting
Opérateur de casting

 Exemple ;
int i, j ;
short s = 2 ;
float f = 1.5f ;
i = (int) f ; /* conversion explicite obligatoire avec perte
(on s’intéresse qu’à la partie entière du réel f*/
i=s; // conversion implicite
f = i/2 ; /* conversion implicite par opération arithmétique*/
Opérateur de casting : Application
public class RegConv{
public static void main (String args[]){
float x ; double y ; int n ; short p ;
y = 1e-300 ;
x = (float) y ; System.out.println ("double-float : " + y + " --> " + x) ;
y = -1e-300 ;
x = (float) y ; System.out.println ("double-float : " + y + " --> " + x) ;
y = 1e+300 ;
x = (float) y ; System.out.println ("double-float : " + y + " --> " + x) ;
x = 123456789.f ;
n = (int) x ; System.out.println ("float-int : " + x + " --> " + n) ;
p = (short) x ; System.out.println ("float-short : " + x + " --> " + p) ;
x = 1.23456789e15f ;
n = (int) x ; System.out.println ("float-int : " + x + " --> " + n) ;
p = (short) x ; System.out.println ("float-short : " + x + " --> " + p) ;
x = 32771.f ;
n = (int) x ; System.out.println ("float-int : " + x + " --> " + n) ;
p = (short) x ; System.out.println ("float-short : " + x + " --> " + p) ;
Opérateur de casting : Solution

n double-float
= (int) x ; System.out.println
: 1.0E-300 --> ("float-int
0.0 : " + x + " --> " + n) ;
pdouble-float
= (short) x ; System.out.println
: -1.0E-300 --> ("float-short
-0.0 : " + x + " --> " + p)
;
double-float : 1.0E300 --> Infinity
xfloat-int
= 1.23456789e15f ;
: 1.23456792E8 --> 123456792
nfloat-short
= (int) x ; System.out.println
: 1.23456792E8 ("float-int : " + x + " --> " + n) ;
--> -13032
pfloat-int
= (short): x1.23456795E15 -->
; System.out.println 2147483647
("float-short : " + x + " --> " + p)
;
float-short : 1.23456795E15 --> -1
xfloat-int
= 32771.f : 32771.0
; --> 32771
nfloat-short : 32771.0 --> -32765
= (int) x ; System.out.println ("float-int : " + x + " --> " + n) ;
p = (short) x ; System.out.println ("float-short : " + x + " --> " + p)
;
}
Opérateur Conditionnel

 En java l’opérateur conditionnel permet de remplacer une

structure conditionnelle simple du genre
If condition
variable = expression1 ;
else
variable =expression 2 ;

 Exemples :
 max = a>b ? a:b;
 String response = v1!=v2 ? " correcte " : " incorrecte "
Les Structures de Contrôles
 Java est riche en structures de contrôles :
Les Structures conditionnelles
Les Structures Répétitives
 Les branchements
Instructions et structures de contrôle
Déclarations, instructions, blocs
 Une instruction
 Réalise un traitement particulier:
 Renvoie éventuellement le résultat du calcul
 Est comparable à une phrase du langage naturel
 Constitue l’unité d’exécution
 Est toujours suivie de « ; »
 Instruction d’affectation (d’assignation), instruction de déclaration …
 Un bloc
 Est une suite d’instructions entre accolades « { » et « } »
 Délimite la portée des variables qui y sont déclarées
 Une déclaration
 Constitue la signature d’un élément (classe, variable ou méthode)
 Annonce la définition de cet élément
 Est (normalement) toujours suivie d’un bloc d’instructions
Instructions et structures de contrôle
Structures de contrôle
 Les structures de contrôles permettent d’arrêter l’exécution linéaire
des instructions (de bas en haut et de gauche à droite)
 Elles permettent d’exécuter conditionnellement une instruction, ou de
réaliser une boucle

Type d’instruction Mots clés utilisés

Décision if() else – switch() case

Boucle for( ; ; ) – while () – do while()

Traitement d’exceptions try catch finally – throw

Branchement label : -- break – continue -- return

Instructions et structures de contrôle
Structures de contrôle
IF – THEN – ELSE

if (expression)
{
//instructions
}

if (expression)
{
//instructions
}
else
{
//instructions dans les autres cas
}
Instructions et structures de contrôle
Structures de contrôle
IF – imbriqués
 Dans le cas de plusieurs if imbriqués on peut se trouver
dans une situation d’ambiguïté sur le else concerne quel
if comme le montre l’exemple suivant :
if (a<=b) if (b<=c) System.out.println ("ordonne") ;
else System.out.println ("non ordonne") ;
 Dans ce cas il faut suivre la règle suivante :
 Un else se rapporte toujours au dernier if rencontré
auquel un else n’a pas encore été attribué.
Instructions et structures de contrôle
Structures de contrôle
SWITCH – CASE

switch (number)
{
case 1 : instructions; break;
case 2 : instructions; break;
default : instructions;
}
Structure Conditionnelle : Application
Voici un exemple d’utilisation des if imbriqués. Il s’agit d’un
programme de facturation avec remise. Il lit en donnée un simple prix
hors taxes et calcule le prix TTC correspondant (avec un taux de TVA
constant de 18,6%). Il établit ensuite une remise dont le taux dépend
de la valeur ainsi obtenue, à savoir :
• 0 % pour un montant inférieur à 1 000 d,
• 1 % pour un montant supérieur ou égal à 1000 d et inférieur à 2000 d,
• 3 % pour un montant supérieur ou égal à 2000 d et inférieur à 5000 d,
• 5 % pour un montant supérieur ou égal à 5 000 d.
 import java.util.Scanner;
 / * cette classe contient la méthode nextDouble() pour la saisie en
mode console d’un réel. nextInt() pour la lecture d’un entier */
Structure Conditionnelle : Application
donnez le prix hors taxes
prix ttc 4864.0
remise 145.92
net a payer 4718.08
donnez le prix hors taxes : 859.45
prix ttc 1045.0912
remise 10.450912
net a payer 1034.640288
 Structure Conditionnelle : Application
public class Tva {
public static void main (String[] args)
{ double taux, tva = 21.6 ;
double ht, ttc, net, tauxr, remise ;
System.out.print ("donnez le prix hors taxes : ") ;
sc = new Scanner(System.in);
ht = sc.nextDouble()
ttc = ht * ( 1. + taux_tva/100.) ;
if ( ttc < 1000.) tauxr = 0 ;
else if ( ttc < 2000 ) tauxr = 1. ;
else if ( ttc < 5000 ) tauxr = 3. ;
else tauxr = 5. ;
remise = ttc * tauxr / 100. ;
net = ttc - remise ;
System.out.println ("prix ttc : " + ttc) ;
System.out.println ("remise : " + remise) ;
System.out.println ("net a payer :" + net) ;
} }
Instructions et structures de contrôle
Structures de contrôle
FOR
for (initialisation; condition; mise à jour de valeurs){
// instructions
}
 Initialisation: à exécuter lorsque le programme rentre pour la première
fois dans la boucle
 Condition : à remplir pour recommencer le bloc d’instructions
 Mise à jour: instruction exécutée chaque fois que la boucle est terminée

Exemples:
for (int i=0 ; i<10 ; i++) {
System.out.println("The value of i is : " + i);
}
Instructions et structures de contrôle
Structures de contrôle
WHILE – DO WHILE
while (test logique) {
//instructions
}

Si le code de la boucle doit être exécuté la première fois de toute façon:

do {
// code to perform
} while (logical_test)

Boucle infinie:
while (true) {
//instructions
}
Structures de contrôle : Que Fournit ce programme ?
public class Boucle {
public static void main(String[] args) {
int n, p ;
n=0;
while (n<=5) n++ ; System.out.println ("A : n = " + n) ;
n=p=0;
while (n<=8) n += p++ ;
System.out.println ("B : n = " + n) ;
n=p=0;
while (n<=8) n += ++p ;
System.out.println ("C : n = " + n) ;
n=p=0;
while (p<=5) n += p++ ;
System.out.println ("D : n = " + n) ;
n=p=0;
while (p<=5) n+= ++p ;
System.out.println ("D : n = " + n) ; } }
Structures de contrôle : Que Fournit ce programme ?
Le résultat de l’exécution est :
A:n=6
B : n = 10
C : n = 10
D : n = 15
D : n = 21
Structures de contrôle : Application
 Voici maintenant un exemple de programme qui calcule
les racines carrées de 5 valeurs fournies en données. Les
lectures au clavier sont réalisées en utilisant la méthode
sc.nextDouble() de la classe Scanner.
import java.util.Scanner;
public class Racines {
public static void main (String[] args){
final int NFOIS = 5 ;
int i ;
double x, racx ;
Scanner sc ;
x =sc.nextDouble () ;
For (i=0;i<NBFOIS;i++)
if (x < 0.0) System.out.println (x + " ne possede pas de racine carree") ;
else { racx = Math.sqrt(x) …..affichage
Instructions et structures de contrôle
Structures de contrôle
 BREAK / CONTINUE

 BREAK: achève immédiatement la boucle

 CONTINUE: ignore le reste des instructions et recommence au début
de la boucle

for (int i=0; i<10 ;i++){

if (i==5) continue; // Si i=5, on recommence au début
if (i==7) break; /* Si i=7, on sort de la boucle et
les instructions suivantes sont
exécutées */
System.out.println("The value of i is : " + i);
}
Instructions et structures de contrôle
Structures de contrôle
BREAK [LABEL]
CONTINUE [LABEL]

outer:
for (int i=0 ; i<10 ; i++) {
for(int j=20;j>4;j--){
if (i==5) continue; // if i=5, you jump to the beginning of the loop

if (i==7) break outer; // if i=7, you jump outside the loop and continue
System.out.println(«The value of i,j is :»+i+ «,»+j);
}
Exercices
 Five D Seven D
EX 3.1
 Ecrire un programme qui compte de 1 à 100
 Affiche ces nombres à l’écran
 Remplace les multiples de 5 par « Five D »
 Remplace les multiples de 7 par « Seven D »
 Calcul de factorielle
 Ecrire un programme qui calcule la factorielle d’un nombre
EX 3.2
 Dessiner une Pyramide
*
**
***
 Décoder une chaîne de caractère
Compiler et exécuter les programmes créé
Exercices
 Moyenne des Etudiants EX 3.3

 Vous recevez une à une les notes de vos N étudiants

(/20). N est donné par l’utilisateur au début.
 Notez pour chaque étudiant s’il réussit ou échoue et, à la
fin, indiquez le nombre de ceux qui échouent, le nombre
de ceux qui réussissent, la moyenne totale et les deux
moyennes de ceux qui échouent et réussissent

 Exécuter les programmes et observer le résultat

Les packages et les importations
 Les packages offrent une organisation structurée des classes, Ils
permettent de regrouper un certain nombre de classes ayant,
généralement, des rôles proches
 La répartition des packages correspond à l’organisation physique,
ils sont considérés comme une bibliothèque de classes
 Les packages permettent la coexistence de classes de même nom
 Les mots-clé associés sont « package » et « import »
 Les packages sont organisés hiérarchiquement à la manière des
répertoires : on peut définir des sous-packages, des sous-sous-
packages, …
 On peut créer des packages, ajouter des classes dans un package
existant ou utiliser des définitions de classes à partir de leurs
packages (voir la fin du présent chapitre)
Les packages et les importations
 Exemple:
 package technofutur.bank
 Class BankCompte
 Class CompteEpargne
 Class CompteCourant
 package technofutur.mediatheque
 import technofutur.bank.CompteCourant package bank

class BankCompte

Class CompteEpargne Class CompteCourant

package mediatheque

Class CompteCourant
Comprendre les Packages
 Package design Example
 As program manager you need two sets of classes with unique
functionality that will be used by the same end product. You ask
Developer A to build the first set and Developer B to build the second.
 Developer A is to create several geometry-based classes including a
point class, a polygon class, and a plane class.
 Developer B is to build classes that will be included for simulation
purposes, including objects such as hot air balloons, helicopters, and
airplanes.

 Come delivery time, they both give you a class named Plane.java .

you have a problem because both of these source files cannot

coexist in the same directory since they have the same name.

The solution is packaging.*

* Source : Oracle Certified Associate (OCA) Java S7
102
Comprendre les Packages
 You need to know exactly how to place a source file into a
package, use the package statement at the beginning of
that file. You may use zero or one package statements per
source file.
 To import classes from other packages into your source
file, use the import statement.
 The java.lang package that houses the core language
classes is imported by default.

Example :
// Package statement
package oca.coursJava; /* Imports all classes from the
java.io package */
/* Imports class ArrayList from import java.io.*;
the java.util package */ public class MainClass {
import java.util.ArrayList; ………….
}

Oracle Certified Associate (OCA) Java SE 7 103

Comprendre les Packages
 The package statement includes the package keyword, followed
by the package path delimited with periods.
 Package statements have the following attributes:
– Package statements are optional.
– Package statements are limited to one per source file.
– Standard coding convention for package statements reverses the
domain name of the organization or group creating the package. The
domain name ocaexam.com may use the following package name for
an utilities package: com.ocaexam.utilities.
– Package names equate to directory structures. The package name
com.ocaexam.utils would equate to the directory com/ocaexam/utils.
– The package names beginning with java.* and javax.* are reserved for
use by JavaSoft.
– Package names should be lowercase. Individual words within the
package name should be separated by underscores.

Source : Oracle Certified Associate (OCA) Java SE 104

Basic Java Packages

Source : Oracle Certified Associate (OCA) Java SE 105