Chapitre 2

Chapitre II : Eléments de base du langage java

A.Hammache

1

Plan du Chapitre Introduction et historique JDK, JRE et packages de base Structure d’un programme Java Types de données Opérateurs Instructions Tableaux et chaines de caractères A.Hammache

2

Origine du langage Développé par SunSoft (SUN) pour réaliser des 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/  Livres  La programmation objet en Java : Michel Divay, Dunod , 2006.

A.Hammache

3

Java est simple Simplicité relative par rapport au C++ 1. Certains concepts du C++ à l’origine de nombreux bugs ont été supprimés  

Pointeurs Surcharge des opérateurs

2. Des études comparatives de développement montrent une diminution du coût de développement de 30 à 35 %. A.Hammache

4

Java est un langage objet Java reprend des caractéristiques de différents langages à objets  La syntaxe de C++  La gestion dynamique de la mémoire de SmallTalk

1. Toute ligne de code JAVA se trouve obligatoirement dans une méthode à l’intérieur d’une classe

2. Java implémente les concepts de l’orienté objet  Encapsulation  Héritage  Polymorphisme

A.Hammache

5

Java est robuste et sûr 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

A.Hammache

6

JAVA est portable  Un code source Java est compilé pour générer un code assembleur virtuel : le bytecode 1. 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 o en moyenne, une instruction bytecode = 1,8 octet

 Etre vérifiable

2. Le bytecode est exécuté par un logiciel : la Machine Virtuelle 3. La machine virtuelle est dépendante de la plate-forme: pour chaque plate forme (Windows, linux, etc.) il existe une machine virtuelle.

A.Hammache

7

Comment il fonctionne …!

A.Hammache

8

Exemple Bytecode 0: iconst_2 1: istore_1 2: iload_1 3: sipush 1000 Programme source java 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 31: getstatic #84; Compilation 34: iload_1 (javac) 35: invokevirtual #85; 38: iinc 1, 1 41: goto 2 A.Hammache 44: return

9

Les indispensables (JDK / JRE)  Le JRE= Java Runtime Environment Il contient :

 la machine virtuelle  Un ensemble de classes de base regroupées en packages

 Interface utilisateur, conteneurs, gestion des threads, réseau, etc.

Le JDK = Java Development Kit Il contient :

 JRE  Des exécutables (outils) : compilateur (javac) , débuggeur, (jdb) générateur de documentation (javadoc), etc.

A.Hammache

10

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, etc.

Classes de base

 Date, Chaîne de caractères

RMI

 Remote Method Invocation

A.Hammache

11

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

A.Hammache

12

Les environnements de développement Ils offrent des fonctions avancées : • • • • • •

Éditeur évolué (couleur, autocorrection, présentation, etc.) Assistance syntaxique Générateur de code Débugage Environnement d’exécution …

A.Hammache

13

Constitution d’un programme java Un programme Java est composé d’un ensemble de classes Les classes sont regroupées en package Une classe regroupe un ensemble d’attributs et de méthodes

Package n Package 1 Classe 1 Attributs Méthodes

A.Hammache

14

Premier programme en Java public class Exemple{ public static void main (String argv[]) { System.out.println("MON PREMIER PROGRAMME JAVA "); } }  public class Exemple: 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  System.out.println("MON PREMIER PROGRAMME JAVA "): méthode d’affichage dans une fenêtre console A.Hammache

15

É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= Exemple.java). 2. Compilation: produire le bytecode à partir de fichier source (.java) en utilisant la commande javac  javac Exemple.java Génération d’un fichier bytecode Exemple.class 3. Exécution: exécuter le bytecode obtenu en utilisant la commande java  java Exemple • ne pas mettre .class pour l’exécution. A.Hammache

16

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 (types): variables, constantes, etc.  Les expressions qui permettent de manipuler les données: affectation, comparaison, etc.  Les instructions pour construire les algorithmes: test, boucle, etc.  Les objets

A.Hammache

17

Les commentaires Les commentaires: Ils permettent de clarifier le code. Ils ne sont pas pris en compte par le compilateur. Il existe trois types de commentaires en Java : Type de commentaire

Exemple

commentaire abrégé

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

commentaire multi lignes

commentaire de documentation automatique

/** * commentaire de la méthode * @param val la valeur à traiter * @since 1.0 * @return Rien * @deprecated Utiliser la nouvelle méthode XXX */

A.Hammache

18

Les types de données en Java Types arithmétiques Entiers

Réels

byte

8 bits

signé

(-128 , 127)

short

16 bits

signé

(-32768 , 32767)

int

32 bits

signé

(-2147483648 , 2147483647)

long

64 bits

signé

(-9223372036854775808, 9223372036854775807)

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é UNICODE

Type booléen boolean 1 bit

deux valeurs possibles : true ou false A.Hammache

19

Les identificateurs A chaque objet, classe, variable, constante est associé un nom (identificateur). L’identificateur 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 ($). Java est sensible à la casse: ( id <>iD) Un identificateur ne peut pas appartenir à la liste des mots réservés du langage Java . Cette liste est la suivante: 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 this

import

private

synchronized

while

A.Hammache

class false instanceof

protected

20

Déclaration de variables  La Syntaxe de la déclaration: type

maVariable;

// maVariable est de type entier

 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éen int X,Y,Z ; // Il est possible de déclarer plusieurs variables de même type en les

// séparant par une virgule.

 La syntaxe de la déclaration et de l’initialisation d’une variable : type

maVariable=valeur; // Déclaration et initialisation de la variable

 Exemples boolean result = true; char capitalC = ‘C’; byte b = 100; short s = 10000; int i = 100000; int decVal = 26; // Le nombre 26 en décimal int octVal = 032; // Le nombre 26 en octal int hexVal = 0x1a; // Le nombre 26 en hexadécimal double d1 = 123.4; double d2 = 1.234e2; // notation scientifique float f1 = 123.4f; A.Hammache

21

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 CONSTANTE [ = valeur ]; // CONSTANTE est une constante  Exemple: final int C=20; // Constante entière ayant une valeur 20 C= 15; // erreur de compilation

A.Hammache

22

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érateurs sont:     

L’opérateur d’affectation Les opérateurs arithmétiques Les opérateurs unaires Les opérateurs de comparaison Les opérateurs logiques

A.Hammache

23

L’opérateur d’affectation L’opérateur « = »  permet d’affecter la valeur de l’expression qui est à droite à la variable qui est à gauche.  Exemple 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; } }

A.Hammache

24

Les opérateurs arithmétiques S’appliquent sur les types entiers ou réels +, - , * , / , % (modulo) , += , -= , *= , /=  Exemples int x, y, z; y = 2; z = 3; x x y y

= y * z ; += 2 ; //x = x / 4 ; =x % 2 ;

//x vaut 6 vaut 8 (équivalente à x=x+2;) //y vaut 2 //y vaut 0

En terme de performance, il est recommandé d’utiliser la notation raccourcie (+=,*=,-=) A.Hammache

25

Les opérateurs unaires S’appliquent sur un seul opérande de type entier ou réel: +,-, ++,- Exemple

int x, y; x = 3; y = -x ; y = ++x ; y = x-- ;

//y vaut -3 //y vaut 4, x vaut 4 //y vaut 4, x vaut 3

La pré et la post-incrémentation diminuent le nombre de lignes de bytecode générées y = ++x ; y = x-- ;

 x=x+1; y=x;  y=x; x=x-1; A.Hammache

26

Les opérateurs de comparaison S’appliquent sur des entiers, réels et booléens: == (é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  Exemple { boolean droitDeVote; int age; ………… droitDeVote = (age >= 18) ; } A.Hammache

27

Les opérateurs logiques S’appliquent au type boolean  ! (NON logique) , && (ET logique) , II (OU logique)

Retournent un type boolean Exemple boolean x = true; boolean y = false; System.out.println("x && y = " + (x&&y)); System.out.println("x || y = " + (x||y) ); System.out.println("!(x && y) = " + !(x && y));

A.Hammache

Résultat x && y = false x || y = true !(x && y) = true

28

Les opérateurs bit à bit Fonctionnent sur les représentations binaires des nombres  & (ET bit à bit ) , I (OU inclusif ), ^ (OU exclusif)

Retournent une valeur numérique Exemple int x = 60; // 60 = 0011 1100 int y = 13; // 13 = 0000 1101 int z = 0; z = x & y; // 12 = 0000 1100 System.out.println("x & y = " + z ); z = x | y; // 61 = 0011 1101 System.out.println("x | y = " + z ); z = x ^ y; // 49 = 0011 0001 System.out.println("x ^ y = " + z );

Résultat x & y = 12 x | y = 61 x ^ y = 49

Un opérateur spécial : l’opérateur (?:) la syntaxe: expression1? expression2: expression3; expression1 est évaluée en premier (retourne une valeur booléenne). Si sa valeur est true, expression2 est calculée et renvoyée, sinon expression3 est calculée renvoyée.  Exemple int x = 3, y = 4, max; max = (x > y)? x: y; //Ceci revient à dire que max=y;

  Dans ce code, max reçoit la valeur de x ou de y, selon que x est supérieur à y ou non. A.Hammache

La priorité des opérateurs  Java définit la priorité des 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 (affectation)

A.Hammache

^ & | && || = , += , -=

31

Les conversions de type (1/2) Il y a 4 contextes possibles de conversion:  Conversion explicite (cast)  Conversion implicite: o Affectation o Appel de méthode o Promotion arithmétique

Certaines conversions (cast) provoquent une perte de valeur  float en int, int en short, short en byte

Le type boolean ne peut pas être converti en entier A.Hammache

32

Les conversions de type (2/2) Exemple 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) f = i / (double)j; // conversion explicite // promotion arithmétique de i

A.Hammache

de j

33

Les Instructions 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 instructions sont :  Les tests conditionnels (if else, switch case);  Les boucles (for, while);  Les débranchements (break, continue).

A.Hammache

34

Test conditionnel (if …else)  la syntaxe : if (condition) { Bloc d’instruction } else { Bloc d’instruction }

 condition est de type booléen  le if ne nécessite pas de then  si Bloc d’instruction a une seule instruction alors pas besoin des {}

Exemple class Test { public static void main (String args[]) { int compteur ; lire(compteur); if (compteur == 0) System.out.println("Début de la partie"); else if (compteur ==10) System.out.println("Fin de la partie"); else if ((compteur >0) &&(compteur<10)) System.out.println("Partie en cours"); } } A.Hammache

35

Test conditionnel Switch …case Syntaxe : switch (expression) { case constante1 : instr11; instr12; break; case constante2 : ... default : ...

Exemple class Test { public static void main (String args[]) {

}  Le « switch » ne s’applique qu’au type entier ou caractère.

}

char c = (char)System.in.read(); switch(c) { case ‘o’ : System.out.println("Oui"); break; case ‘n’ : System.out.println("Non"); break; default : System.out.println("Mauvaise réponse"); break; } }

 Si un 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 A.Hammache

36

Boucles while  Syntaxe

Exemple

while ( condition) { ... // code à exécuter dans la boucle }

Condition est de type booléen. Le code est exécuté tant que la condition est vraie. Si avant l'instruction while, la condition est fausse, alors le code de la boucle ne sera jamais exécuté.

 Autre syntaxe do { ... // code à exécuter dans la boucle } while ( condition)

Dans ce cas le code est exécuté au moins une fois.

class Test { public static void main (String args[]) { int n = 10; int somme = 0; int i= 1; while( i<=n){ somme += i; i++; } System.out.println(" la somme des "+n+" premiers entiers est : "+somme); }

Résultat: la somme des 10 premiers entiers est : 55 A.Hammache

Boucle for  Syntaxe :

Exemple

for ( initialisation; condition; modification) { ... }

Condition est de type booléen  Dans l'initialisation, on peut déclarer une variable qui servira d'index et qui sera dans ce cas locale à la boucle Il est possible d'inclure plusieurs traitements dans l'initialisation et la modification de la boucle: chacun des traitements doit être séparé par une virgule.

class Test { public static void main(String args[]) { int n = 10; int somme = 0; for(int i=1; i<=n; ++i) somme += i;

}

System.out.println(" la somme des "+n+" premiers entiers est : "+somme); }

Résultat : la somme des 10 premiers entiers est : 55 A.Hammache

38

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 de deux points qui définit le début d'une instruction. A.Hammache

39

Exemples int x = 0; while (x < 6){ System.out.println(x); x++; if (x == 4) break; } Résultat: 0 1 2 3

for ( int x = 0 ; x < 6 ; x++) { if(x == 4) continue; //revient au début de la //boucle avec x=5 System.out.println(x); }

Résultat: 0 1 2 3 5 A.Hammache

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 multidimensionnels sont des tableaux de tableaux. A.Hammache

41

Les tableaux : déclaration Les tableaux peuvent être déclarés avec les syntaxes suivantes : type [] nom ; type nom [];  Exemples :

int table[]; double [] d1,d2 ;

A.Hammache

42

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; A.Hammache

43

Les 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 base).  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). String n’est pas un type primitif. Il s’agit d’une classe du paquetage java.lang.

A.Hammache

44

TP Avant de programmer en Java Le JDK de Oracle(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.

A.Hammache

45

Lecture des données à partir du clavier Utilisation de la classe Scanner définie dans le package «java.util» Etapes : 1. 2.

Inclure le package : import java.util.*; Créer un objet de la classe scanner (sc) : Scanner sc=new Scanner(System.in); 3. Lire les données avec la méthode (nextXXX)  lire un entier : int a = sc.nextInt();  lire un double : double d=sc.nextDouble();

A.Hammache

46

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 } } A.Hammache

47

Question ?

A.Hammache

48