INITIATION A LA
PROGRAMMATION JAVA
Mme. KASSE L2 UADB
1
PLAN DU COURS
Historique
Principes de la POO
Exemple de programme
Les instructions de contrôle
La POO
Les tableaux
Les chaines de caractères
Héritage
CHAPITRE I
INITIATION ET OPERATEURS DE BASES
EN JAVA
/Web 3
HISTORIQUE
Initialement, projet de la société Sun (rachetée depuis par
Oracle) pour l'électronique grand public (1991)
• Transformé en langage pour le Web, sous le nom de « Java »,
grâce à sa portabilité (1994/95)
• Lancement officiel en mai 1995
• Après l'engouement pour les applets, Java est progressivement
reconnu comme un langage à part entière
• Langage de programmation sans doute le plus utilisé
aujourd’hui :
– plusieurs millions de développeurs Java
– nombreux outils de développement
4
INTERETS DE JAVA
logiciels portables
programmes fiables (rigueur du langage => peu de
bugs)
développement rapide
pages Web interactives (via les « applets »)
logiciels (ou briques logicielles) téléchargeables,
éventuellement automatiquement.
gestion de la sécurité (par défaut, accès restreint aux
ressources locales pour les applets)
5
CARACTERISTIQUES DE JAVA
➢Un langage orienté-objet :
◦ portable
◦ compilé puis interprété (bytecode+JVM)
◦ robuste (typage fort, garbage collector)
➢Une énorme librairie de classes standards
6
JRE-JDK-ECLIPSE
Plusieurs implantations disponibles du langage Java, dont celles d’origine
ORACLE/SUN (créateur du langage)
• « JRE » (Java Runtime Environment)
• « Java SE » (Standard Edition) « JDK » (Java Development Kit)
(gratuit) contient :
◦ compilateur (javac)
◦ interpréteur / machine virtuelle (java)
◦ toute la librairie de classes standards
◦ divers outils : génération doc (javadoc), visualisation d'applet
• « Eclipse » (gratuite)
• Les sources de Java sont disponibles
7
PRINCIPES de la POO
Unité logique : l’objet
◦ Objet est défini par Voiture
◦ un état ➢Couleur = Bleue
◦ un comportement ➢Vitesse= 100
◦ une identité
État : représenté par des attributs (variables) qui
stockent des valeurs
Comportement : défini par des méthodes (procédures)
qui modifient des états
Identité : permet de distinguer un objet d’un autre
objet
8
PRINCIPES de la POO
Les objets communiquent entre eux par des messages
Un objet peut recevoir un message qui déclenche une
méthode qui modifie son état et / ou une méthode qui
envoie un message à un autre objet
Ma voiture Démarre Le moteur
9
POO: Notion de Classe
Les objets qui ont les mêmes états et les mêmes
comportements sont regroupés : c’est une
classe.
Les classes servent de « moules » pour la
création des objets.
Un objet est une instance d’une classe
Un programme OO est constitué de classes qui
permettent de créer des objets qui s’envoient
des messages.
10
POO: Notion de Classe
Nom de Classe Voiture
❖puissance: entier
Attributs ❖estDemarrée: booléen
❖Vitesse: réel
+deQuellePuissance( )
+démarre( )
Méthodes
+accélère( réel)
11
Principales étapes d’un développement
12
Premier exemple du programme JAVA
public class PremierProg
{
public static void main (String[] argv)
{
[Link]("Ola, mon
Premier Programme");
}
}
public class PremierProg
◦ Nom de la classe
13
Premier exemple du programme JAVA
public static void main
◦ La fonction principale équivalent à la
fonction main du C/C++
String[] argv
◦ Permet de récupérer des arguments transmis
au programme au moment de son lancement
[Link]("Ola, mon premier
programme")
◦ Méthode d'affichage dans la fenêtre console
14
MISE EN OEUVRE
Pas de séparation entre définition et codage des
opérations.
◦ Un seul fichier « [Link] »
Nom de la classe = Nom du fichier java
Compilation
◦ javac [Link]
◦ Génération d’un fichier Byte-Code «
[Link] »
15
MISE EN OEUVRE
Exécution Ne pas mettre l’extension
« .class » lors de l’exécution
◦ java NomDeClasse
◦ Choisir la classe principale à exécuter
16
VARIABLES ET TYPES
notion de variable
◦ nom (identificateur) + type+zone mémoire
en Java, deux grandes catégories de types
types « primitifs » (entiers, flottants, …)
références à des types « composites » :
◦ Tableaux
◦ énumérations
◦ objets
◦ interfaces
17
TYPES PRIMITIFS
boolean
char: 16-bit
byte: entier 8-bit
short: entier 16-bit
int: entier 32-bit
long: entier (signé) 64-bit
float: flottant32-bit
double: flottant 64-bit
18
BOOLEENS : boolean
2 valeurs : true ou false
type retourné par les opérateurs de
comparaison
type attendu dans tous les tests
19
ENTIERS
valeurs min/max :
byte = [-128; +127]
short = [-32768 ; +32767]
int = [-[Link] ; +[Link]]
long = [-9,223... 1018 ; +9,223... 1018]
• conversion automatique seulement vers les
types entiers plus grands.
Exemple: (int->long) et vers les types flottants
20
CARACTERES char
16-bit 65536 valeurs : quasiment tous les caractères de
toutes les écritures !
ne sont affichables que si le système possède les polices
de caractères adéquates !
littéraux entre simples quotes : 'a' 'Z‘
caractères spéciaux : '\n' '\t' '\b' '\\‘
convertible automatiquement en int ou long (et
manuellement en byte ou short)
inversement, (char)val est le caractère dont le code
Unicode est l'entier val
21
FLOTTANTS
float x = 2.5; // Erreur
double y = 2.5; // OK
valeurs f ou F pour spécifier un float :
float x = 2.5f;
conversion automatique:
◦ seulement float -> double.
la conversion « manuelle » en entier tronque la partie
décimale
float x = -2.8f;
int i = (int) x; // => i==-2
22
CONSTANTES
variable dont la valeur ne peut plus être changée une fois fixée
se déclare avec le mot-clé final :
final double PI = 3.14159;
ce qui interdit d’écrire ensuite
PI = 3.14; // ERREUR
23
Déclaration et portée des variables
déclaration préalable obligatoire
◦ identificateurs :
◦ caractères Unicode
◦ commencent par une lettre, _ ou $
◦ ensuite : lettre, chiffre, _ ou $
exemples de déclaration:
◦ int i;
◦ float x, y, z;
◦ char c = 'A', d;
◦ boolean flag = true;
initialisation obligatoire avant usage :
◦ int i, j;
j = i; // ERREUR : i non initialisé
« portée » des variables (= zone de validité de la déclaration): jusqu'à
la fin du bloc englobant (voir plus loin)ion préalable obligatoire
24
COMMENTAIRES
Sur une ligne
//Commentaire -> fin de la ligne
int x; // Ligne partielle
Sur plusieurs lignes
/* Commentaire qui s'étend sur plusieurs
lignes */
De documentation
/** Commentaire pour javadoc */
25
OPERATEURS
affectation : =
arithmétiques : +, -, *, /, %
comparaisons : <, <=, >, >=, ==, !=
booléens : &&, ||, &, |
pré/post-incrémentation : ++
pré/post-décrémentation : --
création tableau ou objet (allocation mémoire) :
new
26
Operateurs arithmétiques
Operateur Fonction usage
+ Addition expr1+expr2
- Soustraction expr1-expr2
- Changement de signe -expr
* Multiplication expr1*expr2
/ Division expr1/expr2
% Modulo expr1%expr2
27
Operateurs de comparaison
Operateur Fonction
== Égalité
!= Inégalité
< Inferieur strict
<= Inferieur ou égal
> Superieur strict
>= Inferieur ou égal
28
Operateurs booléens
Opérateur Fonction usage
&& Et(version optimisée) expr1&&expr2
|| Ou(version optimisée) expr1||expr2
& Et(version non optimisée) expr1&expr2
| Ou(version non optimisée) expr1|expr2
29
Operateurs d’affectations
Exemple :
◦ int i, j;
◦ i = 0;
◦ j = i;
évaluation de droite à gauche :
◦ i = j = 2; // i et j valent 2
• affectation combinée avec opération arithmétique
+=, -= ,*=, &=
i += 3; équivaut à i = i+3;
30
Opérateurs d’incrémentation et de décrémentation
Opérateur Fonction
i++ Post-incrémentation
++i Pré-incrémentation
i-- Post-décrémentation
--i Pré-décrémentation
Opérateurs servant essentiellement à compacter les
écritures :
n = i++; équivaut à n = i; i = i + 1;
n = ++i; équivaut à i = i + 1; n = i;
31
Priorité des operateurs
[] (params) expr++ expr--
++expr --expr
New (type)expr
* / %
< > <= >=
== !=
& | && ||
== *= += /=
%=
32
CHAPITRE II
INSTRUCTIONS DE CONTROLE
(Tests, Boucles)
33
Blocs d’intructions
chaque instruction se termine par un ';'
int i;
i = 4*3;
on peut grouper plusieurs instructions en un bloc (délimité par des
accolades),
exemple :
int a=1, b=2;
{ // début de bloc
int x=a;
a = b;
b = x;
} // fin de bloc
x = 3; // ERREUR: x n’est pas connu ici
Remarque : la portée d'une variable va de sa déclaration jusqu'à la fin du
bloc où elle est déclarée.
34
Instructions de contrôles
Permettent de modifier l’ordre normal (séquentiel)
d’exécution des instructions
• exécution conditionnelle :
◦ – if … else
• cas multiples :
◦ – switch
• boucles :
◦ – for
◦ – while
◦ – do … while
35
Instructions (if……else)
if (boolExpr) instruction;
if (boolExpr) {
◦ instruction(s); // exécuté si VRAI
}
else {
◦ instruction(s); // exécuté si FAUX
}
if (boolExpr) {
◦ instruction(s); // exécuté si VRAI
}
else if (boolExpr2) {
◦ instruction(s); // ...
} else {
◦ instruction(s); // ...
}
36
Exemple (if……else)
public class Exemple_If_Else
{
int final MIN = 100;
int solde ;
public static void main(String args [ ])
{
if ( solde < =MIN)
[Link]("solde insuffisant" ) ;
else
[Link]("solde suffisant" ) ;
}
}
37
Instructions (Switch…case)
switch (expr) {
case cst1:
◦ instruction(s)
break;
case cst2:
◦ instruction(s)
case cst3:
◦ instruction(s)
break;
default:
◦ instruction(s) si aucun des cas prévus
break;
}
38
Exemple (Switch…case)
public class Exemple_Switch{
int final MIN = 100;
int final Max = 1000;
int choix , solde;
public static void main(String args [ ])
{ switch(choix)
{ case 1: solde = MIN;
[Link]("solde insuffisant" ) ;
break;
case 2: solde = MAX ;
[Link]("solde suffisant" ) ;
break;
default : break
} }}
39
Boucles de répétitions(While)
while (boolExpr) {
// corps de la boucle :
◦ instruction(s);
}
ou alors
// cas avec une et une seule instruction
while (boolExpr)
◦ instruction;
40
Exemple (While)
public class Exemple_While{
public static void main(String args [ ])
{ while ( n < = 0)
{ [Link]("saisir un entier strictement positif " ) ;
Scanner sc=new Scanner([Link]);
int n=[Link]();
if ( n < 0) [Link]("la saisie est invalidée:
recommencez" ) ;
}
}
}
41
Boucles de répétitions(do...while)
do {
// corps de la boucle exécuté au moins une fois :
◦ instruction(s);
} while (boolExpr);
ou alors
// cas avec une et une seule instruction
do instruction;
while (boolExpr);
42
Exemple(do...while)
public class Exemple_Do_While{
public static void main(String args [ ])
{ do
{ [Link]("saisir un entier strictement positif " );
Scanner sc=new Scanner([Link]);
int n=[Link]();
if ( n < 0) [Link]("la saisie est invalidée:
recommencez" ) ;
}
while ( (n < =0 );
}
}
43
Boucles de répétitions(for)
for (initialisations ; boolExpr ; incr) {
instruction(s); // corps de la boucle
}
équivalent à :
initialisations;
while (boolExpr) {
instruction(s);
incréments;
}
44
Exemple(for)
public class Exemple_For{
public static void main(String args [ ])
{ int tab [ ] = new int [ 100] ; // tableau d’entiers de taille
100
for( int i = 0 ; i < 100 ; i ++ )
{
tab [ i ] = i + 1;
}
}
}
45
Branchement inconditionnel (break)
Elle sert à interrompre le déroulement de la boucle, en passant à l’instruction
suivant la boucle.
public class Exemple_Break{
public static void main(String args [ ])
{ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10
for( int i = 0 ; i < 10 ; i ++ )
{ if ( i = = 5 ) break ;// initialiser seulement les 5 premiers elts du
tableau
tab [ i ] = i + 1;
} // le break nous branche à la sortie du for pour continuer
for( int i = 0 ; i < 10 ; i ++ )
[Link](" éléments du tableau:" +" "+tab [ i] );
}
}
46
Branchement inconditionnel
(continue)
L’instruction continue permet de passer prématurément au tour de
boucle suivant.
public class Exemple_Continue{
public static void main(String args [ ])
{ int tab [ ] = new int [ 10] ; // tableau d’entiers de taille 10
for( int i = 0 ; i < 10 ; i ++ ) // ici
{ if ( i = = 5 ) continue ;// on poursuit la boucle for
tab [ i ] = i + 1;
}
for( int i = 0 ; i < 10 ; i ++ )
[Link](" éléments du tableau:" +" "+tab [ i] );
}
}
47
