Les Bases de JAVA

Les bases de JAVA
Programmation Orientée Objet avancée en JAVA

Module: M22 - 4ième Année FI-GTR
Pr. Abdessamad EL BOUSHAKI

abdessamad.elboushaki@gmail.com
ENSA de Fès
Université Sidi Mohammed Ben Abdellah
Pr. Abdessamad EL BOUSHAKI (ENSA de Fès) Programmation Orientée Objet en JAVA 1/46
Les bases de JAVA
Programmation orientée objet avancée en JAVA
Objectif du cours
I Apprendre le langage JAVA (les applications, les APIs,...).
I Apprendre le paradigme de la Programmation Orientée Objet en JAVA.
I Utiliser des outils d’aide au développement (Environnement de
développement, ...).
Organisation
I 16h de cours : Concepts de la POO et JAVA.
I 16h de TP : Programmation JAVA et outils de développement.
Évaluation
I Examen * 0.53 + TP * 0.47. TP : 2 TP relevés et notés.
Les bases de JAVA
Les bases de JAVA
Les bases de JAVA
Introduction
JAVA
I JAVA est une langage de programmation moderne développé par Sun
Microsystems (Début des années 90 ), aujourd’hui racheté par Oracle.
I Il est compilé et basé sur une architecture logicielle très particulière
nécessitant une machine virtuelle Java.
I Il permet une programmation orientée-objet (à l’instar de SmallTalk et
C++), modulaire (langage ADA) et reprend une syntaxe très proche de celle
du langage C.
I Il est accompagné d’un ensemble énorme de bibliothèques standard couvrant
de très nombreux domaines.
I La technologie JAVA est indissociable du domaine de l’informatique et du
Web. On la retrouve donc sur les ordinateurs, mais aussi sur les téléphones
mobiles, les consoles de jeux, etc.
I La technologie Java regroupe aujourd’hui différents standards, des logiciels et
des communautés d’entreprises. Le terme est l’un des plus répandus sur la
Toile et dans le monde de l’informatique. Il a même été utilisé comme
symbole boursier au Nasdaq par Sun.
Les bases de JAVA
Introduction
Avantages
I simple: Plus simple que C++, nombreux mots clés éliminés, pas de
pointeurs visibles au niveau du programmeur..
I modulaire: On peut écrire des portions de code génériques, c-à-d utilisables
par plusieurs applications.
I Portable: Un même programme compilé peut s’exécuter sur différents
environnements.
I Rigoureux: La plupart des erreurs se produisent à la compilation et non à
l’exécution.
I Avantages de POO: Utilise les notions usuelles de la programmation
orientée objet : la notion de classe, d’encapsulation, d’héritage, d’interface,
de virtualité, de généricité,...
Inconvénient
I les applications Java ont le défaut d’être plus lentes à l’exécution que des
applications programmées en C++ par exemple.
Les bases de JAVA
Introduction
Il est possible d’utiliser Java pour créer des logiciels dans des environnements
très diversifiés:
I applications machine (IHM, Swing) ;
I applications sur client lourd (JFC) ;
I applications Web, côté serveur (servlets, JSP, Struts, JSF, J2EE) ;
I applications réparties (EJB) ;
I applications embarquées (J2ME) ;
I applications sur carte à puce (JavaCard).
Ces applications peuvent être enrichies par de nombreuses fonctionnalités:

I accès à des bases de données (JDBC et JDO) ;
I accès à des annuaires (JNDI) ;
I traitements XML (JAXP) ;
I connexion à des ERP (JCA) ;
I accès à des traitements en d’autres langages (JNI) ;
I services web (JAX-RPC, JAXM, JAXR) ;
I multimédia (Java Media) ;
I téléphonie (JTAPI) ;
I télévision interactive (Java TV).
Les bases de JAVA
Environnement Java
Java est un langage interprété, ce qui signifie qu’un programme compilé
n’est pas directement exécutable par le système d’exploitation mais il doit
être interprété par un autre programme, qu’on appelle interpréteur.
Figure : La compilation du programme p1.java en son équivalent p1.class en bytecode.
Figure : L’interprétation du bytecode p1.class sur n’importe quel ordinateur disposant

d’un interpréteur de bytecode (indépendamment du langage machine de cet ordinateur).
Les bases de JAVA
Environnement Java
Un programmeur Java écrit son code source, sous la forme de classes, dans
des fichiers dont l’extension est .java. Le langage source Java est défini par
la JLS (Java Language Specification) éditée par Sun-Oracle.
Ce code source est alors compilé par le compilateur javac en un langage

intermédiaire appelé bytecode et enregistre le résultat dans un fichier dont
l’extension est .class.
Le bytecode ainsi obtenu n’est pas directement utilisable. Il doit être

interprété par la machine virtuelle de Java (JVM) qui transforme alors,
avec la comande java, le code compilé en code machine compréhensible par
le système d’exploitation.
Le rôle de la JVM est d’abstraire le comportement d’une machine pour

rendre le possible indépendant de la plateforme. on parle plus communément
de JRE (Java Runtime Environment).
Les bases de JAVA
Installer les outils de développement

Les outils de développement Java (JDT) constituent un ensemble d’extensions du
plan de travail qui permet d’éditer, de compiler et d’exécuter des programmes
Java.
JRE ou JDK:
I Java Runtime Environment (JRE): environement qui permet d’exécuter
applications java. Il contient le JVM, les bibliothèques de base et d’autres
composants supplémentaires pour l’exécution d’applications et d’applets écrits
dans Java (ex. Java SE).
I Java Development Kit (JDK) : il s’agit d’un bundle de logiciels qui peut être
utilisé pour développer des programmes Java. Il contient le JRE, un jeu de
classes API, un compilateur Java, Web Start et d’autres fichiers requis pour
l’écriture d’applets et d’applications Java.
IDE:
I Integrated Development Environment (IDE): un outil de développement
permet notamment d’écrire, de compiler, d’exécuter et de déboguer des
applications depuis une interface graphique simplifiée. Les trois IDE les plus
souvent choisis pour le développement Java sont IntelliJ IDEA, Eclipse IDE,
and NetBeans.
Les bases de JAVA
Installer les outils de développement
Figure : JVM vs JRE vs JDK.
Les bases de JAVA
Premier exemple
Dans un fichier de nom HelloWorld.java

I Règle: toute classe publique doit être dans un fichier qui a le même nom
que la classe.
I Règle: tout code doit être à l’intérieur d’une classe.
public class HelloWorld {

/* Un style de commentaire
sur plusieurs lignes . */
public static void main ( String [] args ) {
// Un commentaire sur une seule ligne
System . out . println ( " Bonjour à vous les JTR ! " );
}
}
Ça définit une classe, qui est une unité de compilation.

Comme il y a une méthode main, cette classe est exécutable.
Les bases de JAVA
Variables et types de données

Identificaton
Les contraintes suivantes sont à respecter dans l’écriture des noms de

variables :
I Le premier caractère d’une variable doit obligatoirement être différent d’un
chiffre.
I Aucun espace ne peut figurer dans un nom.
I Les majuscules sont différentes des minuscules, et tout nom de variable
possédant une majuscule est différent du même nom écrit en minuscule.
I Les caractères spéciaux ne peuvent être utilisés dans l’écriture d’un nom de
variable.
I Tout autre caractère peut être utilisé, y compris les caractères accentués, le
caractère de soulignement ( ) et les caractères $.
Nom de variable autorisé Nom de variable interdit

compte pourquoi#pas
num 2 (” ” et non pas ”-”) 2001espace
undeux (et non pas un deux) -plus
VALEUR temporaire @adresse
Val$solde ah!ah!
Les bases de JAVA

Types primitifs
Les types primitifs de Java se répartissent en quatre grandes catégories selon

la nature des informations qu’ils permettent de représenter :
I Entiers: byte, short, int et long, tous signés.
I Nombres à virgule flottante: float et double.
I Caractères: char.
I Booléens : boolean, pour les valeurs logiques.
Le tableau suivant en récapitule leurs caractéristiques:

Type Classe éq. Taille Valeurs Portée Défaut
boolean Boolean 8 bits true ou false N/A false
byte Byte 8 bits entier signé {-128..128} 0
char Character 16 bits caractère {/u0000../uFFFF} /u0000
short Short 16 bits entier signé {-32768..32767} 0
int Integer 32 bits entier signé {-2147483648..2147483647} 0
long Long 64 bits entier signé {-231 ..231 -1} 0
{-3.402823438 ..3.402823438 }
float Float 32 bits réel signé {-1.40239846-45 ..1.40239846-45 }
0.0
{-1, 797693134308 ..1, 797693134308 }

double Double 64 bits réel signé {-4, 94065645-324 ..4, 94065645-324 }
0.0
En plus de ces types primitifs, le terme void est utilisé pour spécifier le
retour vide ou une absence de paramètres d’une méthode.
Les bases de JAVA

Déclarer une variable
Comme en C++, la déclaration des variables doit s’effectuer avant leur

utilisation n’importe où dans un bloc.
I Le syntaxe de déclaration:
type NomDeVariable ;
I Exemple de déclaration:
int a ;
int a , b , c ; // Multiple d é clarations é quivalent à
int a ; int b ; int c ;
I Une variable peut recevoir une valeur initiale au moment de sa déclaration,

comme dans:
int a = 5; // é quivalent à
int a ; a =5;
I Déclaration des constantes avec le mot-clé final:

final char c = ’A ’; // exemple de constante caract è re
final int i = 2017; // exemple de constante enti è re
final double PI = 3.14; // exemple de constante r è el
Les bases de JAVA

Transtypage
Le transtypage (ou cast) est la conversion d’une expression d’un certain

type en une expression d’un autre type. On distingue deux types de
transtypage:
I Conversion implicite: Faite automatiquement par le compilateur lorsque
plusieurs types de données sont impliqués dans une opération.
I En Java, la conversion automatique est seulement possible lorsque le
compilateur sait que la variable destination est assez grande.
I Dans le cas des types primitifs, la hiérarchie est la suivante : byte est plus bas
que short, short plus bas que int, char plus bas que int, int plus bas que
long, long plus bas que float, float plus bas que double. Le type boolean
est incomparable avec les autres types de base.
double a = 0.5 * 8; // a =0.5 * 8.0 = 4.0
I Conversion explicite: Cette conversion est demandée par le programmeur

avec la syntaxe suivante: (nouveau type)expression
int a = 10;
int b = a * ( int )2.5; // r é sultat : 20
int b = ( int )( a * 2.5); // r é sultat : 25
Les bases de JAVA
Les expressions
Dans la plupart des langages, on trouve, comme en Java :
I d’une part, des expressions formées (entre autres) à l’aide d’opérateurs et
variables;
I d’autre part, des instructions pouvant éventuellement faire intervenir des
expressions, comme, par exemple, l’instruction d’affectation :
y = a * x + b ;
dans laquelle apparaı̂t l’expression a ∗ x + b ;
En Java, les notions d’expression et d’instruction sont étroitement liées

puisque la principale instruction de ce langage est une expression
terminée par un point-virgule. On la nomme souvent ”instruction
expression”. Voici des exemples de telles instructions qui reprennent les
expressions évoquées ci-dessus :
++ i ; // é quivalent à i = i + 1
i = 5 ;
i +=5 ; // é quivalent à i = i + 5
k = i = 5 ; // é quivalent à k = ( i = 5)
Les bases de JAVA
Les opérateurs
Les opérateurs sont des symboles qui permettent de manipuler des variables,
c’est-à-dire effectuer des opérations, les évaluer, etc.
On distingue plusieurs types d’opérateurs :
Incrémentation
Affectation /Décrémentation
Arithmétique Logiques Comparaison Autre
+a
a = b -a
a += b a + b
a -= b a - b
a == b
a *= b a * b
++a a != b a(...)
a /= b a / b !a
--a a < b a, b
a %= b a % b a && b
a++ a > b ? :
a &= b ~a a || b
a-- a <= b a.b
a |= b a & b
a >= b
a ^= b a | b
a <<= b a ^ b
a >>= b a << b
a >> b
Les bases de JAVA
Les priorités relatives des opérateurs
Lorsque plusieurs opérateurs apparaissent dans une même expression, il est

nécessaire de savoir dans quel ordre ils sont mis en jeu. En Java, comme
dans les autres langages, les règles sont naturelles et rejoignent celles de
l’algèbre traditionnelle:
Priorité Catégorie Opérateurs

*************** Référence () [] .
************** Unaire + - ++ -- ! ^ * &
************* Arithmétique * / %
************ Arithmétique + -
*********** Décalage << >>
********** Relationnels < <= > >= instanceof
********* Relationnels == !=
******** Manipulation de bits &
******* Manipulation de bits ~
****** Manipulation de bits |
***** Logique &&
**** Logique ||
*** Conditionnel (ternaire) ? :
** Affectation = += -= *= /= %= &= ~= |= >>= <<=
* Séquentiel ,
Les bases de JAVA
Afficher et saisir les données

Afficher de données
Le principe général, pour l’affichage d’un message, est de placer ce dernier en

paramètre de la fonction System.out.print():
I Il s’agit de l’appel de la méthode print(), possédant un paramètre (une

chaı̂ne de caractères). Cette méthode permet d’afficher sur la sortie standard
(ici, l’écran) la chaı̂ne de caractère qui lui est passée en paramètre.
I Il existe aussi une méthode appelée println(), qui lui ajoutant
automatiquement un caractère de retour à la ligne.
I Les deux méthodes sont précédées de System.out, cela signifie qu’ils font
partie de l’objet out, faisant lui-même partie de la classe System.
I Ainsi, la classe System fait partie du package lang, qui fait lui même partie
du package java. Toutefois, il n’est pas nécessaire de préciser
java.lang.System.out, car le package java.lang est importé par défaut.
Les bases de JAVA

Afficher de données
Exemple d’utilisation System.out.print():

/** ** ** * ** ******** Affichage de la valeur d ’ une variable ** ** ** * ** ** * ** * */
int valeur = 22 ;
System . out . print ( valeur ) ;
// 22
/** * * * * * * * * * * * * * * * * * * * * * * * Affichage d ’ un texte * * * * * * * * * * * * * * * * * * * * * * * * */
System . out . print ( " Bonjour à vous ! " ) ;
// Bonjour à vous
/** ************* Affichage d ’ un commentaire avec variable **** ******* *** */
System . out . print ( " Le montant s ’ eleve a : " + valeur ) ;
// Le montant s ’ eleve a : 22
System . out . print ( valeur + " correspond au montant total " ) ;
// 22 correspond au montant total
/** * * * * * * * * ******** Affichage de plusieurs variables * * * * * * * * * * * * * * * * * * * */
int v = 5 , s = 220 ;
System . out . print ( v + " elements valent au total " + s + " francs " ) ;
// 5 elements valent au total 220 francs
/** ******** Affichage de la valeur d ’ une expression arithm é tique ******* */
int a = 10 , b = 5 ;
System . out . print ( a + " fois " + b + " est egal a " + a * b ) ;
// 10 fois 5 est egal a 50
System . out . print ( a + " plus " + b + " est egal a " + a + b ) ;
// 10 plus 5 est egal a 105
System . out . print ( a + " plus " + b + " est egal a " + ( a + b )) ;
// 10 plus 5 est egal a 15
Les bases de JAVA

La saisie de données
La classe Scanner permet l’entrée facile de types primitifs et de String au

clavier. Ce dernier se trouve dans le package java.util que nous devons
importer.
Pour pouvoir récupérer les données saisie, Il suffit de créer un objet Scanner
avec en argument le flux d’entrée standard, System.in, puis d’appeler une
méthode nextXXX() selon le type primitif XXX à lire.
Il y a aussi la possibilité de vérifier le type d’une donnée avant de la lire. Il

suffit d’appeler une méthode hasNextXXX() qui retourne une valeur
boolean selon la congruence le type primitif XXX et le type de donnée saisie.
Attention: Il y a un type de variables primitives qui n’est pas pris en compte

par la classe Scanner : il s’agit du type char qui doit être d’abord scanné
comme chaı̂ne.
Les bases de JAVA

La saisie de données
Exemple d’utilisation la classe Scanner:
// Ceci importe la classe Scanner du package java . util

import java . util . Scanner ;
// Ceci importe toutes les classes du package java . util
import java . util .*;
public class Main {
public static void main ( String [] args ){
Scanner sc = new Scanner ( System . in );
System . out . println ( " Saisissez une cha ^
ı ne : " );
String str = sc . nextLine ();
System . out . println ( " Saisissez un entier : " );
int i = sc . nextInt ();
// Etc ...
/** Voici comment on pourrait r é cup é rer un caract è re :* */

System . out . println ( " Saisissez une lettre : " );
String str = sc . nextLine ();
char carac = str . charAt (0);
System . out . println ( " Vous avez saisi le caract è re : " + carac );
System . out . println ( " FIN ! " );

}
}
Les bases de JAVA
Les instructions de contrôle
En Java, comme en C,on distingue deux types de structures de contrôle:
Structures de contrôle conditionnelles qui permettent de tester si une

condition est vraie ou non. Il s’agit des instructions suivantes:
I La structure conditionnelle if,
I Le branchement conditionnel switch et
I La condition ternaire ? :.
Structures de contrôle itératives qui permettent d’exécuter plusieurs fois la

même série d’instructions jusqu’à ce qu’une condition ne soit plus réalisée.
On appelle ces structures des boucles.
I La boucle for,
I La boucle while et
I La boucle do...while.
Les bases de JAVA
Structure conditionnelle ”if...elseif...else”
La structure conditionnelle if permet de réaliser un test et d’exécuter une

instruction ou non selon le résultat de ce test.
L’expression else permet d’exécuter une autre série d’instructions en cas de
non-réalisation de la condition.
L’expression elseif permet d’exécuter plusieurs tests à la suite.
elseif
else
if if ( condition_1 )
if ( condition ) { instruction_1 ;}
if ( condition ) { instruction_1 ;} elseif ( condition_2 )
{ instruction ;} else { instruction_2 ;}
{ instruction_2 ;} else
{ instruction_3 ;}
I Où condition est une expression dont la valeur est booléenne ou entière.
Toute valeur non nulle est considérée comme vraie. Si le test est vrai,
instruction est exécutée.
I Il est possible de définir plusieurs conditions à remplir avec les opérateurs ET
et OU (&& et ||).
Les bases de JAVA
Structure conditionnelle ”if...elseif...else”
Exemple d’utilisation de la structure conditionnelle if:

public class Main {
float a ;
System . out . println ( " un r é el : " );
a = sc . nextFloat ();
if ( a > 0)
System . out . println ( a + " est positif " );
elseif ( a == 0)
System . out . println ( a + " est nul " );
else
System . out . println ( a + " est n é gatif " );
}
}
Les bases de JAVA
Structure conditionnelle ”switch”
Dans le cas où plusieurs instructions différentes doivent être exécutées selon
la valeur d’une variable de type intégral, Le Java fournit donc la structure de
contrôle switch, qui permet de réaliser un branchement conditionnel:
Syntaxe
switch ( Choix ) // le type de la variable est char ou int

{
case valeur_1 :
instruction_1 ; // A r é aliser si choix vaut valeur_1
break ; // facultatif , pour sortir du bloc switch
case valeur_2 :
instruction_2 ;
break ;
case valeur_3 :
instruction_3 ;
break ;
default :
i ns tr uctionParD é faut ;
}
Les bases de JAVA
Structure conditionnelle ”switch”
Exemple d’utilisation de la structure conditionnelle switch:

public class Main {
int a ;
System . out . println ( " Tapez la valeur de a : " );
a = sc . nextInt ();
switch ( a )
{
case 1 :
System . out . println ( " a vaut 1 " ); break ;
case 2 :
case 3 :
default :
System . out . println ( " erreur " ); break ;
}
}
}
Les bases de JAVA
Structure conditionnelle ”? :”
La particularité de ces conditions réside dans le fait que trois opérandes

(c’est-à-dire des variables ou des constantes) sont mis en jeu, mais aussi que
ces conditions sont employées pour affecter des données à une variable.
Voici à quoi ressemble la structure de ce type de condition :
int x = 10 , y = 20;
int max = ( x < y ) ? y : x ; // Maintenant , max vaut 20
int x = 10 , y = 20;
int max = ( x < y ) ? y * 2 : x * 2 ; // Ici , max vaut 2 * 20 donc 40
int x = 10 , y = 20;
int max = ( x < y ) ? ( y < 10) ? y % 10 : y * 2 : x ; // max vaut 40
/** On peut entourer la deuxi è me instruction ternaire par des parenth è ses
pour mieux voir : */
max = ( x < y ) ? (( y < 10) ? y % 10 : y * 2) : x ; // max vaut 40
Les bases de JAVA
La structure itérative ”for”
La boucle for est une structure de contrôle qui permet de répéter un certain
nombre de fois une partie d’un programme. Elle permet de condenser:
I Un compteur: une instruction consiste à préciser le nom de la variable qui
sert de compteur et éventuellement sa valeur de départ.
I Une condition: une expression dont la valeur déterminera la fin de la boucle.
I Une itération: une instruction qui incrémente ou décrémente le compteur.
Syntaxe
for ( compteur ; condition ; it é ration )
{
instructions ;
}
Les bases de JAVA
La structure itérative ”for”
Exemple d’utilisation de la structure itérative for:
public class Main {

int i ;
for ( i = 1 ; i < 10 ; i ++)
System . out . println ( i + " || " );
System . out . println ( " Fin " ) ;
}
}
Il y a aussi la possibilité de cumuler les déclarations, les conditions et les

instructions de fin de boucle :
for ( int i = 0 , int j = 2; ( i < 10 && j < 6); i ++ , j +=2)

{
System . out . println ( " i = " + i + " , j = " + j );
}
Les bases de JAVA
La structure itérative ”while”
La boucle while permet d’exécuter des instructions en boucle tant qu’une

condition est vraie.
Exemple
public class Main {
Syntaxe int i = 1;
// affiche les valeurs de 1 jusqu ’à 9
while ( condition )
while ( i < 10)
{
{
instructions ;
System . out . println ( " " + i );
}
i ++ ;
}
}
}
Les bases de JAVA
La structure itérative ”while”

Un autre exemple d’utilisation de la structure itérative while:

public class Main {
String prenom ;
char reponse = ’O ’;
while ( reponse == ’O ’)
{
System . out . println ( " Donnez un pr é nom : " );
prenom = sc . nextLine ();
System . out . println ( " Bonjour " + prenom + " , comment vas - tu ? " );
// Sans ça , nous n ’ entrerions pas dans la deuxi è me boucle
reponse = ’ ’;
// Tant que la r é ponse n ’ est pas O ou N , on repose la question
while ( reponse != ’O ’ && reponse != ’N ’)
{
// On demande si la personne veut faire un autre essai
System . out . println ( " Voulez - vous r é essayer ? ( O / N ) " );
reponse = sc . nextLine (). charAt (0);
}
}
System . out . println ( " Au revoir ... " );
}
}
Les bases de JAVA
La structure itérative ”do...while”
La boucle do...while effectue le test sur la condition après l’exécution des

instructions. Cela signifie que les instructions sont toujours exécutées au
moins une fois, que le test soit vérifié ou non.
Exemple
public class Main {
Syntaxe int i = 1;
do
do
{
{
System . out . println ( " " + i );
instructions ;
i ++;
} while ( condition ) ;
} while (i <10);
// affiche les valeurs de 1 jusqu ’à 9
}
}
Les bases de JAVA
La structure itérative ”do...while”
Un autre exemple d’utilisation de la structure itérative do...while:

public class Main {
String prenom = new String ();
// Pas besoin d ’ initialiser : on entre au moins une fois dans la boucle !
char reponse = ’ ’;
do {
System . out . println ( " Donnez un pr é nom : " );
prenom = sc . nextLine ();
System . out . println ( " Bonjour " + prenom + " , comment vas - tu ? " );
do {
System . out . println ( " Voulez - vous r é essayer ? ( O / N ) " );
reponse = sc . nextLine (). charAt (0);
} while ( reponse != ’O ’ && reponse != ’N ’ );
} while ( reponse == ’O ’ );
System . out . println ( " Au revoir ... " );
}
}
Les bases de JAVA
La récursivité
En informatique, la récursivité est un des concepts de programmation les plus

importants. C’est l’équivalent de la récurrence en mathématique.
Permet de résoudre des problémes complexes en les décomposant en

problémes plus petits.
Le langage Java comme C ou C++ gère la récursivité des fonctions. Une

fonction peut s’appeler elle-même pour opérer sur de nouveaux
paramètres.
La fonction doit comporter un test d’arrêt (des appels récursifs) qu’il est
conseillé de mettre en début de fonction.
La programmation réccursive sert à remplacer les boucles (while, for,etc).
Les bases de JAVA
La récursivité
Exemples
Factorielle
Par exemple, la fonction factorielle peut être définie sous forme récursive de
la manière suivante:
si n=0 alors factorielle(n)=1 sinon factorielle(n)=n*factorielle(n-1)
Lorsque n >= 1, il y a récursivité car la définition de factorielle(n) fait appel
à factorielle(n-1).
Suite de Fibonacci
( F (0) = 0
F (1) = 1 (1)
F (n) = F (n − 1) + F (n − 2) si n > 1
Les bases de JAVA
La récursivité
Exemples
implémentation en Java:
Factorielle
long fact ( int N )
{
if ( N == 0)
return 1;
else
return N * fact (N -1);
}
Suite de Fibonacci
long Fibonacci ( int N )
{
if ( N == 0)
return 0;
elseif ( N == 1)
return 1;
else
return Fibonacci (N -1) + Fibonacci (N -2);
}
Les bases de JAVA
Ruptures de séquence
break et continue
L’instruction break est utilisée pour sortir immédiatement d’un bloc

d’instructions (sans traiter les instructions restantes dans ce bloc).
L’instruction continue est utilisée pour ignore le reste des instructions et

passe tout de suite à l’itération suivante (au début de la boucle).
Exemple
for ( int i =0; i <10 ; i ++){
if ( i ==5) continue ; // Si i =5 , on passe à 6 sans afficher
if ( i ==7) break ; // Si i =7 , on sort de la boucle
System . out . println ( " The value of i is : " + i ); // 0 , 1 , 2 , 3 , 4 , 6
}
System . out . println ( " The value of i is : " + i ); // 7
Les bases de JAVA
Les tableaux
En programmation, on parle de tableau pour désigner un ensemble

d’éléments de même type désignés par un nom unique.
Comme tous les langages, Java permet de manipuler des tableaux.
En Java, les tableaux sont considérés comme des objets, et pas
seulement une suite d’emplacements mémoire comme en C/C++.
les tableaux à plusieurs indices s’obtiennent par composition de tableaux.
Le type des éléments peut être un type primitif ou une classe.
Chaque élément étant repéré par un indice précisant sa position au sein de
l’ensemble.
L’utilisation d’un tableau se décompose en trois parties :
I Création du tableau ;
I Remplissage du tableau ;
I Lecture du tableau.
Les bases de JAVA
Les tableaux
Création du tableau - Tableaux unidimensionnels
Lors de la définition d’un tableau, les [ ] spécifiant qu’il s’agit d’un tableau
peuvent être placés avant ou après le nom du tableau :
TypeDuTableau NomDuTableau [] ; // Ou encore
TypeDuTableau [] NomDuTableau ;
Exemple de déclaration :
int TEntier [];
char [] TCaractere ;
Un tableau peut être déclaré et initialisé en même temps :

int TEntier [] = {0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9};
double TDouble [] = {0.0 ,1.0 ,2.0 ,3.0 ,4.0 ,5.0 ,6.0 ,7.0 ,8.0 ,9.0};
char TCaractere [] = { ’a ’ , ’b ’ , ’c ’ , ’d ’ , ’e ’ , ’f ’ , ’g ’ };
String TChaine [] = { " chaine1 " , " chaine2 " , " chaine3 " ," chaine4 " };
Pour allouer l’espace nécessaire au tableau il faut utiliser le mot-clé new :

int TEntier [] = new int [10]; // Ou encore
char [] TCaractere ;
TCaractere = new char [7];
Les bases de JAVA
Les tableaux
Manipulation des éléments - Tableaux unidimensionnels
Un élément du tableau peut être manipulé exactement comme une variable,

on peut donc effectuer des opérations avec (ou sur) des éléments de tableau.
Les éléments d’un tableau sont indicés à partir de 0 à taille - 1. Chaque
élément peut être accédé individuellement en donnant le nom du tableau
suivi de l’indice entre [ ].
TEntier [3] = 547; // Affectation

TEntier [2] = TEntier [2] + 547; // Utilisation
Un tableau possède un attribut length qui permet de connaı̂tre le nombre

d’éléments d’un tableau :
System . out . println ( TEntier . length ); // vaut 10.
System . out . println ( TCaractere . length ); // vaut 7.
L’accès à un élément du tableau en dehors des bornes provoque la levée

d’une exception ArrayIndexOutOfBoundsException.
Les bases de JAVA
Les tableaux
Manipulation des éléments - Tableaux unidimensionnels
On peut parcourir les tableaux en utilisant une boucle.
On peut ainsi effectuer une action sur chacune des cases d’un tableau, l’une
après l’autre : par exemple afficher le contenu des cases.
public class Main {

final int n = 10;
int Tab [] = new int [ n ];
for ( int i = 0 ; i < Tab . length ; i ++ )
{
tab [ i ]= i * i ;
System . out . println ( " Le tableau [ " + i + " ] contient la valeur " + tab [ i ]);
}
}
}
Les bases de JAVA
Les tableaux
Création du tableau - Tableaux multidimensionnels
Le tableau multidimensionnel et un tableau dont les éléments sont eux

mêmes des tableaux.
Par exemple, pour un tableau à deux dimensions, ces trois déclarations sont
équivalentes :
t yp eD es Elements [][] nomduTableau ; // Ou encore
t yp eD es Elements [] nomduTableau [] ; // Ou encore
t yp eD es Elements nomduTableau [][];
Exemple de déclaration :
double [][] matrice ;
double [] matrice [] ;
double matrice [][];
Comme pour tableaux unidimensionnels possible de créer un tableau

multidimensionnel en donnant explicitement la liste de ses éléments à la
déclaration:
double [][] matrice = {{1.5 ,2.8 ,3.4 ,4.6} , {6.9 ,7.3 ,8.4 ,9.3} ,
{1.1 ,2.0 ,3.7 ,4.8} , {6.6 ,7.3 ,8.9 ,9.6}};
Les bases de JAVA
Les tableaux
Création du tableau - Tableaux multidimensionnels
L’allocation d’espace mémoire pour un tableau multidimensionnel se fait

comme suite:
// Cr é ation d ’ une matrice 4 x4 de r é els
double [][] matrice = new double [4][4];
// Ou encore
double [][] matrice = new double [4][];
for ( int i =0; i < 4; i ++)
matrice [ i ] = new double [4];
// Ou encore
double [][] matrice ;
matrice = new double [4][];
for ( int i =0; i < 4; i ++)
matrice [ i ] = new double [4];
Chaque tableau imbriqué peut avoir une taille différente:

char [][] txt = new char [3][];
txt [0] = new char [80];
Les bases de JAVA
Les tableaux
Manipulation des éléments - Tableaux multidimensionnels
Chaque élément d’un tableaux multidimensionnel peut être accédé

individuellement en donnant le nom du tableau suivi de l’indices entre
[][]...[]
matrice [3][2] = 54.45; // Affectation

matrice [2][3] = matrice [2][3] + 7.4; // Utilisation
Chaque tableau imbriqué possède un attribut length qui permet de

connaı̂tre le nombre d’éléments de ce tableau:
System . out . println ( txt . length ); // vaut 3.
System . out . println ( txt [0]. length ); // vaut 80.
De la même manière que précédement, on peut facilement parcourir tous les

éléments d’un tableau:
int i , j ;
for ( i =0; i < matrice . length ; i ++){
for ( j =0; j < matrice [ i ]. length ; j ++){
// Action sur matrice [ i ][ j ]
}
}
Les bases de JAVA
Les chaı̂nes de caractères
Les chaı̂nes de caractères (String) sont essentielles et omniprésentes dans

les programmes informatiques.
String n’est en fait pas un type primitif, c’est une classe (voir plus tard).
Leur utilisation ressemble néanmoins très fort à celle des autres types:
I Déclaration d’un String:
String s1 ;
String s1 , s2 ;
I Déclaration et initialisation:
String s3 = " Hello " ;
I Opérations essentielles:
s2 = " le monde " ; // Affectation

String s4 = s1 + " " + s2 ; // Concat é nation
char c = s1 . charAt (2); // Acc è s à un é l é ment

Les Bases de JAVA

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Les Bases de JAVA

Transféré par

Droits d'auteur :

Formats disponibles

Les bases de JAVA

Programmation Orientée Objet avancée en JAVA

Pr. Abdessamad EL BOUSHAKI

Programmation orientée objet avancée en JAVA

Les bases de JAVA

Ces applications peuvent être enrichies par de nombreuses fonctionnalités:

Figure : La compilation du programme p1.java en son équivalent p1.class en bytecode.

Figure : L’interprétation du bytecode p1.class sur n’importe quel ordinateur disposant

Ce code source est alors compilé par le compilateur javac en un langage

Le bytecode ainsi obtenu n’est pas directement utilisable. Il doit être

Le rôle de la JVM est d’abstraire le comportement d’une machine pour

Installer les outils de développement

Installer les outils de développement

Figure : JVM vs JRE vs JDK.

Dans un fichier de nom HelloWorld.java

public class HelloWorld {

Ça définit une classe, qui est une unité de compilation.

Variables et types de données

Les contraintes suivantes sont à respecter dans l’écriture des noms de

Nom de variable autorisé Nom de variable interdit

Variables et types de données

Les types primitifs de Java se répartissent en quatre grandes catégories selon

Le tableau suivant en récapitule leurs caractéristiques:

{-1, 797693134308 ..1, 797693134308 }

Variables et types de données

Comme en C++, la déclaration des variables doit s’effectuer avant leur

I Une variable peut recevoir une valeur initiale au moment de sa déclaration,

I Déclaration des constantes avec le mot-clé final:

Variables et types de données

Le transtypage (ou cast) est la conversion d’une expression d’un certain

double a = 0.5 * 8; // a =0.5 * 8.0 = 4.0

I Conversion explicite: Cette conversion est demandée par le programmeur

dans laquelle apparaı̂t l’expression a ∗ x + b ;

En Java, les notions d’expression et d’instruction sont étroitement liées

Les priorités relatives des opérateurs

Lorsque plusieurs opérateurs apparaissent dans une même expression, il est

Priorité Catégorie Opérateurs

Afficher et saisir les données

Le principe général, pour l’affichage d’un message, est de placer ce dernier en

I Il s’agit de l’appel de la méthode print(), possédant un paramètre (une

Afficher et saisir les données

Exemple d’utilisation System.out.print():

Afficher et saisir les données

La classe Scanner permet l’entrée facile de types primitifs et de String au

Il y a aussi la possibilité de vérifier le type d’une donnée avant de la lire. Il

Attention: Il y a un type de variables primitives qui n’est pas pris en compte

Afficher et saisir les données

Exemple d’utilisation la classe Scanner:

// Ceci importe la classe Scanner du package java . util

/** Voici comment on pourrait r é cup é rer un caract è re :* */

System . out . println ( " FIN ! " );

Les instructions de contrôle

En Java, comme en C,on distingue deux types de structures de contrôle:

Structures de contrôle conditionnelles qui permettent de tester si une

Structures de contrôle itératives qui permettent d’exécuter plusieurs fois la

Structure conditionnelle ”if...elseif...else”

La structure conditionnelle if permet de réaliser un test et d’exécuter une

Structure conditionnelle ”if...elseif...else”

Exemple d’utilisation de la structure conditionnelle if:

import java . util . Scanner ;

Structure conditionnelle ”switch”

switch ( Choix ) // le type de la variable est char ou int

Structure conditionnelle ”switch”