Meriem BENHADDI FSTG Marrakech JAVA Meriem BENHADDI FSTG Marrakech

Plan Syntaxe et éléments de base de Java Variables et types Affectations Opérations Tests, conditions et boucles Tableaux Manipulation des chaines de caractères

Syntaxe et les éléments de base de JAVA

Les règles de base 1- JAVA est sensible à la casse 2- Les blocs de code sont encadrés par des accolades. 3- Chaque instruction se termine par un caractère ';' (point virgule). 4- Une instruction peut tenir sur plusieurs lignes : Exemple : char code = 'D'; Les commentaires 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 ;.

Les commentaires Types de commentaires : Type de commentaires Exemple commentaire abrégé // commentaire sur une seule ligne int N=1; // déclaration du compteur commentaire multiligne /* commentaires ligne 1 commentaires ligne 2 */

Les identificateurs Chaque objet, classe, programme ou variable 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 dollars.

Les identificateurs Un identificateur ne peut pas appartenir à la liste des mots réservé du langage Java : abstract assert boolean break byte case Catch char class const continue default do double else extends false final finally float for goto if implements import Instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient true try void volatile while

Les types primitifs Les types primitifs : les entiers Type Désignation Valeur par défaut Valeur byte octet Longueur : 8 bits -128 a 127 short Entier court Longueur : 16 bits −32768 à 32767 int Entier Longueur : 32 bits −2147483648 à 2147483647 Long Entier long Longueur : 64 bits −9223372036854775808 à 9223372036854775807

Les types primitifs Les types primitifs : les flottants Type Désignation Valeur par défaut Valeur float Nombre décimal Longueur : 32 bits 0.0 -1.401e−045 à +3.40282e+038 double Nombre décimal long Longueur : 64 bits - 2.22507e−308 à + 1.79769e+308

Les types primitifs Les types primitifs : le caractère \b Désignation Valeur par défaut Valeur char Caractère unicode Longueur : 16 bits \u000 \u0000 à \uFFFF Caractères disposant d’une notation spéciale : \b Retour arrière \t Tabulation horizontale \n Saut de ligne \f Saut de page \r Retour chariot \’’ Inactivation du caractère ’’ \’ Inactivation du caractère ’ \\ Inactivation du caractère \

Les types primitifs Les types primitifs : le boolean Type Désignation Valeur par défaut Valeur Boolean valeur logique : true ou false Longueur : 8 bits false True ou False

La déclaration et l’utilisation de variables La déclaration de variables : Une variable est un emplacement en mémoire doté : D’un nom : ce nom ne doit pas comprendre d’espace, ni correspondre à un mot clé du langage. D’un type : il caractérise la nature des données. D’une valeur : elle est nécessairement compatible avec le type de la variable et remplace une éventuelle valeur affectée au préalable à la variable La déclaration d'une variable : Elle doit nécessairement contenir un nom et un type de données, la valeur n’étant pas obligatoire, car le compilateur attribut à chaque variable une valeur par défaut en accord avec son type au moment de la création. Une variable est utilisable dans le bloc ou elle est définie.

La déclaration et l’utilisation de variables Exemple : long nombre; int compteur; String chaine;

La déclaration et l’utilisation de variables Il est possible de définir plusieurs variables de même type en séparant chacune d'elles par une virgule : déclaration simultanée. Exemple : int jour, mois, annee ;

La déclaration et l’utilisation de variables Il est possible en une seule instruction de faire la déclaration et l'affectation d'une valeur à une variable ou plusieurs variables. Exemple : int i=3 , j=4 ; //Déclaration et initialisation au lieu de : int i, j; //Déclaration i=3; //Initialisation j=4; //Initialisation

Le format des types élémentaires Le format des nombres décimaux : Les types float et double stockent des nombres flottants : Les suffixes f, F, d, D sont utilisés pour préciser le type float ou double. Exemple : float pi = 3.141f; float f = +.1f , d = 1e10F; double v = 3d; double n = 6; Les suffixes d et D ne sont pas obligatoires.

Le format des types élémentaires Par défaut un littéral est de type double : pour définir un float. Exemple : double w = 1.1; Attention : float pi = 3.141; // erreur à la compilation Correction : il faut le suffixer par la lettre f ou F. float pi = 3.141f; Ou float pi = 3.141F;

Le format des types élémentaires Le format des caractères : Un caractère est codé sur 16 bites. Il doit être entouré par des apostrophes. Une valeur de type char peut être considérée comme un entier non négatif de 0 à 65535. La conversion implicite par affectation est possible.

Le format des types élémentaires Exemple : /* test sur les caractères */ class test1 { public static void main (String args[]) { char code = 'D'; int index = code; //Conversion implicite de char en int System.out.println("index = " + index); } Le résultat est : 68.

Les constantes Une constante est déclarée avec le mot clé final : final int n = 20; La valeur de n restera inchangée pendant toute l’exécution du programme. n = n + 5; // erreur : n a été déclarée final Vous n’êtes pas obligé d’initialiser une variable déclarée final lors de sa déclaration. final int n ; ……. n = 15 ;

Les opérations

Opérations arithmétiques Opérateurs binaires Symbole Opération + Addition - Soustraction / Division * Multiplication % Reste d’une division (Modulo) Opérateurs Unaires Symbole Opération - Opposé + Identité

Opérations arithmétiques Les opérateurs binaires ne sont définis que pour des opérandes de même type : le résultat est de même type que celui des opérandes. Mais on peut également les utiliser avec des opérandes de types différents : Lors d'une opération sur des opérandes de type différents, le compilateur détermine le type du résultat en prenant le type le plus précis des opérandes, et effectue une conversion implicite.

Opérations arithmétiques Les conversions d’ajustement de type ou conversions implicites se font suivant une hiérarchie qui permet de ne pas dénaturer la valeur initiale : int  long  float  double Exemple : n est int, p est long, x est float

Opérations arithmétiques Promotion numérique : Les opérateurs numériques ne sont pas définis pour les types byte, char et short, alors java prévoit de les convertir d’abord en int avant de procéder à l’opération. Exemple : p1, p2 et p3 sont de type short, et x est de type float.

Exemple : float a = 13.12f; double b = 11.11; double c; c = a * b; C doit être de type double

Opérations arithmétiques Priorité des opérateurs : Lorsque plusieurs opérateurs arithmétiques apparaissent dans une même expression, il faut savoir dans quel ordre ils sont mis en jeu : Les opérateurs unaires + et – ont la priorité la plus élevée Ensuite, on trouve à un même niveau, les opérateurs *, / et % Au dernier niveau, on trouve les opérateurs binaires + et -. En cas de priorités identiques, les calculs s’effectuent de gauche à droite. Si on veut modifier l’ordre d’exécution des opérateurs, il faut utiliser les parenthèses.

Opérations arithmétiques Priorité des opérateurs : Exemple : a + b * c b * c  res + a a * b + c % d a * bres1, c % dres2, res1 + res2 - c % d -c  res % d - a + c % d - a res1, c % d res2, res1 + res2 - a / - b + c -a res1, -bres2, res1/res2res3 +c - a / - (b + c) b + cres1, - a res2, -res1res3, res2/res3

Opérateurs de comparaison Les opérateurs de comparaison permettent de comparer deux expressions, le résultat est de type boolean. Symbole Comparaison == Egalité (A ne pas confendre avec l’affectation par =) != Différent > Supérieur strictement >= Supérieur ou égal < Inférieur strictement <= Inférieur ou égal Exemple : class logiq{ public static void main (String[] args){ int a=10,b=3; boolean resultat; resultat=a > b; System.out.println(“resultat =” + resultat); }}

Opérateurs de comparaison Priorité des opérateurs de comparaison : Les quatre opérateurs <,<=, >, >= sont de même priorité. Les opérateurs == et != ont également la même priorité mais inférieure à celle des quatre premiers. Les opérateurs de comparaison sont moins prioritaires que les opérateurs arithmétiques. Exemple : x + y < a + 2 x + yres1, a + 2res2, res1<res2

Opérations logiques Les opérations logiques prennent en argument 1 ou 2 nombres booléens. Symbole Opération ! Inverse la valeur logique (true devient false et inversement) | OU logique inclusif(vaut true si au moins l’un des opérandes vaut true) & Et logique (vaut true si ses deux opérandes valent true) || Comme |, mais le deuxieme opérande n’est évalué que si le premier vaut false && Comme &, mais le deuxieme opérande n’est évalué que si le premier vaut true ^ OU logique exclusif (vaut true si une et une seule des opérandes vaut true, false dans le cas contraire)

Opérations logiques Priorité des opérateurs logiques : L’opérateur ! a une priorité supérieure Ensuite, on trouve l’opérateur & Au troisième niveau, on trouve ^ Au quatrième niveau, on trouve | Au cinquième niveau, l’opérateur && Au sixième niveau, l’opérateur || L’opérateur ! est plus prioritaire que les opérateurs arithmétiques et de comparaison. Le reste des opérateurs logiques sont moins prioritaires que les opérateurs arithmétiques ou de comparaison.

Opérateur d’incrémentation et de décrémentation signification Expression équivalente ++ A++ A=A+1 -- A-- A=A-1

Formes condensées associant opération et affectation Ce sont des opérateurs qui permettent de simplifier l'écriture d'une opération d'affectation associée à un opérateur mathématique : Opérateur signification Expression équivalente += A+=B A=A+B -= A-=B A=A-B *= A*=B A=A*B /= A/=B A=A/B %= A%=B A=A%B &= A&=B A=A&B |= A|=B A=A|B ^= A^=B A=A^B

L’opérateur d’affectation L’opérateur d’affectation est le seul à avoir une associativité de droite à gauche : Exemple : i = j = 5 est évalué comme suit : L’expression j = 5 est la première à être évaluée. Ensuite on affecte 5 à i. L’opérateur d’affectation est le moins prioritaire.

Conversion par affectation Exemple : float x ; int p ; x = p + 5; va conduire à convertir le résultat (p + 5) en float. La conversion par affectation suit les hiérarchies : byte shortintlongfloatdouble charintlongfloatdouble

Opérateur de cast On peut forcer la conversion d’une expression quelconque dans un autre type, à l’aide d’un opérateur appelé cast. Exemple : p et n sont de type int, l’expression: (double) (n/p) Aura comme valeur celle de l’expression entière n/p convertie en double. Le résultat de la division est ensuite converti et non pas l’inverse Mais, (double) n/p donnerai le résultat de n convertie en double, ensuite divisé par p.

Opérateur de cast Exemple : x = x + y ;  erreur à la compilation : short x= 5 , y = 15; x = x + y ;  erreur à la compilation : found : int required : short ^ 1 error

Opérateur de cast Solution : il est nécessaire, pour régler le problème, d'utiliser une conversion explicite ou cast. Exemple : x = (short) ( x + y );

Opérateur de cast Deuxième Exemple avec l’opération de cast : Class prog_division { Public static void main (String[] args){ Int a =10; Int b=3; Float resultat1,resultat2; Resultat1=a/b; Resultat2=a/(float)b; System.out.println(“Resultat 1=“+resultat1); System.out.println(“Resultat 2=“+resultat2); }} Affichage : Resultat1=3.0 Resultat2=3.33333

Opérateur de cast Type de conversion Nature de conversion Non dégradante Float->double entier->flottant Dégradante Double->float Flottant->entier

Complément sur les opérateurs L’incrémentation et la décrémentation : Les opérateurs d'incrémentation et de décrémentation sont : n++ , ++n , n−− , −−n Si l'opérateur est placé avant la variable (préfixé), la modification de la valeur est immédiate sinon la modification n'a lieu qu'à l'issu de l'exécution de la ligne d'instruction (postfixé)

Les opérations arithmétiques L’incrémentation et la décrémentation : Suite Exemple : System.out.println(x++); // est équivalent à System.out.println(x); x = x + 1; System.out.println(++x); // est équivalent à x = x + 1; System.out.println(x);

Les structures de contrôle

Les structures de contrôles Java propose un ensemble d'instructions qui permettent de d'organiser et de structurer les traitements. 1- les tests 2- Les boucles 3- Les branchements conditionnels 4- Les débranchements

Les structures de contrôles Les tests : l’instruction if if (condition) { traitements; } } else { } else if (condition) {

Les structures de contrôles Les boucles : 1- while 2-do while 3- for

Les structures de contrôles while : while ( boolean ) { ... // code a exécuter dans la boucle } Le code est exécuté tant que le booléen est vrai. Si avant l'instruction while, le booléen est faux, alors le code de la boucle ne sera jamais exécuté. Il ne faut pas mettre de ; après la condition sinon le corps de la boucle ne sera jamais exécuté

Les structures de contrôles Do while : do { ... } while ( boolean ) Cette boucle est au moins exécuté une fois quelque soit la valeur du booléen.

Les structures de contrôles For : for ( initialisation; condition; modification) { ... } Exemples : for (i = 0 ; i < 10; i++ ) { ....} for (int i = 0 ; i < 10; i++ ) { ....}

Les structures de contrôles 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. Exemple : for (i = 0 , j = 0 ; i * j < 1000;i++ , j+= 2) {....}

Les structures de contrôles Les branchements conditionnels : Switch : swith (expression) { case constante1 : instr11; instr12; break; case constante2 : ... default : }

Les structures de contrôles Les débranchements : break : permet de quitter immédiatement une boucle ou un branchement. continue : s'utilise dans une boucle pour passer directement à l'itération suivante.

Les tableaux

La déclaration des tableaux : Les tableaux La déclaration des tableaux : Java permet de placer les crochets après ou avant le nom du tableau dans la déclaration. Exemple : 1- int tableau[] = new int[50]; // déclaration et allocation 2- int[] tableau = new int[50]; // déclaration et allocation 3- int tab[]; // déclaration tab = new int[50]; //allocation

La déclaration des tableaux : Suite Les tableaux La déclaration des tableaux : Suite Pour déclarer les tableaux à plusieurs dimensions il faut déclarer un tableau de tableau. Exemple : float tableau[][] = new float[10][5];

Les tableaux L'initialisation explicite d'un tableau : Exemple : 1- int tableau[5] = {10,20,30,40,50}; 2- int tableau[3][2] = {{5,1},{6,2},{7,3}};

Les tableaux L'initialisation explicite d'un tableau : La taille du tableau n'est pas obligatoire si le tableau est initialisé à sa création. Exemple : int tableau[] = {10,20,30,40,50};

Les tableaux L'initialisation explicite d'un tableau : Le nombre d'élément de chaque lignes peut ne pas être identique : Exemple : int[][] tabEntiers = {{1,2,3,4,5,6}, {1,2,3,4}, {1,2,3,4,5,6,7,8,9}};

Les tableaux Le parcours d'un tableau : Exemple : for (int i = 0; i < tableau.length ; i ++) { ... } La variable length retourne le nombre d'éléments du tableau.

Les tableaux Le parcours d'un tableau : Pour passer un tableau à une méthode, il suffit de déclarer les paramètres dans l'en tête de la méthode. Exemple : public void printArray(String texte[]){ ... }

Le parcours d'un tableau : Les tableaux Le parcours d'un tableau : Un accès aux éléments d'un tableau qui dépasse sa capacité , lève une exception du type : java.lang.arrayIndexOutOfBoundsException

Manipulation de chaînes de caractères

Manipulation de chaînes de caractères La définition d'une chaine : Exemple : String texte = ‘‘bonjour’’ ;

Manipulation de chaînes de caractères Les caractères spéciaux dans les chaines Caractères spéciaux Affichage \’ Apostrophe \" Guillemet \\ Anti slash \t Tabulation \b Retour arrière \r Retour chariot \f Saut de page \n Saut de ligne

Manipulation de chaînes de caractères Quelques fonctions : String texte = ‘‘ Java Java Java ’’; texte = texte.replace('a','o');

Manipulation de chaînes de caractères L'addition de chaines : L'opérateur arithmétique + permet de concaténer plusieurs chaînes. Il est possible d'utiliser l'opérateur += Exemple : String texte = ‘‘ ’’; texte += ‘‘ Hello ’’; texte += ‘‘ World3 ’’;

Manipulation de chaînes de caractères La comparaison de deux chaînes Il faut utiliser la méthode equals() Exemple : String texte1 = ‘‘ texte 1 ’’; String texte2 = ‘‘ texte 2 ’’; if ( texte1.equals(texte2) )...

Manipulation de chaînes de caractères La détermination de la longueur d'une chaine La méthode length() permet de déterminer la longueur d'une chaine. Exemple : String texte = ‘‘ texte ’’; int longueur = texte.length();

Manipulation de chaînes de caractères La modification de la casse d'une chaine Les méthodes Java toUpperCase() et toLowerCase() permettent respectivement d'obtenir une chaine tout en majuscule ou tout en minuscule. Exemple : String texte = ‘‘ texte ’’; String textemaj = texte.toUpperCase();

Les conversions de types Conversions des types String et Integer La conversion d'un entier int en chaine de caractère String Exemple : int i = 10; String montexte = new String(); montexte =montexte.valueOf(i);

Les conversions de types Conversions des types String et Integer La conversion d'une chaine de caractères String en entier int Exemple : String montexte = new String(‘‘10 ’’); Integer monnombre=new Integer(montexte); int i = monnombre.intValue(); //convertion d'Integer en int

Les paramètres les deux notations suivantes sont acceptables : String argv[] String[] argv Pour donner des paramètres lors de l’exécution d’un programme test : Java test chaine1 chaine2 Pour récupérer et utiliser un paramètre saisi lors de l’exécution du programme : String param1=argv[0]; String param2=argv[1];

Lecture des entrées clavier La lecture au clavier est réalisée à l’aide de la classe « Scanner ». //Ceci importe la classe Scanner du package java.util import java.util.Scanner; Scanner sc = new Scanner(System.in); System.out.println("Veuillez saisir un mot :"); String str = sc.nextLine(); System.out.println("Vous avez saisi : " + str);

Pour saisir un entier : System.out.println("Veuillez saisir un entier:"); int i = sc.nextInt(); double d = sc.nextDouble(); long l = sc.nextLong(); byte b = sc.nextByte();