Vous êtes sur la page 1sur 64

Programmation Orientée Objet

Cours 3 Année LMD (2013-2014)


Hammache Arezki
LMD3_POO@yahoo.fr
Sommaire
• Introduction
• Concepts de la POO
– Objet , classe, encapsulation, héritage, etc.
• Langage Java
– Introduction
– Syntaxe de Java
– Objets et Classes
– Relations entre classe : Héritage et polymorphisme
– Interfaces graphiques : AWT
– Les indispensables :Collections, exceptions.
– Les entrées sorties
– Les threads
– Les applets
Introduction
Quelques notions
• Algorithme: méthode pour résoudre un problème. Pour un problème donné, il
peut y avoir plusieurs algorithmes . . . ou aucun !

• Programme: Le programme est le codage (langage de programmation) lisible


par l’ordinateur de cet algorithme.

• Le langage de programmation : est l'intermédiaire entre l'humain et la


machine, il permet d'écrire dans un langage proche de la machine mais
intelligible par l'humain les opérations que l'ordinateur doit effectuer.
Quelques uns des plus connus: C, C++, Pascal, Java, python

• Langage machine : est une succession de 0 et de 1

• Compilateur (interpréteur) : est un programme qui permet de transformer un


programme (fichier source) écrit dans langage de programmation en un
programme en langage machine (fichier exécutable).
D’un problème à la solution informatique
Homme Machine

Fichier source

Programme
Problème Algorithme
… (Langage)
Résolution équation ? Calculer delta …
delta=a*a-4*b*c
Si delta >0 alors
if (delta>0)
…. {

Compilateur
Ou
Interpréteur

Données Exécutable
5 4 1
Code machine

00011001
Résultats 10011001
??? …

Introduction
5
Niveau de langage de programmation
Langage Humain Haut niveau : proche de
l’homme, vocabulaire et
syntaxe plus riches

JAVA, C++,

C , Pascal (fonctions) Bas niveau : proche de la


machine, instructions
élémentaires
Assembleur (mnémonique : add)

Langage Machine (01111001..)


Les familles de langages de programmation

On distingue habituellement deux grandes familles


de langages de programmation:
1. Les langages orientés procédures (langages
fonctionnels ou procéduraux) (ex :pascal, le C).
Algorithmes(fonctions , procédures) +
Données = Programme
2. Les langages orientés objets (=langages objets) :
(ex : C++, JAVA) Méthodes + Données = Objet
(Classe)
Langages procéduraux et fonctionnels

Un programme est composé de plusieurs Données


procédures (ou fonctions) :
 qui effectuent un traitement sur des Traitement 1
données (procédure) Traitement 2
 qui retournent une valeur après leur
Traitement 3
invocation (fonction)

Certains langages ne distinguent pas Nom, prénom, nom module, num groupe,
Num Salle, ….
procédures et fonctions.
Inscription
Exemples de langages procéduraux ou
Affectation
fonctionnels : Fortran, Lisp, C, …
Deliberation
Langages Orientés-Objet
D
Un programme est composé de plusieurs T
objets qui contiennent : D
D
 des données "internes" T
T
 des traitements manipulant ces
D D
données internes ou d'autres
T T
données

Les données d'un objet sont appelés ses Nom, prénom

attributs et ses traitements sont ses ajouter

méthodes (ou opérations). Num_salle


Num_mod

affecter
affecter
Exemples de langages orientés-objet :
SmallTalk, C++, Java, … Num_groupe

ajouter
Avantages de la Programmation Orienté Objet

 Facilite la réutilisation de code.


 Une meilleure sécurité (encapsulation)
 Facilite l’évolution du code
 Améliore la conception et la maintenance des
grands systèmes
 Permet la Programmation par « composants ».
Conception d’un logiciel à la manière de la
fabrication d’une voiture
Sommaire
• Introduction
• Concepts de la POO
– Objet , classe, encapsulation, héritage, etc.
• Langage Java
– Introduction
– Syntaxe de Java
– Objets et Classes
– Relations entre classe : Héritage et polymorphisme
– Interfaces graphiques : AWT
– Les indispensables :Collections, exceptions.
– Les entrées sorties
– Les threads
– Les applets
Objet
 Approche procédurale :
 "Que doit faire mon programme ?"
 Approche orientée-objet :
 "De quoi doit être composé mon programme ?"
 Cette composition est conséquence d'un choix de modélisation fait
pendant la conception
 Un objet est une abstraction d’une entité du monde réel
Exemple: Gestion d'une bibliothèque

Germinal
E. Zola
Liberté A.Lydia
B.Tanina
Directrice
Lectrice

A.Nassim
Le seigneur des anneaux
D.kamel Lecteur
J.R.R.Tolkien
Bibliothécaire
Classe
Des objets similaires peuvent être informatiquement décrits par une même
abstraction : une classe
 même structure de données et méthodes de traitement
 valeurs différentes pour chaque objet

Classe Lecteur
Classe Livre Classe Employé -nom, prénom
-titre, auteur -nom, prénom, statut
Classe Journal
-titre

Germinal
E. Zola
Liberté A.Lydia
B.Tanina
Directrice
Lectrice

Le seigneur des anneaux A.Nassim


D.kamel Lecteur
J.R.R.Tolkien
Bibliothécaire
Encapsulation
L'encapsulation est la pratique consistant à regrouper
des attributs au sein d'une même classe.
 Pour améliorer la lisibilité des
programmes, les attributs
encapsulés sont souvent privés
(inaccessibles aux autres
classes).
 Les données et méthodes
accessibles sont dites publiques.
Héritage (La généralisation / spécialisation)

 L’héritage autorise une classe d’objet de bénéficier de la structure des


données et du comportement d’une classe « mère » tout en lui permettant
de les affiner et ce, afin de prendre en compte les spécificités de la classe
« fille » sans avoir cependant à redéfinir ce que les deux classes ont en
commun.

 Généralisation = recherche des similitudes


Identifier les objets du monde réel connus par le système
Regrouper les objets en classes
Généraliser les classes en super classes

 Règle d’or : en cas de doute sur la pertinence d’une classe, il est préférable de
ne pas la définir

 La généralisation est caractérisé par l’expression : « est un type de »


Un exemple d’héritage
Exemple : gestion bibliothèque
Classes
Classe Personne
Classe Ouvrage mères
-Nom, prénom
-titre

Classe Employé Classe Lecteur


Classe Livre Classe Journal -statut -type
-auteur -type

Germinal
Liberté A.Lydia
E. Zola B.Tanina
Directrice
Lectrice

Le seigneur des anneaux A.Nassim


D.kamel Lecteur
J.R.R.Tolkien
Bibliothécaire
Un autre exemple d’héritage
Classes mères
Moyen de transport

<<hérite>>

Classes
filles
Tracteur Train Voiture

Monde réel
(objets)
Polymorphisme
 Offre la possibilité d’associer à un comportement,
une implémentation différente en fonction de l’objet
auquel on se réfère.

Personne
dessiner()
dessiner()
Sanctionner() Sanctionner()

Employé Lecteur
Sommaire
• Introduction
• Concepts de la POO
– Objet , classe, encapsulation, héritage, etc.
• Langage Java
– Introduction
– Syntaxe de Java
– Objets et Classes
– Relations entre classe : Héritage et polymorphisme
– Interfaces graphiques : AWT
– Les indispensables :Collections, exceptions.
– Les entrées sorties
– Les threads
– Les applets
Origine du langage
 Développé par SunSoft (SUN) pour réaliser le développement
de systèmes embarqués
 Projet « Oak »
 Évolution gérée par JavaSOFT (SunSoft)
 Repris par Oracle
 Quelques liens
 http://www.oracle.com/technetwork/java/index.html
 http://www.developer.com/
 http://www.javaworld.com/
 http://tips.iworld.com/
 Livres
 La programmation objet en Java : Michel Divay, Dunod , 2006. (PR
42)
Java est simple

 Simplicité relative par rapport au C++

 Certains concepts du C++ à l’origine de nombreux bugs ont


été supprimés
 Pointeurs
 Surcharge des opérateurs
 …

 Des études comparatives de développements


montrent une diminution du coût de développement de 30 à
35 %.
Java est un langage objet
 Java reprend des caractéristiques de différents langages à
objets
 La syntaxe du C++
 La gestion dynamique de la mémoire SmallTalk

 Toute ligne de code JAVA se trouve obligatoirement dans une


méthode à l’intérieur d’une classe

 Java implémente les concept de l’orienté objet


 Encapsulation
 Héritage
 Polymorphisme
Java est robuste et sûr
 Le compilateur Java est très strict

 Contrôle de typage « fort »

 Le compilateur vérifie que les erreurs sont traitées par le développeur


– Si une erreur retournée par une méthode n’est pas traitée, le programme ne
compilera pas

 La gestion de la mémoire n’est pas à la charge du développeur


 Garbage Collector (« ramasse-miettes)
 Pas de pointeurs

 Un débordement d’index dans un tableau provoque une erreur


 La mémoire n’est pas écrasée
JAVA est portable
 Un code source Java est compilé pour générer un code assembleur
virtuel : le byte code

 Ce code est conçu pour :


 Etre rapidement interprété
 Etre optimisable au moment de son exécution
 Etre facilement traduit en instructions assembleur lors de son exécution
 Etre compact
 en moyenne, une instruction byte code = 1,8 octet
 Etre vérifiable

 Le byte code est exécuté par un logiciel : la Machine virtuelle

 La machine virtuelle est dépendante de la plate-forme: pour chaque plate


forme (Windows, linux, etc) il existe une machine virtuelle.
Comment il fonctionne …!
Exemple
Byte code
0: iconst_2
1: istore_1
2: iload_1
Programme source java 3: sipush 1000
6: if_icmpge 44
outer:
9: iconst_2 10: istore_2 11: iload_2
for (int i = 2; i < 1000; i++) {
12: iload_1
for (int j = 2; j < i; j++) {
13: if_icmpge 31
if (i % j == 0) continue outer;
16: iload_1
}
17: iload_2 18: irem
System.out.println (i);
19: ifne 25
}
22: goto 38
25: iinc 2, 1
28: goto 11
Compilation 31: getstatic #84;
(javac) 34: iload_1
35: invokevirtual #85;
38: iinc 1, 1
41: goto 2
44: return
Le JDK / JRE
 Le JDK = Java Development Kit
 Il contient :
 Des exécutables : machine virtuelle, compilateur…
 Un ensemble de classes de base regroupées en packages
 Interface utilisateur, conteneurs, gestion des threads, réseau…
 Des bibliothèques permettant de coupler du Java et du C

 Le JRE= Java Runtime Environment


contient :
 la machine virtuelle
Les environnements de développement
 Ils offrent des fonctions avancées :
– Éditeur évolué (couleur, autocorrection, présentation…)
– Assistance syntaxique
– Générateur de code
– Débugage
– Environnement d’exécution
–…
Les packages de base
 AWT et Swing
boutons, listes, menus, etc.
 Réseau
Sockets (serveurs, clients), Web (URL), Applet…
 Entrée-sortie
 Fichier, Pipe, accès direct…
 Classes de base
 Date, Chaîne de caractères
 RMI
 Remote Method Invocation
Les packages de base
 JDBC
 Accès aux bases de données relationnelles
 Beans
 Composant Java
 Sécurité
 Cryptage, identification, signature
 Internationalisation
 Format de date/heure
 messages localisés
 caractères UNICODE 2

 Utiles
 Collection, Compression,
Sommaire
• Introduction
• Concepts de la POO
– Objet , classe, encapsulation, héritage, etc.
• Langage Java
– Introduction
– Syntaxe de Java
 Structure d’un programme Java
 Types de données
 Opérateurs
 Instructions
– Objets et Classes
– Relations entre classe : Héritage et polymorphisme
– Interfaces graphiques : AWT
– Les indispensables :Collections, exceptions.
– Les entrées sorties
– Les threads
– Les applets
Constitution d’un programme java
 Un programme Java utilise un ensemble de classes
 Les classes sont regroupées par package
 Une classe regroupe un ensemble d’attributs et de
méthodes

Package

Classe
Attributs

Méthodes
Premier programme en Java
public class PG1{
public static void main (String argv[])
{
System.out.println("MON PREMIER PROGRAMME JAVA ");
}
}

 public class PG1 : Nom de la classe


 public static void main : nom de la fonction principale (point
d’entrée d’un programme java)
String argv[] : permet de récupérer les arguments transmit au
programme au moment de son exécution (lancement)
 System.out.println(« MON PREMIER PROGRAMME JAVA ") :
méthode d’affichage dans une fenêtre console
Étapes de mise en oeuvre
1. Edition (saisie) : saisir le programme source java avec un
éditeur:
 le nom de fichier doit être le même que le nom de la
classe (nom de fichier= PG1.java)
2. Compilation : produire le byte code a partir de fichier
source (.java) en utilisant la commande javac
 javac PG1.java
Génération d’un fichier byte code PG1.class
3. Exécution : exécuter le byte code obtenu en utilisant la
commande java
 java PG1 paramètre1 paramètre2
 ne pas mettre .class pour l’exécution.
Briques de base de java

 Les briques de base du langage: Nous traitons Java


d'abord comme un langage de programmation
classique. Nous aborderons les objets ultérieurement.
 Les composantes de bases sont :
Ce qui permettent de stocker des données: variables,
constantes (types), etc.
Les expressions qui permettent de manipuler les données :
affectation, comparaison, etc.
Les instructions pour construire les algorithmes : tests,
boucle, etc.
Les objets
Les commentaires
 Les commentaires : Ils ne sont pas pris en compte par le compilateur donc
ils ne sont pas inclus dans le pseudo code. Ils ne se terminent pas par un
caractère ";".
 Il existe trois types de commentaire en Java :
Type de commentaires Exemple

commentaire abrégé // commentaire sur une seule ligne


int N=1; // déclaration du compteur
commentaire multi ligne /* commentaires ligne 1
commentaires ligne 2 */

commentaire de documentation automatique /**


* commentaire de la methode
* @param val la valeur a traiter
* @since 1.0
* @return Rien
* @deprecatedUtiliser la nouvelle methode XXX
*/
Les types de données dans Java
 Types arithmétiques
Entiers byte 8 bits signé (-128 , 127)
short 16 bits signé (-32768 , 32767)
int 32 bits signé (-2147483648 , 2147483647)
long 64 bits signé (-9223372036854775808,
9223372036854775807)
Réels float 32 bits signé (1.4E-45 , 3.4028235E38)
double 64 bits signé (4.9E-324 ,
1.7976931348623157E308)

 Type caractère
char 16 bits non signé UNICODE2
 Type booléen

boolean 1 bit deux valeurs possibles : true ou false


Les identificateurs
 Chaque objet, classe, programme variable, constante 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 ( id <>iD)
 Un identificateur ne peut pas appartenir à la liste des mots réservé du langage Java :

abstract const final int public throw assert continue finally


interface return throws boolean default float long short transient
break do for native static true byte double goto new strictfp try
case else if null super void catch enum (Java 5) implements package s witch
volatile
Char extends import private synchronized while class false instanceof
protected this
Déclaration de variables
 La Syntaxe de la déclaration :
type nom_variable; // nom_variable est un identificateur
 exemples :
int p ; // p est une variable de type entier
double x ; // x est une variable de type flottant
char c; // c est une variable de type caractère
boolean b ; // b est une variable de type booléenne
int X,Y,Z ; //Il est possible de définir plusieurs variables de même type en séparant chacune d'elles par une
virgule.
La syntaxe de l’Initialisation d’une variable
type ma_variable=valeur; // initialisation de la variable
 exemples :
boolean result = true;
char capitalC = ‘C’;
byte b = 100;
short s = 10000;
int i = 100000;
int decVal = 26; // Le numero 26, en decimal
int octVal = 032; // Le numero 26, en octal
int hexVal = 0x1a; // Le numero 26, en hexadecimal
double d1 = 123.4;
double d2 = 1.234e2; // notation scientifique
float f1 = 123.4f;
Déclaration de constantes
 Java définie une constante grâce au mot clé final : elle ne peut être
initialisée qu'une seule fois de façon statique (à la compilation) ou
dynamique. Une fois la valeur affectée, elle ne peut plus être
modifiée.
 La syntaxe de la déclaration d’une constante
final type nom_constante; // nom_constante est un identificateur
 Exemples :
final int C=20; // Constante entière ayant une valeur 20
C= 15; // erreur de compilation
Les opérateurs
 Un opérateur : applique une fonction sur des opérandes
(variables ou valeur) => valeur de retour
 La valeur de retour d’un opérateur dépend de l’opérateur,
mais aussi du type de ses opérandes
 Les différents opérateur sont :
 Affectation
 Les opérateurs arithmétiques
 Opérateurs unaires
 Opérateurs de comparaison
 Opérateurs logiques
L’affectation

 L’opérateur « = »  permet d’affecter la valeur


de l’expression qui est à droite à la variable qui
est à gauche.
class Test {
int calculer () {
int i = 0; // affecter la valeur 0 à la variable i
int j = 6; // affecter la valeur 6 à la variable j
i = (j + 5) * 3; // affecter la valeur de l’expression à i
return i + j;
}
}

42
Les opérateurs arithmétiques

 S’appliquent sur les types entiers ou réels


 +, - , * , / , % (modulo) , += , -= , *= , /=
int x, y, z;
y = 2;
z = 3;

x = y * z ; //x vaut 6
x += 2 ; //x vaut 8
y = x / 4 ; //y vaut 2
y =x % 2 ; //y vaut 0

 Les opérateur = et += peuvent être utilisés sur des variables de


type « String »
 En terme de performance, il est recommandé d’utiliser la
notion raccourcie (+=,*=,-=)
Opérateurs unaires
 S’appliquent à un seul opérande de type entier ou réel
: -, --, +, ++
int x, y;
x = 3;

y = -x ; //y vaut -3
y = ++x ; //y vaut 4, x vaut 4
y = x-- ; //y vaut 4, x vaut 3

 La pré et la post-incrémentation diminuent le nombre de


lignes de byte code générées
y = ++x ;  y=x+1;
y = x-- ;  y=x; x=x-1;
Opérateurs de comparaison

 S’appliquent sur des entiers, booléens, réels


== (égal) , != (différent), < (inférieur), <=
(inférieur ou égal), > (supérieur), >= (supérieur
ou égal).
 Ces opérateurs retournent une valeur du type
booléen
{
boolean droitDeVote;
int age;

droitDeVote = (age >= 18) ;


}
Opérateurs logiques

 S’appliquent au type boolean


! (not) , && (and) , II (or)
&, I
 Retournent un type boolean
 & renvoie « true » si les deux expressions renvoient « true »
 && a le même comportement mais n’évalue pas le seconde
expression si la première est « false »
 | renvoie « true » si l’une des deux expressions renvoie
« true »
 || a le même comportement mais n’évalue pas le seconde
expression si la première est « true »
Un opérateur spécial : l’opérateur ?

 la syntaxe :
expression1? expression2: expression3;
expression1 est évaluée en premier. Si sa valeur est true, expression2 est
calculée, sinon expression3 est calculée.

 Exemple :
int x = 3, y = 4, max;
max = (x > y)? x: y; //ceci revient à dire max=y;
 
Dans ce code, max reçoit la valeur de x ou de y, selon que x est supérieur à y
ou non.

 Remarque Certains confondent cet opérateur avec une instruction


conditionnelle.
Ce n’est pas une instruction, comme l’illustre l’erreur dans le code suivant :
(x > y)? max = x: max = y; //ne peut pas être utilisé comme une instruction
Priorité des opérateurs
Java définit les priorités dans les opérateurs comme suit ( du plus prioritaire au moins prioritaire )

les parenthèses ()
les opérateurs d'incrémentation ++
--
les opérateurs de multiplication, division, et modulo *
/
%
les opérateurs d'addition et soustraction +
-
les opérateurs de décalage <<
>>
les opérateurs de comparaison <
>
<=
>=

les opérateurs d'égalité ==


!=
l'opérateur OU exclusif ^
l'opérateur ET &
l'opérateur OU |
l'opérateur ET logique &&
l'opérateur OU logique ||
les opérateurs d'assignement =
+=
-=
Les conversions de type (1/2)
 Il y a 4 contextes possibles de conversion (cast) :
Conversion explicite
Affectation
Appel de méthode
Promotion arithmétique

 Certaines conversions provoquent une perte de valeur


Float en int, int en short, short en byte

 Le type boolean ne peut pas être converti en entier


Les conversions de type (2/2)
double f =3.14 ;
int i,j ;
short s ;

i = (int)f; // float  int (conversion explicite)


float ff = (float)3.14;

i = s; // short  int (affectation)

// appel de la méthode int obj.m(int i)


obj.m(s); // short  int (appel de méthode)

// division d’un entier et d’un flottant : l’entier i est


// converti en flottant, puis la division flottante est
calculée
f = i / (double)j; // (promotion arithmétique)
Les Instructions
 Comme la quasi totalité des langages de développement orienté
objets, Java propose un ensemble d'instructions qui permettent
d'organiser et de structurer les traitements. L'usage de ces
instructions est similaire à celui rencontré dans d'autres
langages.
Ces instruction sont :
 Les tests conditionnels
 Les boucles
 Les débranchements
Test conditionnel (if …else)
 la syntaxe :  Exemple :
if (condition) { class Test {
public static void main (String
Bloc d’instruction args[]) {
} int compteur = 0;
else { boolean debut;
Bloc d’instruction
if (compteur == 0) {
} debut = true;
 condition est de type System.out.println("Début
booléen de la partie");
 le if ne nécessite pas de }
else if (compteur ==10)
then System.out.println("Fin de la
 si Bloc d’instruction est une seule partie");
instruction alors pas besoin des {}
else
System.out.println("Partie en
cours");
}
}
Test conditionnel Switch …case
 Syntaxe :  Exemple :
class Test {
switch (expression) { public static void main (String args[])
case constante1 : {

instr11; char c = (char)System.in.read();


switch(c) {
instr12; case ‘o’ : case ‘O’ :
break; System.out.println("Oui");
break;
case constante2 : case ‘n’ : case ‘N’ :
... System.out.println("Non");
break;
default : default :
...
System.out.println("Mauvaise
} réponse");
 Le « switch » ne s’applique qu’au type break;
}
entier ou caractère. }
 Si une instruction case ne contient }

pas de break alors les traitements


associés au case suivant sont
exécutés.
 Il est possible d'imbriquer des switch
Boucles while
 Syntaxe
 Exemple
while ( condition) class Test {
{ public static void main
(String args[]) {
... // code a exécuter dans la boucle int i;
}
do {
Condition est de type System.out.println("Entrez un
booléen nombre < 10");
Le code est exécuté tant que la c= lireUnInt();
} while (c>10);
condition est vraie. Si avant
l'instruction while, la condition est while (c>0) afficher (c--);
}
fausse, alors le code de la boucle ne
sera jamais exécuté public static int lireUnInt()
 Autre syntaxe {……}
do { public static void afficher
... // code a exécuter dans la boucle (char c) {……}
} while ( condition)
}
Le code est exécuté au moins une
fois.
Boucle for
 Syntaxe :  Exemple :
for ( initialisation; condition; modification) class Test {
public static void main(String args[])
{ {
... int i;
}
Condition est de type for (i=0 ; i <=5 ; i++) {
System.out.println (i);
booléen ……
 Dans l'initialisation, on peut }
déclarer une variable qui servira
for (int j=0 ; j <=5 , j++) {
d'index et qui sera dans ce cas locale à System.out.println (i);
la boucle ……
}
Il est possible d'inclure plusieurs
traitements dans l'initialisation et la // i est accessible
modification de la boucle : chacun des // j n’est pas accessible
traitements doit être séparé par une }
virgule. }
Les débranchements

 break : permet de quitter immédiatement une boucle


ou un branchement (switch …case).
 continue : s'utilise dans une boucle pour passer
directement à l'itération suivante
 break et continue peuvent s'exécuter avec des blocs
nommés. Il est possible de préciser une étiquette
pour indiquer le point de retour lors de la fin du
traitement déclenché par le break.
 Une étiquette est un nom suivi d'un deux points qui
définit le début d'une instruction.
Exemples
int x = 0; for ( int x = 0 ; x < 6 ; x++)
while (x < 6){ {
System.out.println(i); if(x == 4)
continue; //revient au début de la
x++;
boucle avec x=6
if (x == 4) System.out.println(i);
break; }
else
//faire quelque chose d’autre
Résultat:
}
0
1
Résultat: 2
0 3
1 4
2 5
3
Les tableaux : description

 Nombre fixe d’éléments. Taille fixée à la


construction
 Les éléments sont de même type (type de base ou
classe)
 Les tableaux sont alloués dynamiquement par
l’opérateur « new »
 Un tableau est détruit lorsqu’il n’est plus référencé
 Les tableaux multi-dimensionnels sont des
tableaux de tableaux
Les tableaux : déclaration
• Les tableaux peuvent être déclarés suivant les
syntaxes suivantes :
type [] nom ;
type nom [];
Exemples :
int table[];
double [] d1,d2 ;
Les tableaux : initialisation
 L’attribut « length » renvoie la dimension du
tableau
 L’indice des éléments du tableaux varie de 0 à
« tableau.length –1 »
 Initialisation statique :
int[] monTableau = {1, 2, 3};

 Initialisation dynamique :
int[] param = new int[10];

for (int i = 0; i < param.length ; i++)


param[i]= i;

60
Chaines de caractères
 Les chaînes de caractères sont manipulées par la
classe String (ce n’est donc pas un type de données).
 Exemples :
String str = ”exemple de chaine de caractères” ;
String chaine = ”Le soleil ” + ”brille” ; // Opérateur de
concaténation
La valeur initiale d’une variable du type String est null
(ainsi que pour toutes les variables dont leur type est une
classe d’objets).
Mais attention!! Techniquement, String n’est pas un type
primitif. Il s’agit d’une classe du paquetage java.lang.
TP
Avant de programmer en Java
Le JDK de Sun (Java Development Kit) est l’outil essentiel pour programmer en Java.
Il permet la compilation, le débogage et l’exception d’applications et d’applets Java.
Après avoir installé le JDK, il faut définir un chemin de recherche des exécutables «
PATH ».
Pour le faire, Lancer une session DOS et taper :
Set Path=C:\JDK\bin ou bien directement Path=C:\JDK\bin
(Donne la valeur C:\JDK\bin à la variable d’environnement path) Ou encore
Set Path=%Path%;C:\JDK\bin
(Ajoute le chemin C:\JDK\bin à la valeur de la variable d’environnement path)
Ceci ne fonctionne que si C:\JDK\ est le répertoire d’installation du JDK. Si ce n’est
pas le cas, remplacer-le par votre vrai répertoire.
Lecture des données à partir du clavier

 Utilisation de la classe Scanner définie dans le


package « java.utils »
 Etapes :
 inclure le package : import java.util.*;
 créer un objet de la classe scanner (sc) :
Scanner sc=new Scanner(System.in);
 lire les données avec la méthode (nextXXX)
 lire un entier : int a = sc.nextInt();
 lire un double : double d=sc.nextDouble()
Exemple
import java.util.*; // inclure le package

public class exemple{


public static void main(String[] args) {
Scanner sc=new Scanner(System.in); // création d’un
//objet de type scanner
int a=sc.nextInt(); // lecture d’un entier
double d=sc.nextDouble(); // lecture d’un double
}
}

Vous aimerez peut-être aussi