1 Programmation Avant-propos. 2 Programmation / Avant-propos  Programmation Ensemble des activités permettant l'écriture de programmes informatiques.

Présentation au sujet: "1 Programmation Avant-propos. 2 Programmation / Avant-propos  Programmation Ensemble des activités permettant l'écriture de programmes informatiques."— Transcription de la présentation:

1 1 Programmation Avant-propos

2 2 Programmation / Avant-propos  Programmation Ensemble des activités permettant l'écriture de programmes informatiques On parle de Conception logicielle

3 3 Programmation / Avant-propos  De l'architecture machine aux langages de haut niveaux Un ordinateur est une machine permettant de traiter des informations selon des procédures Il est doté, entre autre, d'un processeur d'une mémoire centrale qui interagissent CPUMémoire

4 4 Programmation / Avant-propos  Les procédures Une procédure est une opération à effectuer  Algorithme Un algorithme est une suite de procédures à réaliser Procédure 1 Procédure 2 Procédure 3 Procédure 4 Procédure 5 Procédure n Algorithme

5 5 Programmation / Avant-propos  Implémentation La mise en œuvre d'un algorithme consiste en la traduction en langage de programmation On parle d'implémentation  Langage de bas / haut niveau Principe: Une recette de cuisine doit être plus ou moins détaillée en fonction de l'expérience du cuisinier

6 6 Programmation / Avant-propos  Langage de bas / haut niveau (suite) Le niveau de détail d'un algorithme est proportionnel à celui du langage de programmation: Utilisation d'un langage de bas niveau: Nécessité de détailler l'algorithme Utilisation d'un langage de haut niveau: Possibilité de moins détailler l'algorithme

7 7 Programmation / Avant-propos  Exemple concret: La soustraction Acquis du module I1: Je connais la méthode permettant de réaliser  l'addition (a+b)  la complémentation à 2 (cplt 2 (x)) Algorithmique a – b = a + (-b) = a + cplt 2 (b) J'ai maintenant la méthode permettant de réaliser la soustraction

8 8 Programmation / Avant-propos Acquis du module I2: J'ai à disposition:  un composant réalisant l'addition d'un registre 8 bits (add)  un composant réalisant la complémentation à 2 (C2) Implémentation (langage bas niveau) add C2 abc minus

9 9 Programmation / Avant-propos Acquis (futurs !) du module I3 J'ai à disposition une fonction permettant de réaliser:  l'addition (a+b)  la négation (-b) Implémentation (langage haut niveau)  c=a+(-b)

10 10 Programmation / Avant-propos Processeur stocker a stocker b réaliser -b addition (a,t) stocker dans c Algorithme Programme langage humainement compréhensible Mémoire langage compréhensible par la machine traduction (compilation) 2 a -4 t 4 b stocker dans t -2 c opérations entrée/sortie procédures

11 11 Programmation / Avant-propos  De l'algorithmique au programme L'algorithmique est l'étape essentielle (80%) de la conception d'un programme MAIS L'algorithme n'est pas directement compréhensible par la machine…

12 12 Programmation / Avant-propos Le langage de programmation:  est une traduction de l'algorithme dans un langage fini et non ambiguë  offre un certain nombre de procédures Le compilateur  est l'outil permettant de traduire le langage de programmation en langage machine  dépend du langage utilisé  est fortement lié à l'architecture de la machine

13 13 Programmation / Avant-propos  Synthèse stocker a stocker b réaliser -b addition (a,t) stocker dans c Algorithme stocker dans t traduction en langage de programmation Programme traduction (compilation) read a read b t=-b c=a+t Code source Intervention du programmeur Utilisation de logiciel de compilation

14 14 Java Introduction

15 15 Java  Rappel sur l'étape de la compilation Compilation:  Rôle: passage du langage de programmation vers un langage machine  Conséquences: Lors de la compilation, des liens sont établis entre: le programme, le système d'exploitation (Microsoft Windows, Linux, MacOS, …) l'architecture de la machine (Intel, Risc, Motorola, …)

16 16 Java Conséquences (suite)  Un tel programme ne peut s'exécuter que sur la plateforme pour laquelle il a été compilé !  Nécessité de re-compiler pour les différentes plateformes ciblées  Même sur une même architecture machine, un programme est lié au système d'exploitation

17 17 Langages compilés et limitations Compilation Architecture 1 Risc 6000 Unix Exécutable Architecture 4 Intel xScale PalmOS Exécutable Architecture 3 Mac G5 MacOS Exécutable Architecture 2 Intel x86 LinuxWindows Exécutable fichier source du programme Légende Indépendant de la machine Dépendant de la machine

18 18 Portabilité  Notion de portabilité Capacité d'un programme à être indépendant du système d'exploitation et de l'architecture machine Architecture 1 Risc 6000 Unix Programme portable Architecture 2 Intel x86 LinuxWindows Impossible !

19 19 Java et la portabilité  Solution proposée: Construire une machine virtuelle: joue le rôle de plateforme virtuelle dépendante de l'architecture machine et du SE opère un langage machine virtuel indépendant de l'architecture réelle et du SE réel Machine virtuelle SE / Architecture Programme Java Code source Java

20 20 Pseudo-Langage interprété Schéma du principe Java fichier source du programme Compilation Programme Java Architecture 1 Risc 6000 Unix Machine virtuelle Architecture 2 Intel x86 LinuxWindows Machine virtuelle Architecture 3 Mac G5 MacOS Machine virtuelle Architecture 4 Intel xScale PalmOS Machine virtuelle Programme portable !

21 21 Conséquences  Avantage Portabilité  Le programme ne nécessite pas de recompilation pour un autre couple SE/LM  Inconvénient Vitesse d'exécution  La machine virtuelle interprète le pseudo langage pour exécuter des instructions machines

22 22 Java Présentation

23 23 Java  Java est un langage de programmation orienté objet  La plateforme Java: Définition: Une plateforme est l'environnement matériel et logiciel dans lequel s'exécute un programme Composition:  La JVM (Java Virtual Machine) Eléments du langage natif  La J-API (Java Application Programming Interface) Eléments supplémentaires Plateforme matérielle API monProgramme.java JVM

24 24 Java: Fiche signalétique  Propriétaire:Sun Microsystem  Naissance:fin 1995  Signe particulier: fortes compétences dans la créations d'applications client-serveur et Internet Langage multi-plateforme Domaines d'applications multiple:  bureautique,  graphique,  multimédia,  base de données,  …

25 25 Java Techniques de base

26 26 Compilation et exécution sous Java  Mon premier programme: HelloWorld !  Remarques Le nom de la classe principale est le nom du fichier Une seule public class par fichier Attention à la casse ! Hello.java public class Hello { public static void main (String [] args) { System.out.println("Bonjour"); }

27 27 Invocation d’un programme  Une classe est exécutable QUE si elle contient une méthode main()  Invocation: java Hello (Attention: pas d’extension !)

28 28 Compilation et exécution sous Java C:\Hello>dir Le volume dans le lecteur C n'a pas de nom. Le numéro de série du volume est 78C3-E609 Répertoire de C:\Hello 08/03/2005 14:12. 08/03/2005 14:12.. 08/03/2005 14:06 142 Hello.java 1 fichier(s) 142 octets 2 Rép(s) 5 089 857 536 octets libres C:\Hello> C:\Hello>dir Le volume dans le lecteur C n'a pas de nom. Le numéro de série du volume est 78C3-E609 Répertoire de C:\Hello 08/03/2005 14:12. 08/03/2005 14:12.. 08/03/2005 14:06 142 Hello.java 1 fichier(s) 142 octets 2 Rép(s) 5 089 771 520 octets libres C:\Hello>javac Hello.java C:\Hello> Répertoire de C:\Hello 08/03/2005 14:12. 08/03/2005 14:12.. 08/03/2005 14:06 142 Hello.java 1 fichier(s) 142 octets 2 Rép(s) 5 089 771 520 octets libres C:\Hello>javac Hello.java C:\Hello>dir Le volume dans le lecteur C n'a pas de nom. Le numéro de série du volume est 78C3-E609 Répertoire de C:\Hello 08/03/2005 14:12. 08/03/2005 14:12.. 08/03/2005 14:12 417 Hello.class 08/03/2005 14:06 142 Hello.java 2 fichier(s) 559 octets 2 Rép(s) 5 089 771 520 octets libres C:\Hello> 08/03/2005 14:12. 08/03/2005 14:12.. 08/03/2005 14:06 142 Hello.java 1 fichier(s) 142 octets 2 Rép(s) 5 089 771 520 octets libres C:\Hello>javac Hello.java C:\Hello>dir Le volume dans le lecteur C n'a pas de nom. Le numéro de série du volume est 78C3-E609 Répertoire de C:\Hello 08/03/2005 14:12. 08/03/2005 14:12.. 08/03/2005 14:12 417 Hello.class 08/03/2005 14:06 142 Hello.java 2 fichier(s) 559 octets 2 Rép(s) 5 089 771 520 octets libres C:\Hello>java Hello Bonjour C:\Hello>

29 29 Applet  Pré requis Il faut créer une page HTML  Visualisation Automatique, après chargement par un navigateur Attention: la JRE est requise ! test applet Java

30 30 Java Éléments de base, Types natifs

31 31 Blocs et instructions  Instruction Une instruction se termine par ; Peut tenir sur plusieurs lignes  Exemple char v = 'c'; char u = 'd' ;

32 32 Blocs et instructions  Bloc Un bloc de code est délimité par { et } Contient un ensemble d'instructions { … instructions … }

33 33 Types natifs  Java est un langage de manipulation d'objets Cependant, tout n'est pas objet ! Il existe un nombre fini de types natifs La taille mémoire des types natifs est constant quelque soit la plateforme !

34 34 Types natifs  boolean description type booléen intervalle de variation false ou true espace mémoire 1 bit exemple: boolean var = true;

35 35 Types natifs  boolean (suite) Autre exemples boolean v1 = 2;// ERREUR boolean v2 = 'a';// ERREUR Remarque pas de conversion possible vers d'autre types

36 36 Types natifs  byte description type octet signé intervalle de variation [-128 ; +127] espace mémoire 8 bits exemple byte var = 0x12;

37 37 Types natifs  byte (suite) Autres exemples byte v1 = 12;// initialisation base 10 byte v2 = 'a';// initialisation caractère byte v3 = "toto";// ERREUR

38 38 Types natifs  char description caractère unicode intervalle de variation [0 (\u0000); 65535 (\uFFFF)] espace mémoire 16 bits exemple char var = 'a';

39 39 Types natifs  char (suite) Autre exemples char v1 = 12; char v2 = "ab";// ERREUR char v3 = 0x12; char v4 = \u0014; Remarque entouré de cotes simples

40 40 Types natifs  short description entier court signé intervalle de variation [-32768 ; 32767 ] espace mémoire 16 bits exemple short var = 1452;

41 41 Types natifs  int description entier signé intervalle de variation [-2147483648 ; 2147483647 ] espace mémoire 32 bits exemple: int v = -123;

42 42 Types natifs  long description entier long intervalle de variation [-9223372036854775808 ; 9223372036854775807 ] espace mémoire 64 bits exemple: long v = 1524454;

43 43 Types natifs  float description virgule flottante simple précision intervalle de variation [1.401e-045 ; 3.40282e+038 ] espace mémoire 32 bits exemple float v = 123.45;

44 44 Types natifs  double description virgule flottante double précision intervalle de variation [2.22507e-308 ; 1.79769e+308 ] espace mémoire 64 bits exemple double v = 123.45;

45 45 Attention  L'affectation numérique peut générer des ambiguïtés !  Problématique: Quel est le type des variables suivantes: 'a'char 0x12int 123int 123.45double ?

46 46 Attention  Problématique (suite) long v = 922337203685477508;// ERREUR car la valeur numérique est de type int erreur de type 'out of range' car la borne sup. du type int ( v >> 2147483647 )  Effet pervers long v = 152454*2243*100; L'évaluation numérique de v est 34195432200 (<BS(long)) Or, l'instructionSystem.out.println("v=" + v); Affichev=-164306168

47 47 Valeur numériques  Question Comment créer une valeur numérique de type long ??  Suffixe numérique type long:nombrel ou nombreL type float:nombref ou nombreF type double:nombred ou nombreD

48 48 Valeur numériques  Exemples: long v = 922337203685477508L; long v = 152454L*2243*100; System.out.println("v=" + v); Affichev=34195432200

49 49 Les variables  Une variable possède: un identifiant un type une valeur

50 50 Les variables  Déclaration simple type identifiant ;  Déclaration multiple type identifiant_1, identifiant_2(, …) ;  Déclaration affectation simple type identifiant = valeur;  Déclaration affectation multiple type identifiant_1 = valeur_1, identifiant_2 = valeur_2(, …) ;

51 51 Les variables  Déclaration / Définition type identifiant = valeur;  Remarques: valeur doit être de même type que type OU être le type de la variable doit être 'plus grand' que celui de la valeur une variable devrait toujours être initialisée

52 52 Les variables  Exemples: int v = 12.3;// ERREUR double v = 12;// OK short u = 12345;// OK short u = 123456;// ERREUR (conv. int -> short)

53 53 Visibilité  La porté d'une variable: commence à l'endroit où elle est déclarée est limité au bloc où elle est déclarée  Exemple { int c; } portée de c

54 54 Visibilité  Quels sont les cas corrects ? int c; { int c; } char c; { int c; } { int c; } char c; FAUX OK

55 55 Java Structures de contrôle

56 56 Les branchements conditionnels  A quoi ça sert ? Effectuer un traitement spécifique exécuté uniquement lorsqu'une condition est respectée Condition … suite du programme… Traitement conditionné oui non

57 57 Les branchements conditionnels  Exemple Afficher la valeur absolue d'un nombre Lire (a) Si (a < 0), Alors a = - a; Fin Si Afficher ( a )

58 58 Les branchements conditionnels  en algorithmique Si expression_conditionnelle, Alors traitement FinSi

59 59 Les branchements conditionnels  en Java if (a < 0) { a = -a; } System.out.println(a);

60 60 Les branchements conditionnels  et sinon ??? Gestion d'un traitement alternatif Condition … suite du programme… Traitement conditionné oui non Traitement conditionné

61 61 Les branchements conditionnels  Exemple: Trouver le maximum de deux nombres ?? Formalisme mathématique max  2  (a,b)  max(a,b) ??

62 62 Les branchements conditionnels  en algorithmique Si expression_conditionnelle, Alors traitement_si_oui Sinon traitement_si_non FinSi

63 63 Les branchements conditionnels  en Java if (a > b) { System.out.println(a); } else { System.out.println(b); }

64 64 Les boucles  A quoi ça sert ? Écriture simplifiée d'actions répétitives Pourquoi faire n fois la même chose Alors qu'on peut faire 1 fois les n choses ? condition de bouclage vérifiée ensemble d'instructions sortie départ OUI NON

65 65 Les boucles  Comment ça marche ? Initialiser l'état de départ: inventaire des hypothèses de départ: initialisation Construire le corps de la boucle: inventaire des instructions répétitives Condition d'arrêt condition pour sortir de la boucle

66 66 Les boucles: Un exemple  Afficher les nombres de 0 à 10  Afficher 0  Afficher 1  Afficher 2  Afficher 3  Afficher 4  Afficher 5  Afficher 6  Afficher 7  Afficher 8  Afficher 9  Afficher 10

67 67 Les boucles: Un autre exemple  Afficher les nombres de 0 à 100  Afficher 0  Afficher 1  Afficher 2  Afficher 3  Afficher 4  Afficher 5  Afficher 6  Afficher 7  Afficher 8  Afficher 9  Afficher 10 ……  Je suis entrain de faire toujours la même chose !!!

68 68 Les boucles: Analyse  Quel est le point commun ?  Afficher 0  Afficher 1  Afficher 2  Afficher 3  Afficher 4  Afficher 5  Afficher 6  Afficher 7  Afficher 8  Afficher 9  Afficher 10 Le point commun est Afficher (i) i part de 0 jusqu'à 10 inclus

69 69 Les boucles: Analyse  Quel est le 1 er état souhaité ? Afficher 0  Quel est le dernier état souhaité ? Afficher 10  Que se passe t'il entre le 1 er et le dernier état ??

70 70 Les boucles: Analyse  Besoin de stocker l'état  Utilisation d'une variable d'état Exemple: variable entière i Etat initiali=0 Etat finali=10  et entre deux états successifs ? i est incrémenté de 1 i=i+1

71 71 Les boucles  Condition d'arrêt Remarque: Trouver la condition pour sortir, c'est aussi difficile de  trouver la condition pour rentrer dans le corps de boucle ? Afficher ( i ) i = i + 1 Etat final Initialisation (état de départ) i = 0 OUI NON Quel est la condition qui permet de rejoindre l'état final ? (Condition d'arrêt) Corps de boucle

72 72 Les boucles  Condition de bouclage ? L'état initial est i=0, On doit rejoindre l'état final à i=10 (inclus !!) ? Afficher ( i ) i = i + 1 Etat final Initialisation (état de départ) i = 0 OUI NON Corps de boucle i ≤ 10

73 73 Les boucles  … et en algo ? i=0 TantQue i≤10, Faire Afficher (i) i = i + 1 FinTantQue Initialisation Condition d'arrêt Corps de boucle

74 74 Les boucles  Finalement, en Java… TantQuewhile i=0; while (i<=10) { System.out.println(i); i = i + 1; }

75 75 Java Les opérateurs

76 76 Les opérateurs  A quoi ça sert: manipuler séparer comparer stocker des valeurs

77 77 Les opérateurs  Les opérateurs peuvent être classifié: selon le nombre d'opérandes:  opérateurs unaires  opérateurs binaires  opérateurs ternaires selon leur champ d'action:  opérateurs arithmétiques  opérateurs de comparaisons  opérateurs booléens  opérateurs d'affectation  opérateurs bit à bit

78 78 Les opérateurs  Priorité des opérateurs A chaque opérateur est associé un niveau de priorité Sert à indiquer l'ordre dans lequel s'effectue les opérations Exemple: 2 + 3 * 4 = 20 ou 14 ??

79 79 Les opérateurs  Priorité des opérateurs Que dire d'une expression utilisant plusieurs fois le même opérateur ? Exemple: 2*3*4 ?? Évaluation de gauche à droite

80 80 Java Les opérateurs arithmétiques

81 81 Les opérateurs arithmétiques  Caractéristique Soit {E,F,G}  {boolean, byte, short, int, long, float, double} Un opérateur défini une application de loi externe: E x F  G où G = E ou G = F

82 82 Les opérateurs arithmétiques  Signe positif catégorie:unaire opérateur:+ priorité:1 exemples: +a +(a-b) +7

83 83 Les opérateurs arithmétiques  Signe négatif catégorie:unaire opérateur:- priorité:1 exemples: -a -(a-b) -7

84 84 Les opérateurs arithmétiques  Multiplication catégorie:binaire opérateur:* priorité:2 exemples: 5 * 4 12.7*(-8.35) 5*2.6 a*2

85 85 Les opérateurs arithmétiques  Division catégorie:binaire opérateur:/ priorité:2 exemples: 5 / 4 12.7 / 2 a/2.

86 86 Les opérateurs arithmétiques  Reste catégorie:binaire opérateur:% priorité:2 exemples: 5 % 2 3 % a x % y

87 87 Les opérateurs arithmétiques  Addition catégorie:binaire opérateur:+ priorité:3 exemples: 5 + 4 2.7 + (-8.3) 5 + 2.6 a + 2

88 88 Les opérateurs arithmétiques  Soustraction catégorie:binaire opérateur:- priorité:3 exemples: 5 - 4 12.7-(-8.35) 5-2.6 a-2

89 89 Les opérateurs arithmétiques  Exemples d'utilisation int x = 5, y; float a, b = 5; y = x / 2; y = b / 2; y = b / 2.; a = b / 2; a = x / 2; a = x / 2f; Résultat x = 5 y = ??? Commentaire 2 variables déclarées Résultat a = ??? b = 5.0 Commentaire 2 variables déclarées Résultat y = 2 Commentaire opérandes de type int  résultat de type int Résultat ERREUR DE CONVERSION Commentaire conversion automatique impossible (de float vers int) Résultat ERREUR DE CONVERSION Commentaire conversion automatique impossible (de float vers int) Résultat a=2.5 Commentaire opérations sur 2 float  résultat de type float Résultat a=2.0 Commentaire opérations sur 2 int  résultat de type int conversion auto. int -> float Résultat a=2.5 Commentaire opération (int, float)  résultat de type float

90 90 Les opérateurs arithmétiques  Remarque le cas "y = b / 2" engendre une erreur Rappels: y de type int b de type float Solutions: y = (int)b/2;// transtypage de b en int avant division y = (int)(b/2);// transtypage du résultat de la division

91 91 Les opérateurs arithmétiques  Incrémentation catégorie:unaire (post ou pré fixée) opérateur:++ priorité:1 exemples: a++; ++a;

92 92 Les opérateurs arithmétiques  Décrémentation catégorie:unaire (post ou pré fixée) opérateur:-- priorité:1 exemples: a--; --a;

93 93 Les opérateurs arithmétiques  Post-incrémentation:k++; Effet: la valeur de k est utilisée dans l'instruction, puis incrémentée de 1 Exemple int k = 5, n; n = k++; n=5 int k = 5, n; n = k++ - k; n=-1, k=6

94 94 Les opérateurs arithmétiques  Pré-incrémentation:++k; Effet: la valeur de k est d'abord augmentée de 1 puis utilisée dans l'instruction, int k = 5, n; n = k++ + ++k; n=12, k=7 int k = 5, n; n = ++k; n=6

95 95 Les opérateurs arithmétiques  Post-décrémentation:k--; Effet: la valeur de k est utilisée dans l'instruction, puis décrémentée de 1 Exemple int k = 5, n; n = k--; n=5 int k = 5, n; n = k-- - k; n=1, k=4

96 96 Les opérateurs arithmétiques  Pré-décrémentation:++k; Effet: la valeur de k est d'abord diminuée de 1 puis utilisée dans l'instruction, int k = 5, n; n = k-- - --k; n=7, k=3 int k = 5, n; n = --k; n=4, k = 4

97 97 Les opérateurs arithmétiques  Résumé OpérateurPrioritéActionExemples +1signe positif+4 -1signe négatif-4 ++1incrémentation++a, a++ --1décrémentation--a, a-- *2multiplicationa*2 /2divisiona/2 %2restea%2 +3additiona+2 -3soustractiona-2

98 98 Java Les opérateurs de comparaison

99 99 Les opérateurs de comparaison  Un opérateur de comparaison renvoie un résultat de type boolean (false ou true)

100 100 Les opérateurs de comparaison  Infériorité stricte catégorie:binaire opérateur:< priorité:5 exemples: a<5 3<2 2<b

101 101 Les opérateurs de comparaison  Supériorité stricte catégorie:binaire opérateur:> priorité:5 exemples: a>5 3>2 2>b

102 102 Les opérateurs de comparaison  Infériorité large (ou égalité) catégorie:binaire opérateur:<= priorité:5 exemples: a<=5 3<=2 2<=b

103 103 Les opérateurs de comparaison  Supériorité large catégorie:binaire opérateur:>= priorité:5 exemples: a>=5 3>=2 2>=b

104 104 Les opérateurs de comparaison  Egalité catégorie:binaire opérateur:== priorité:6 exemples: a==5 3==2 2==b x+1==2

105 105 Les opérateurs de comparaison  Différence (non égalité) catégorie:binaire opérateur:!= priorité:6 exemples: a!=5 3!=2 2!=b x+1!=2

106 106 Les opérateurs de comparaison  Résumé OpérateurPrioritéActionExemples <5strictement inférieur4<3 <=5inférieur ou égal2<=a >5strictement supérieur3>4 >=5supérieur ou égala>=2 ==6égalitéa==2 !=6différencea!=2

107 107 Java Opérateurs booléens

108 108 Opérateurs booléens  Opérateurs classique de l'algèbre de Boole Le résultat est booléen (true ou false)

109 109 Les opérateurs booléens  ET catégorie:binaire opérateur:& priorité:7 exemple: a & b

110 110 Les opérateurs booléens  OU catégorie:binaire opérateur:| priorité:9 exemple: a | b

111 111 Les opérateurs booléens  NON catégorie:unaire opérateur:! priorité:1 exemples: !a

112 112 Les opérateurs booléens  OU-EXCLUSIF catégorie:binaire opérateur:^ priorité:7 exemples: a^b

113 113 Les opérateurs booléens  OU-optimisé Postulat: Si A est vrai, alors (A ou x) est vrai, quelque soit x(x  {faux, vrai}) Si A est faux, alors Le résultat dépend exclusivement de x Conséquence: optimisation de l'évaluation de l'expression

114 114 Les opérateurs booléens  ET-optimisé Postulat: Si A est faux, alors (A et x) est faux, quelque soit x(x  {faux, vrai}) Si A est vrai, alors Le résultat dépend exclusivement de x Conséquence: optimisation de l'évaluation de l'expression

115 115 Les opérateurs booléens  Résumé OpérateurPrioritéActionExemples !1NON booléen!(a<3) &7ET booléen(a<b) & (c<d) |9OU booléen(a>0) | (c<d) &&10ET booléen optimisé(a>0) && (3*a < 20) ||11OU booléen optimisé(a 20)

116 116 Java Les opérateurs bits à bits

117 117 Les opérateurs bits à bits  Domaine de définition Les opérateurs bits level agissent exclusivement sur des opérandes de type entier ou caractère: short, int, long, char, byte  Permettent de manipuler directement les bits du mot mémoire associé à la donnée

118 118 Les opérateurs bits à bits  Complément catégorie:unaire opérateur:~ priorité:1 exemples: 5// 0000000000000000000000000101 ~5// 11111111111111111111111111111010

119 119 Les opérateurs bits à bits  Et catégorie:binaire opérateur:& priorité: exemples: a=4;// 000000000000000000100 b=3;// 000000000000000000011 r=a&b;// 000000000000000000000

120 120 Les opérateurs bits à bits  Ou catégorie:binaire opérateur:| priorité: exemples: a=4;// 000000000000000000100 b=3;// 000000000000000000011 r=a|b;// 000000000000000000111

121 121 Les opérateurs bits à bits  décalage à gauche catégorie:binaire opérateur:<< priorité:4 exemples: 5 << 2// 10100

122 122 Les opérateurs bits à bits  décalage signé à droite catégorie:binaire opérateur:>> priorité:4 exemples: 5 >> 2 // 00000000000000000000000000000001 -5 >> 0 // 11111111111111111111111111111011 -5 >> 1 // 11111111111111111111111111111101 -5 >> 2 // 11111111111111111111111111111110

123 123 Les opérateurs bits à bits  décalage non signé à droite catégorie:binaire opérateur:>>> priorité:4 exemples: 5 >>> 2 // 00000000000000000000000000000001 -5 >>> 0 // 11111111111111111111111111111011 -5 >>> 1 // 01111111111111111111111111111101 -5 >>> 2 // 00111111111111111111111111111110

124 124 Les opérateurs bits à bits  Résumé OpérateurPrioritéActionExemples ~1Complément à 1~a ~5 &Eta & 5 |Oua | 5 ^Ou exclusifa ^ 5 <<4décalage à gauchei<<1 5<<i >>4décalage signé à droitei>>1 5>>i >>>4décalage non signé à droite i>>>1 5>>>i

125 125 Java Les opérateurs d'affectation

126 126 Les opérateurs d'affectation  L'affectation Le symbole d'affectation est = Exemple: x = y; signifie que le contenu de la variable y est recopié dans l'espace mémoire associé à la variable x Attention: x est obligatoirement une variable

127 127 Les opérateurs d'affectation  Exemple int a, b = 56 ; a = (b = 12)+8 ; // b prend une nouvelle valeur dans l'expression a = b = c = d =8 ; // affectation multiple

128 128 Les opérateurs d'affectation  Raccourcis Soit op un opérateur parmi l'ensemble {+, -, *, /, %, >, >>>, &, |, ^} Alors l'instruction x op= y; est un raccourci de x = x op y;

129 129 Les opérateurs d'affectation  Exemples int a, b = 56 ; a = -8 ; a += b ; // équivalent à : a = a + b b *= 3 ; // équivalent à : b = b * 3

130 130 Les opérateurs d'affectation  Raccourcis et optimisation de code L'instructiontab[f(a)] = tab[f(a)] + x; a pour raccourcitab[f(a)] += x; L'appel à la fonction f est effectué 1 fois au lieu de 2

131 131 Java Les tableaux

132 132 Les tableaux  Définition Un tableau est un ensemble contiguë d’éléments de même type  Déclaration: type [] variable; où type est un type natif ou un objet variable est le nom associé à la cellule contenant l’adresse mémoire où est stocké le premier élément du tableau

133 133 Les tableaux  Stockage d’un tableau en mémoire Mémoire 2 a -4 4 b 3-210 0x1353 tab 0x1353 int a=2, b=4; int [] tab = {-4, 3, -2, 1, 0};

134 134 Les tableaux  Accès L’accès aux éléments du tableaux est réalisé à l’aide de l’opérateur [] Exemple: Mémoire 2 a -4 4 b 3-210 0x1353 tab 0x1353 int a=2, b=4; int [] tab = {-4, 3, -2, 1, 0}; int v = tab[2]; -2 v

135 135 Les tableaux  L’opérateur d’accès Que réalise exactement l’opérateur [ ] ? Il agit sur le nom de la variable associé au tableau contenu: l’adresse du premier élément L’opérateur contient un index (tab[index]) index est le décalage en octet modulo la taille de la donnée à partir de l’adresse du premier élément -43-210 0x1353 tab 0x1353 tab[2] équivaut à 0x1353 + 2 * (taille d’un entier) soit 0x1353 + 2*4 = 0x135b

136 136 Les tableaux  Exemples de construction de tableaux: long [] t1 = {1L, 4L, 2L}; String [] t2 = {"iut", "rt", "chalons"};  Tableaux de tableaux Exemple de création de tableaux 2D: int [][] M1 = {{1,2}, {3,4}}; int [][] M2 = {{1},{2,3},{4,5,6}};

137 137 Les tableaux  int [][] M = {{1},{2,3},{4,5,6}}; Mémoire 0x21190x05f20x25ba 1 0x1353 M 45623 0x21190x05f20x25ba

138 138 Les tableaux  Opérateur d'accès int [][] M = {{1},{2,3},{4,5,6}}; M[0][0] = 1 M[1][0] = 2 M[2][1] = 5  Attention M[1][2] n'existe pas !!! Toute tentative d'accès à un élément inexistant déclenche une erreur à l'exécution !!

139 139 Java Classe Méthodes de classes Méthodes d'instance

140 140 Nombre Individu Les classes  Définition Une classe est un regroupement de fonctionnalités liées à un même concept Une classe est une structure, ou ensemble construit, qui constitue la base de l'objet  Exemple: Additionner Avancer Reculer Tourner Soustraire Multiplier Diviser

141 141 Les classes  Sur l'exemple du concept d'Individu Un Individu peut: Avancer (en avant) Paramètres liés:Position de départ ? Direction ? Résultat:Nouvelle position

142 142 Les classes Tourner Paramètres liés:Direction initiale ? Gauche ou Droite ? Résultat:Nouvelle direction

143 143 Les classes  Synthèse Individu Avancer (Position p, Direction d) => Position Tourner (Direction d, Sens s) => Direction

144 144 Les classes  Synthèse Avancer et Tourner possède suffisamment d'information pour pouvoir s'exécuter dans le contexte d'Individu: Avancer et Tourner sont des méthodes de classes  En Java: Ces méthodes commencent par le mot clé static

145 145 De la classe à l'objet  Le concept d'Individu définit l'ensemble des actions propres à n'importe quel Individu… Supposons que Toto soit un Individu Toto sait alors:  Avancer  Tourner Car il appartient à la famille des Individu !!!

146 146 De la classe à l'objet  Quel est la différence entre Toto et Individu ?? Individu est la classe Toto est un Individu personnalisé: Toto est un Individu avec une information d'état Toto est une instance de la classe Individu

147 147 De la classe à l'objet  Résumé intermédiaire: Une classe est une définition d'un concept Elle peut comporter: des attributs propres au concept des méthodes de classes (static) représentant des actions non propres à une instance particulière Exemple: Tous les bipèdes humanoïdes possèdent 2 jambes ! BipedeHumanoide Attributs de classe static final int nb_jambes=2; Méthodes de classe static int NbJambes();

148 148 De la classe à l'objet  Résumé intermédiaire (suite) On peut personnaliser une classe en créant une instance de classe (opérateur new) Exemple: Un bipède humanoïde peut posséder un nom, qui diffère selon les cas BipedeHumanoide Attributs de classe int nb_jambes; Méthodes de classe int NbJambes(); Méthodes d'instance void setNom(String n) String getNom() Attributs String nom;

149 149 De la classe à l'objet  Concepts d'attributs Qu'est-ce qui caractérise une instance d'Individu ? Un Individu possède: Une position Une direction Ce sont ses attributs

150 150 De la classe à l'objet  Concepts d'attributs (suite) Attention: Peut-on initialiser les attributs: pour tout Individu ?? ou pour un Individu particulier ?? Réponse: un Individu particulier

151 151 De la classe à l'objet  Résumé: un Individu possède une position et une direction Toto connaît sa position et sa direction  Rappels Nous avions défini les méthodes de classes suivantes: Avancer (Position p, Direction d) => Position Tourner (Direction d, Sens s) => Direction Or: Les paramètres p et d sont liés à l'Individu Ce sont ses attributs !

152 152 De la classe à l'objet  Finalement, si l'Individu connaît sa position et sa direction (informations d'état), certains paramètres des méthodes Avancer et Tourner deviennent inutiles: Avancer (Position p, Direction d) => Position Tourner (Direction d, Sens s) => Direction Les méthodes de classes deviennent des méthodes d'instance: Avancer () Tourner(Sens s)

153 153 De la classe à l'objet  Démonstration: Toto est dans l'état suivant:  position:(i,j)  direction:Nord Demandons à Toto de tourner à gauche Appel à la méthode d'instance de l'objet Toto: On écrit: Toto.Tourner(Gauche) Nouvel état:  position:(i,j)  direction:Ouest

154 154  Direction d = Individu.Tourner (Nord, Gauche)

155 155 De la classe à l'objet  Comment faire naître Toto ? Toto est un Individu particulier Pour le faire naître, il faut faire appel au constructeur d'Individu  Rôle du constructeur Il permet de créer une instance de la classe pour définir un nouvel objet Il doit renseigner les attributs de la classe pour lui donner un état stable Il est appelé par l'instruction new

156 156 De la classe à l'objet  En Java: Individu Toto = new Individu (i, j, Nord) Permet de créer un objet, instance de la classe Individu caractérisé par sa position (i,j) et sa direction (Nord)

157 157 De la classe à l'objet  Attention !!! On ne peut utiliser un objet QUE lorsqu'il est construit ! Exemple: Individu toto; toto.Tourner(Gauche);// NON VALIDE CAR toto n'est pas construit // Construction d'un Individu toto = new Individu (1,4,Nord); toto.Tourner(Gauche);// OK

158 158 Synthèse Individu Individu est une classe générique (sans état) Toto Toto est une instance de la classe Individu (avec un état propre) i=2 j=5 dir=nord Titi Titi est une instance de la classe Individu (avec un état propre) i=3 j=2 dir=est Individu Toto = new Individu (2, 5, nord)Individu Titi = new Individu (3, 2, est)

159 159 Remarque importante  Soit l'objet suivant: Point xy Point p1, p2, p3; Point 12 p1 = new Point (1,2); Espace mémoireEspace des variablesProgramme p1 p2 p2 = new Point (3,4); Point 34 p3 = p2; p3 p2 = p1;

160 160 Formalisme de déclaration de méthode  Une déclaration de méthode est constituée: d'une entête comportant les différents paramètres et leurs types respectifs ainsi que le type de retour d'un corps de fonction comportant l'ensemble des instructions à exécuter

161 161 Cas des méthodes de classes  Diagramme synoptique static type du résultat nom de la fonction ( ) liste de paramètres { instructions } Type du résultat: une méthode peut générer un résultat d'un type quelconque (natif ou objet). Ce type est obligatoire. Une méthode ne génère pas forcément de résultat: le type de retour est void Nom de la fonction: identificateur, de préférence au formalisme Java: le nom devrait être une action, première lettre de chaque mot en majuscule, sauf pour le premier mot Liste des paramètres Semblable à la déclaration des variables (sans initialisation) Peut-être vide

162 162 Cas des méthodes de classes  Attention: Une méthode de classe ne peut appeler qu'une méthode de classe. En aucun cas une méthode de classe ne peut appeler une méthode d'instance !!

163 163 Cas des méthodes d'instance  Diagramme synoptique type du résultat nom de la fonction ( ) liste de paramètres { instructions } Signification semblable aux méthodes de classe

164 164 Retour de fonction  Le mot clef réservé return demande à une fonction de se terminer en retournant un résultat: return [expression];  L'évaluation de l'expression doit procurer un type compatible avec celui énoncé dans la définition de la fonction  L'appel à l'instruction return; (sans expression) permet de sortir d'une fonction ne procurant pas de résultat

165 165 Type de retour  La méthode retourne un résultat Définition: static int f (int v) { int y=3 + v; return y; } Appel: int r = f(12);

166 166 Type de retour  La méthode ne retourne pas de résultat type de retour: void Définition: static void afficherNombre (int v) { System.out.println("Nombre: " + v); } ou bien static void afficherNombre (int v) { System.out.println("Nombre: " + v); return; } Appel: afficherNombre(3);

167 167 Méthode de classe où d'instance ??  La différence est stratégique: Méthode non spécifique à l'état de l'objet:  Méthode de classe(mot clef:static) Méthode modifiant l'état de l'objet (de l'instance)  Méthode d'instance(aucun mot clef)

168 168 Quelques exemples  Attributs d'instance, méthodes d'instance public class Individu { enum orientation { nord, sud, est, ouest }; enum sens { gauche, droite }; int i, j;// attributs d'instance orientation dir;// " " public void tourner (sens s) { switch (dir) { case nord: dir = s == sens.gauche ? ouest : est; break; case sud: … } Modification de l'état par mise à jour de la variable dir

169 169 Quelques exemples  Attributs statiques, méthodes de classes statiques public class Math { static final double Pi = 3.141592653569; static double cos (double x) { … } Définition d'une constante Fonction trigonométrique appartenant au concept Math mais n'influe pas sur l'état

170 170 Constructeur  Définition Un constructeur est une méthode spécifique permettant: de créer une nouvelle instance d'objet de l'initialisant pour le placer dans un état cohérent  Exemple: public class Point { int x, y;// coordonnées 2D du points Point (int a, int b) { x=a; y=b; } Fichier Point.java public class Essai { public static void main(String [] args) { Point p; p = new Point (1,2); } Fichier Essai.java

171 171 Transmission de paramètre  Exposé du problème: Soit la méthode de classe suivante: public static void afficher (double v) { System.out.println("v=" + v); } Quels sont les appels valides ? afficher (1.4d); afficher ('a'); afficher (1.4f); afficher ("coucou");

172 172 Compatibilité de type  La compatibilité de type s'effectue dans le sens: Qui peut le plus peut le moins Soit techniquement: Un type de n bits acceptera un type de p bits, où p<=n long (64 bits) byte (8 bits) char (16 bits) short (16 bits) int (32 bits) double (64 bits) float (32 bits)

173 173 Compatibilité de type  Exemple: public static void afficher (long v) { System.out.println("v=" + v); } Que produit l'appel suivant: afficher('a'); Réponse: v=97

174 174 Transmission de paramètres  Deux méthodes de transmission de paramètre: par valeur  La fonction appelée reçoit une copie locale du paramètre  Toute modification n'influe pas sur la variable de la fonction appelante par référence  La fonction appelée reçoit une référence directe sur le paramètre de la fonction appelante  Toute modification est directement répercutée sur la variable de la fonction appelante Mode de transmission utilisé par Java

175 175 Transmission de paramètres  Exemple public class Essai { public static void f1 (int x) { x=2; } public static void main(String [] args) { int i=1; System.out.println("i=" + i); f1(i); System.out.println("i=" + i); } Résultat: i=1

176 176 Transmission de paramètres public static void main(String [] args) { int i=1; System.out.println("i=" + i); f1(i); System.out.println("i=" + i); } public static void f1 (int i) { i=12; } copie de i

177 177 Transmission de paramètres  Transmission d'instance d'objet Soit l'objet suivant public class Point { int x, y;// coordonnées 2D du points Point (int a, int b) { x=a; y=b; } public static void initPoint (Point p) { p.x=0; p.y=0; } Fichier Point.java

178 178 Transmission de paramètres Espace des variablesEspace mémoire // Ficher Point.java public class Point { public int x, y; Point (int a, int b) { x=a; y=b; } public static void initPoint (Point p) { p.x=0; p.y=0; } // Ficher Main.java public class Main { public static void main (String[] args){ Point t = new Point(1,2); System.out.println("t.x=" + t.x); Point.initPoint(t); System.out.println("t.x=" + t.x); } Point 12 t p 00

179 179 Surcharge  Deux méthodes membres qui appartiennent à la même classe portent un identificateur identique (même nom de fonction) possèdent des paramètres différents sont des méthodes surchargées

180 180 Surcharge  Exemple: Un point géométrique peut être défini par: ses coordonnées données explicitement Point (int i, int j) { x=i; y=j; } un autre Point Point (Point p) { x=p.x; y=p.y; }

181 181 Surcharge  Exemple (suite): des coordonnées par défaut Point () { x=0; y=0; } Soit: Point (int i, int j) Point (Point p) Point () 3 méthodes portant des signatures différentes

182 182 Surcharge  Attention: Pas de différenciation sur le type de retour Exemple: int f (int v) et double f (int v) ne sont pas différentiable

183 183 Tableaux (le retour)  Rappel Déclaration initialisée d'un tableau: int [] tab = { 1, 2, 3};  Si la taille n'est pas connue à la compilation, alors: int [] tab; Attention: Seule la référence nommée tab à un tableau non construit est réalisée !!  Construction lors de l'exécution: tab = new int [n];

184 184 Tableaux (le retour)  Propriétés particulières: int [] tab = new int [30];  Propriété de longueur: System.out.println("nb elt dans tab: " + tab.length);  Synthèse: Affichage des éléments d'un tableau d'entier de taille quelconque: static void afficheTableau (int [] tab) { int i=0; while (i < tab.length) { System.out.println(tab[i++]); } }

185 185 Java La sécurité d'accès liées aux attributs et aux méthodes visibilité mots clef public / protected / private

186 186 Intérêt  Exemple de l'individu Supposons qu'un objet Individu soit crée Il possède: une position : Point pos; une direction: direction dir;

187 187 Intérêt  Exemple (suite): L'individu est crée selon un cahier des charges Entre autre, la position est relative au labyrinthe ! pos.x >= 0 ET pos.x = 0 ET pos.y <= hauteur Un Individu possède ses propres fonctions d'évolution: Avancer, Tourner, …

188 188 Intérêt  Exemple (suite): Un usage malheureux de l'objet place l'individu dans une position incohérente: Individu Toto = new Individu (2,3,Nord); … Toto.pos.x = -4;// !!! Toto.Avancer();// Problème… A qui incombe la faute ??

189 189 Attributs/Fonctions à usage publique/privée  Le créateur de l'objet doit laisser ou non l'accès aux attributs / fonctions membres ! Exemple: class Point { private int x, y; public Point () { } private void modificationInterne() { } } Variable à usage interne Accès interdit depuis l'extérieur de la classe Un constructeur accessible depuis l'extérieur Méthode à usage interne à la classe: ne doit pas être appelée à l'extérieur

190 190 Attributs/Fonctions à usage protégé  Un attribut ou une méthode déclarée protected est accessible uniquement par les classes déclarée dans le même fichier  Exemple: // Fichier: A.java public class A { public int x; protected int y; private int z; … } class B { public void f (A p) { int x = p.x;// CORRECT int y = p.y;// CORRECT int z = p.z;// INCORRECT }

191 191 Classe publique / privée  Classe publique Rappels: Une classe publique est enregistrée dans un fichier portant le nom de la classe Un fichier ne contient qu'une classe publique Usage du mot-clé public Une classe publique est accessible par tout fichier important la classe: import package.MaClasse;

192 192 Classe publique / privée  Classe privée Une classe privée peut être déclarée dans un fichier contenant une ou aucune classe publique Une telle classe n'est visible que par les classes du même package Attention: pas de mot-clé spécifique !!! private class A {// INCORRECT... }

193 193 Sécurité et visibilité  Exemples // Fichier: A.java package P; public class A { public A () { } class B { public B () { A a = new A(); // CORRECT } // Fichier: C.java package P; public class C { public C() { A a = new A(); // CORRECT B b = new B(); // CORRECT } // Fichier: D.java // Pas de package import P.*; public class D { public D () { A a = new A(); // CORRECT B b = new B(); // INCORRECT C c = new C(); // CORRECT }

194 194 Java Packaging

195 195 Les packages  Principe Les classes fournies avec le JDK (Java Development Kit) ou par d'autres sources sont rangées dans des packages Un package est comparable à un groupe rassemblant des classes par thème

196 196 Les packages  mot-clé import Dans un programme, il est nécessaire d'indiquer les classes qui seront utilisées Ces clauses d'importation se place en début de fichier: Exemples: // importer une classe sans package import nomClasse; // importer une classe d'un package import nomPackage.nomClasse; // importer toutes les classes d'un package import nomPackage.*;

197 197 Les packages  mot-clé import (suite) La classe nomClasse peut correspondre soit à un fichier source nomClasse.java, un fichier compilé nomClasse.class, dans lequel est définie la classe public à importer

198 198 Les packages  Un package représente une arborescence indiquant au compilateur quel chemin il faut emprunter pour retrouver la classe. Exemple: si le package est java.util, -> recherche dans le répertoire java/util (ou java\util sous Windows)  La variable d'environnement CLASSPATH défini la position des packages

199 199 Les packages  Limitation L'importation d'un package se limite à ses classes propres !  Pas d'importation des classes utilisées par le package !  Nécessité d'importer chacun d'entre eux

200 200 Les packages Synthèse  import nomPackage.nomClasse; nomPackage

201 201 Les packages Synthèse  import nomPackage.*;

202 202 Les packages Synthèse  import nomPackage.*; Ces objets ne sont plus accessibles

203 203 Les packages Création  mot-clé package permet de créer une bibliothèque rassemble des objets d'un même thème défini un groupe d'outils pour une utilisation dans plusieurs projet  Exemple: // toujours en amont du fichier source package monPackage;

204 204 Les packages Utilisation Package outils package outils; public class Classe1 { } class Classe2 { } package outils; class Classe3 { Classe1 var1; Classe2 var2; // … } Classe1.java Classe3.java import outils.Classe1; public class Classe4 { Classe1 var1; // … } Classe4.java

205 205 Java Fin du module I3