I21 Algorithmique et programmation II David Gross-Amblard, Joël Savelli IEM-uB 2009-2010 - GFDL 1.2 v2.2.

Présentation au sujet: "I21 Algorithmique et programmation II David Gross-Amblard, Joël Savelli IEM-uB 2009-2010 - GFDL 1.2 v2.2."— Transcription de la présentation:

1 I21 Algorithmique et programmation II David Gross-Amblard, Joël Savelli IEM-uB 2009-2010 - GFDL 1.2 v2.2

2 i21 - 2008-2009 IEM / uB GFDL 1.2 2 L'équipe enseignante ● David Gross-Amblard (responsable, CM-TD-TP) – MdC Le2i : Bases de données (théorie / sécurité / application Web/musique) – Contact : david.gross-amblard sur u-bourgogne.fr, sujet [i21] – Avec modération ● Damien Leprovost (TP), doctorant (bases de données, Web social) ● Joël Savelli (TD-TP) – MdC Le2i : Modélisation ● Hakim Soussi (TP), doctorant (modélisation)

3 i21 - 2008-2009 IEM / uB GFDL 1.2 3 Déroulement du semestre ● Cours : questions libres à la fin (même si pas de rapport avec le cours du jour) ● Vous devez : – Lire votre mél université régulièrement (et le renvoyer vers votre compte favori, votre téléphone,...) – Consultez le site du cours régulièrement http://ufrsciencestech.u-bourgogne.fr/~gadavid

4 i21 - 2008-2009 IEM / uB GFDL 1.2 4 Déroulement ● Début des Tds : semaine prochaine ● Début des Tps : semaine suivante ● 1 partiel / 1 examen final (coef. 1,5 et 3) – Attention : sans document ● 1 projet commun avec i22 (coef 1,5 pour i21) – Modalités précises (rapport/pré-rapport/ soutenance/etc.) – Binômes sauf exception – Commencer dès la distribution du sujet !

5 i21 - 2008-2009 IEM / uB GFDL 1.2 5 Plan du cours I.Rappels sur Java – types, instructions, procédures, fonctions... II.Programmation par objets - classe, composition, héritage, initiation à la modélisation III.Algorithmes (et types de données) – algorithmes de tri, algorithmes récursifs, listes, piles, files, arbres

6 i21 - 2008-2009 IEM / uB GFDL 1.2 6 Dosage de l'effort scalaires impératif récursif affectation déclaration séquence test boucle entrée/sortie syntaxe sémantique expression état valeur exécution fonction procédure référence paramètre passage par valeur Passage par référence Effet de bord Variable globale portée surcharge Ordre d'évaluation Expression comme instruction semi-compilation Machine virtuelle récurrence terminaison complexité espace temps O() Typage fort Typage faible polymorphisme enregistrement Type produit classe instance allocation Glaneur de cellulesurcharge constructeur accesseur partage Type enveloppé tableaux référenceRéférence nulle Types disjonctifs piles files exceptions Typage statique/dynamique transtypage

7 i21 - 2008-2009 IEM / uB GFDL 1.2 7 I Rappels sur Java 1.Programmation impérative 2.Noyau impératif 3.Procédures et fonctions

8 i21 - 2008-2009 IEM / uB GFDL 1.2 8 1. Programmation impérative ● Mode de programmation historique ● Matériel : mémoire(s) / processeur ● Données / programme ● Le processeur exécute le programme pour faire évoluer l'état mémoire ● (≠ programmation fonctionnelle : récriture de termes, ex. : Ocaml, Haskell) ● (≠ programmation logique : résolution, ex. : Prolog)

9 i21 - 2008-2009 IEM / uB GFDL 1.2 9 Langage machine ● Mémoire : tableau de mots-mémoire (32 bits) ● Instructions machine : manipulation élémentaire des mots mémoire (arithmétique, déplacement, test) ● Avantage : très rapide ● Inconvénient : beaucoup de cerveau pour rien ● ex. : copier le mot binaire 1000001, soit 65 en décimal, dans la carte graphique pour écrire « A »

10 i21 - 2008-2009 IEM / uB GFDL 1.2 10 Afficher « AB » 12 load reg1 65 13 move reg1 3233212 14 add reg1 1 15 move reg1 3233213 16 stop

11 i21 - 2008-2009 IEM / uB GFDL 1.2 11 Programmation impérative de haut niveau : compilation ● Abstraire la mémoire et les instructions pour se concentrer sur le plus utile ● Compilation (compilateur) : traduire le programme écrit dans un langage de haut niveau en instructions machine ● Inconvénient : exécution un peu plus lente (négligeable) ● Avantage : cerveau mieux utilisé ● Changement d'architecture (processeur, langage machine) : recompiler

12 i21 - 2008-2009 IEM / uB GFDL 1.2 12 Afficher « AB » System.out.println(« AB »);

13 i21 - 2008-2009 IEM / uB GFDL 1.2 13 Semi-compilation ● Abstraire le processeur : machine virtuelle ● Semi-compilation : convertir le programme en langage pour la machine virtuelle ● Avoir une machine virtuelle pour chaque processeur réel ● Inconvénient : exécution encore un peu plus lente (négligeable en général) ● Avantage : pas de recompilation, le même programme pour toute architecture / portabilité du code semi- compilé

14 i21 - 2008-2009 IEM / uB GFDL 1.2 14 Java ● Machine virtuelle (JVM : Java virtual machine) ● Programme : fichier.java ● Semi-compilateur : javac – javac Main.java -> Main.class ● Exécuteur de la machine virtuelle : – java Main (sous entendu, Main.class) ● Portabilité : le même Main.class fonctionne sur toute architecture (c'est l'exécuteur qui change)

15 i21 - 2008-2009 IEM / uB GFDL 1.2 15 Conventions et programme minimal en Java class Main { public static void main(String arg[]){ } ● Nom du fichier :.java ● Beaucoup de notions (class, static, public, void...) pour plus tard

16 i21 - 2008-2009 IEM / uB GFDL 1.2 16 2 Noyau impératif ● Déclaration ● Mise en séquence ● Affectation ● Test ● Boucle (ici en Java, mais presque pareil en C, C++, ADA, Pascal, Python, PHP,...)

17 i21 - 2008-2009 IEM / uB GFDL 1.2 17 Syntaxe/sémantique ● Syntaxe (de Java) : ensemble de règles définissant les programmes bien formés ● Sémantique (de Java) : ensemble de règles définissant, pour les programmes syntaxiquement corrects, leurs effets sur l'état mémoire, le processeur, et leur conditions de validité

18 i21 - 2008-2009 IEM / uB GFDL 1.2 18 Noyau impératif ● Déclaration – Instruction de déclaration de variables – Types de base – Modèle mémoire associé – Déclaration de constantes

19 i21 - 2008-2009 IEM / uB GFDL 1.2 19 Instruction 1 : déclaration ● Syntaxe : (notation BNF Backus-Naur form) ● ex. : int toto; ● Identificateur : nom unique (suite de caractères, _, nombres, commence par un caractère, sensible à la casse) ● Types : types de bases (ex. int), types composites, types déclarés ● Ex. d'erreur de syntaxe : int 09toto;

20 i21 - 2008-2009 IEM / uB GFDL 1.2 20 Types de bases ● Scalaires – Entier : byte, short, int, long (de plus en plus de bits pour représenter le nombre entier, plus grands nombres) – Flottants : float, double (de plus en plus de bits pour représenter le nombre flottant, meilleure précision) ● Autre – Booléens : boolean (true, false) – Caractères : char ('A', 'B',...)

21 i21 - 2008-2009 IEM / uB GFDL 1.2 21 Variables/constantes ● Variable : zone mémoire identifiée pouvant être modifiée ● Constante : zone mémoire identifiée ne pouvant être modifiée après initialisation – Syntaxe : final – Ex : final float PI; – Une fois la valeur de PI fixée, ne pourra être modifiée

22 i21 - 2008-2009 IEM / uB GFDL 1.2 22 Modèle mémoire ● int x; ● Une case mémoire porte le nom x, et contient une valeur de type int ● boolean b; ● Une case mémoire porte le nom b, et contient une valeur de type boolean

23 i21 - 2008-2009 IEM / uB GFDL 1.2 23 Déclaration ● Bonne pratique : utiliser des identificateurs significatifs ● Ex : int longueurTableau; ● Contre-ex. : int lt; ● Bonne pratique : choisir une convention de nommage et s'y tenir (convention Java : premier mot en minuscule, séparation avec des majuscules, constantes en MAJUSCULES)

24 i21 - 2008-2009 IEM / uB GFDL 1.2 24 Instruction 2 : mise en séquence ● Mettre plusieurs instruction l'une à la suite de l'autre Etat 0→(instr. 1)→Etat 1→(instr. 2)→Etat 2... ● Ex : int x; int y; ● En Java, C, C++ : « ; » est un terminateur (il y a toujours un « ; » à la fin d'une instruction) ● Dans d'autres langages : séparateur (Ocaml, Pascal)

25 i21 - 2008-2009 IEM / uB GFDL 1.2 25 Bloc d'instructions ● Bloc : suite d'instructions entre accolades ● Ex : public static void main(String argv[]){ Int x; {int y; int z; { int q; int t; }

26 i21 - 2008-2009 IEM / uB GFDL 1.2 26 Portée des identificateurs ● Un identificateur est défini pour le bloc courant et ses sous-blocs ● Une redéclaration d'un identificateur dans le même bloc est interdite ● Servira plus tard...

27 i21 - 2008-2009 IEM / uB GFDL 1.2 27 Portée des identificateurs ● Ex : int x;// accessible : x { int y;// accessibles : x,y int z;// accessibles : x,y,z int x; // interdit : x déjà défini } // accessibles : x int x; // interdit : x défini dans ce même bloc

28 i21 - 2008-2009 IEM / uB GFDL 1.2 28 Instruction 3 : affectation ● Syntaxe : = ● Ex. : int x=3; ● Expression : ce qui a une valeur ● Types de bases munis d'opérateurs internes : – Scalaires ● Entiers positifs : +, *, -, / (quotient), % (reste) ● Entiers négatifs : +, *, -, / (division arrondie en défaut), % ● Flottants : +, *, -, / – Autres ● Booléens : && (et), || (ou), ! (non)

29 i21 - 2008-2009 IEM / uB GFDL 1.2 29 Booléens ● George Boole (1815-1864), logicien, mathématicien et philosophe britannique ● Fondements de la logique moderne, basés sur une structure algébrique et sémantique (algèbre de Boole)

30 i21 - 2008-2009 IEM / uB GFDL 1.2 30 Expressions ● Par combinaison de : – valeurs de types de bases (littéraux) ● ex. 3, ''Toto'' – expression expression ● ex. 3+2, 1-5*3 – expression ● ex. -1 – Parenthèses ● ex. -(1+3)*5+2

31 i21 - 2008-2009 IEM / uB GFDL 1.2 31 Expressions : priorité des opérateurs ● Priorités usuelles – Parenthèses > - unaire > * > + ● ex. -(3+5)*2+8 – ! > && > || ● ex. !true && false || true

32 i21 - 2008-2009 IEM / uB GFDL 1.2 32 Instruction 3 : affectation ● Si constante, une et une seule affectation final float PI; PI=3.141593; final int THECANTROPE; THECANTROPE=1; THECANTROPE=2; // erreur sémantique

33 i21 - 2008-2009 IEM / uB GFDL 1.2 33 Expressions : opérateurs logiques ● Test d'égalité – ==, != : test l'égalité/l'inégalité de valeurs ● Comparateurs (types ordonnés) –, >=

34 i21 - 2008-2009 IEM / uB GFDL 1.2 34 Instruction 3 : affectation ● Sémantique de l'affectation : – Calcul de la valeur de l'expression – Modification de la case mémoire indentifiée à cette valeur int x ; x=3+5*(2+8); boolean b; b=true || true; ● Modèle mémoire : – La case nommée x contient la valeur 53 – La case nommée b contient la valeur true

35 i21 - 2008-2009 IEM / uB GFDL 1.2 35 Typage ● Une expression peut combiner des types ● Un calcul (de type) est réalisé pour vérifier la cohérence des types ● ex d'erreur sémantique : int x=true; (syntaxe ok) ● Ex : int x=(3*2)+(5/2)-(3+2.5); (erreur) ● Ex : boolean b=(3>5)&&(5.1+2.9==8.0); (ok) ● Il existe un programme qui vérifie automatiquement si les types d'un programme Java sont corrects

36 i21 - 2008-2009 IEM / uB GFDL 1.2 36 Types ● Ex: javac ● Java est un langage à typage statique pour les types de base : après compilation, il ne peut y avoir d'erreur de type (autre exemple : C++) ● => Pour Ariane (plus stricte encore : ADA) ● Autres langages : pas de déclaration, typage dynamique (à l'exécution, les variables changent de type, ex. PHP) ● => Pour faire vite, plus risqué

37 i21 - 2008-2009 IEM / uB GFDL 1.2 37 Instructions 1 et 3 combinées int x; (x vaut la valeur par défaut des int, 0) x=3; → int x=3; (x ne vaut jamais 0) ● Bonne pratique : initialiser les variables immédiatement (signalé par le compilateur)

38 i21 - 2008-2009 IEM / uB GFDL 1.2 38 Types de base manipulés par références ● Tableau : tableau d'éléments de même type ● Déclaration : int[] t; (t de type tableau d'entiers) ● Variante (déconseillée): int t[]; ● Modèle mémoire : t ne contient pas une valeur, mais une référence vers un élément ● Dans ce cas : référence par défaut : null (rien)

39 i21 - 2008-2009 IEM / uB GFDL 1.2 39 Instanciation d'un tableau ● Instanciation : opération d'allocation mémoire associée à un type / expression ayant pour valeur une référence ● Syntaxe pour l'instanciation d'un tableau : new [ ] ● Alloue un tableau de n éléments de type, initialisés à une valeur par défaut (0 pour scalaires, etc.) ● Ex. : instanciation d'un tableau de 10 int : new int[10];

40 i21 - 2008-2009 IEM / uB GFDL 1.2 40 Tableau à plusieurs dimensions ● ex. : int[][] t=new int[10][3]; ● Accès aux éléments : t[1][1] ● Littéraux de type tableau : Int[] t={1,2,3,4}; String[] s={''toto'', ''tutu''};

41 i21 - 2008-2009 IEM / uB GFDL 1.2 41 Modèle mémoire int[] t=new int[10]; ● t contient une référence vers le tableau instancié. Le tableau contient 10 valeur 0 ● Accès aux éléments par l'indice, débute à 0 ● Expression t[0], t[1],... ● Partage de référence : Int[] t1=new int[10]; Int[] t2=t1; ● t1 et t2 référencent le même tableau !

42 i21 - 2008-2009 IEM / uB GFDL 1.2 42 Partage de références ● t1[1]=55; ● t2[1]=60; ● t1[1] est modifié. ● Attention : test d'égalité t1==t2 ● Compare la valeur de t1 à celle de t2 ● Mais la valeur de t1 et de t2 sont des références

43 i21 - 2008-2009 IEM / uB GFDL 1.2 43 Test d'égalité et références ● Pour les types manipulés par référence, l'opérateur d'égalité teste si les références sont égales, et ne compare par le contenu ● Grande source d'erreur ● Idem pour les chaînes ● Comparer le contenu de 2 tableaux : tester les éléments un par un ● Comparer le contenu de 2 chaînes : s.equals(s2), mais on verra plus tard

44 i21 - 2008-2009 IEM / uB GFDL 1.2 44 Types de bases manipulés par références ● Chaînes de caractère : String ● Constantes : ''tata'' ● String toto=''tata''; ● String tutu=toto; ● Tutu référence la même chaîne que toto ● Effet de : tutu=''bob'' ? ● En Java : impossibilité de modifier un élément String (alors qu'en C, en C++,...)

45 i21 - 2008-2009 IEM / uB GFDL 1.2 45 Instruction 4 : test ● Correspond à la notion – « Si ceci est vrai, alors exécuter cela, (et sinon ceci) » if ( ) else ● Ex. : if (32+5>22 && (true || 1==1)) x=1;

46 i21 - 2008-2009 IEM / uB GFDL 1.2 46 Instruction 4 : test ● Si plus d'une instruction à réaliser, en faire un bloc d'instruction (entre accolades) If (x) { y=3; z=5; } else { y=1; z=2; } ● Bonne pratique : indentation et alignement du code

47 i21 - 2008-2009 IEM / uB GFDL 1.2 47 Instruction 4 : test ● Tests multiples : if ( ) instr.1 else if ( ) instr. 2 else if ( ) instr. 3...

48 i21 - 2008-2009 IEM / uB GFDL 1.2 48 switch/case switch( ){ case : ;... default : ; }

49 i21 - 2008-2009 IEM / uB GFDL 1.2 49 switch/case ● Instruction break : quitter le bloc courant (ici, le switch)

50 i21 - 2008-2009 IEM / uB GFDL 1.2 50 switch/case int x=2; String reponse; switch(x){ case 2: case 4: case 8:reponse= ''c'est 2, 4 ou 8''; break; case 1: reponse= ''c'est 1''; default : reponse= ''c'est pas''; }

51 i21 - 2008-2009 IEM / uB GFDL 1.2 51 Instruction 5 : boucle ● Pour, tant que-faire, faire-tant que ● Tant que (condition) faire instruction – Tant que la condition est vraie, exécuter la/les instruction(s)

52 i21 - 2008-2009 IEM / uB GFDL 1.2 52 boucle ● Objectif : éviter les répétitions de code / faire varier un indice de boucle ● T[0]=0; t[1]=1; t[2]=2; ● i=0; Tant que(i<3) – T[i]=i; – i=i+1; ● while( ) do ● Int i=0; while(i<3){ T[i]=i;i=i+1; ● Attention : expression vérifiée avant l'entrée dans la boucle ● x=11; While (x<10) do x=x+1;

53 i21 - 2008-2009 IEM / uB GFDL 1.2 53 Instruction 5 : boucle ● Question de la terminaison ● int x=1; while (x>0) do x=x+1; ● La terminaison d'un programme est en général indécidable (il n'existe pas de programme qui vérifie qu'un programme P passé en paramètre termine toujours) ● « On Computable Numbers with an Application to the Entscheidungsproblem » [Turing, 1936]

54 i21 - 2008-2009 IEM / uB GFDL 1.2 54 Alan Mathison Turing (1912 - 1954) ● Mathématicien britannique ● Machine de Turing ● Test de Turing ● Code Enigma ● Médaille de Turing

55 i21 - 2008-2009 IEM / uB GFDL 1.2 55 Instruction 5 : boucle ● do while ( ); ● Test de la condition à la fin : exécute au moins une fois l'instruction

56 i21 - 2008-2009 IEM / uB GFDL 1.2 56 Instruction 5 : boucle ● for( ; ; ) – ● Correspond à – Exécuter I1; – Tant que (E est vraie) ● Exécuter I3 ● Exécuter I2

57 i21 - 2008-2009 IEM / uB GFDL 1.2 57 Boucles : break/continue ● break : sortie du bloc courant (donc de la boucle) ● continue : passer au tour de boucle suivant (pour le for, faire l'étape I2);

58 i21 - 2008-2009 IEM / uB GFDL 1.2 58 3 Procédures et fonctions ● Procédures prédéfinies ● Motivation pour leur utilisation ● Déclaration de procédures ● Déclaration de fonctions ● Fonctions et opérateurs ● Surcharge ● Fonctions comme instructions

59 i21 - 2008-2009 IEM / uB GFDL 1.2 59 Procédures prédéfinies ● Entrées / sorties : – System.out.println(); // sauter une ligne – System.out.println( ); ● Affiche la valeur de l'expression et saut de ligne (si référence, une adresse de la mémoire de la machine virtuelle, comme array@12312323) – System.out.print( ); ● Idem, sans saut de ligne

60 i21 - 2008-2009 IEM / uB GFDL 1.2 60 Fonctions prédéfinies ● Calculs – ex. float f=Math.sin(12); ● Entrées / sorties : – Entrées en Java, complexes – Fichier Lire.java pour vous simplifier la vie, disponible sur le site ● ex. : int x=Lire.i(); ● ex. : float f=Lire.f(); ● etc.

61 i21 - 2008-2009 IEM / uB GFDL 1.2 61 Procédures déclarées : motivation ● Ex : afficher « Bonjour et sauter 2 lignes après une délicate frise », pour Clément et Eliana

62 i21 - 2008-2009 IEM / uB GFDL 1.2 62 Motivation ● System.out.println(« Bonjour Clément »); ● System.out.println(« ============= »); ● System.out.println(); ● System.out.println(« Bonjour Eliana »); ● System.out.println(« ============= »); ● System.out.println();

63 i21 - 2008-2009 IEM / uB GFDL 1.2 63 Motivation ● Objectif : éviter les redondances de code / factoriser du code ● « Mais je peux faire du copier/coller ! » ● Oui, mais si il faut changer le message, la frise, il faut (penser à) corriger à plusieurs endroits (éventuellement éloignés) ● Bonne pratique : Lorsque deux traitements sont identiques aux paramètres près, en faire une procédure

64 i21 - 2008-2009 IEM / uB GFDL 1.2 64 Motivation ● // déclaration ● void message(String nom){ – System.out.println(« Bonjour » +nom); – System.out.println(« ============= »); – System.out.println(); ● } ● Message(« Clément »); // programme principal ● message(« Eliana »);

65 i21 - 2008-2009 IEM / uB GFDL 1.2 65 On peut faire mieux ● Redondance des sauts de ligne ● La frise peut servir autre part ● Bonne pratique : si un traitement peut servir dans plusieurs contextes, en faire une procédure

66 i21 - 2008-2009 IEM / uB GFDL 1.2 66 Factorisation de code ● Void afficheFrise(){ – System.out.println(« ============= »); ● } ● Void sauteDeuxLignes(){ – System.out.println(); ● }

67 i21 - 2008-2009 IEM / uB GFDL 1.2 67 Factorisation de code ● void message(String nom){ – System.out.println(« Bonjour » +nom); – AfficheFrise(); – SauteDeuxLignes(); ● } ● message(« Clément »); // programme principal ● message(« Eliana »);

68 i21 - 2008-2009 IEM / uB GFDL 1.2 68 Avantages ● Écrire moins ● Modifications se propagent partout (ex. frise avec des « # ») ● Faciliter la compréhension (programmation en équipe...binômes) ● Découpage et distribution du travail (lundi AfficheFrise, mardi sauteDeuxLigne, etc.)

69 i21 - 2008-2009 IEM / uB GFDL 1.2 69 Vocabulaire ● Déclaration de procédure ou fonction ● Appel de procédure ou fonction

70 i21 - 2008-2009 IEM / uB GFDL 1.2 70 Déclaration de procédures ● Identificateur de procédure (son nom) – Convention Java : commence par une minuscule, majuscule comme séparateur – ex. afficheLigne et pas Affiche_Ligne ● Bonne pratique : choisir une convention et s'y tenir (pourquoi pas celle de Java ?)

71 i21 - 2008-2009 IEM / uB GFDL 1.2 71 Déclarations des paramètre formels ● Déclaration des paramètres formels (ou arguments formels) : ● void (,,etc.) ● void message(String nom)... ● Nb de paramètre : arité de la procédure ● Paramètres disponibles comme variables dans le corps de la proc. ou fonction ● Corps : bloc

72 i21 - 2008-2009 IEM / uB GFDL 1.2 72 Appel de procédures ● Appel : respecter l'arité, l'ordre des paramètres et leur type ● ex. message(« Eliana »); ● Contre-ex. : message(); ● valeur « Eliana » : paramètre (argument) réel

73 i21 - 2008-2009 IEM / uB GFDL 1.2 73 Sémantique de l'appel void afficheNombre(int nombre){ System.out.println(« Le nombre est » +nombre); } int n= 12; afficheNombre(n+1); ● La valeur des expressions fournies comme paramètre est calculée (ici, 13) ● Les valeurs résultantes sont copiées comme valeur des paramètres formels ● Valeur de nombre dans afficheNombre: 13

74 i21 - 2008-2009 IEM / uB GFDL 1.2 74 Passage de paramètres ● Passage par recopie ● Attention : void afficheNombre(int nombre){ System.out.println(« Le nombre est » +nombre); nombre=nombre+1; } int n= 12; afficheNombre(n); ● Aucun rapport entre nombre et n : n est inchangé par l'appel

75 i21 - 2008-2009 IEM / uB GFDL 1.2 75 Passage de paramètres ● Même dans le cas suivant : void afficheNombre(int nombre){ System.out.println(« Le nombre est » +nombre); nombre=nombre+1; } int nombre= 12; afficheNombre(nombre); ● Deux identificateurs nombre, différenciés par le contexte

76 i21 - 2008-2009 IEM / uB GFDL 1.2 76 Autres langages ● Possibilité de passage par adresse (ou référence) : C, C++ ● Complique les choses

77 i21 - 2008-2009 IEM / uB GFDL 1.2 77 Attention : paramètre réel référence ● En Java, certains types sont manipulés par référence ● Tableau, chaînes, etc. ● int[10] t; // t est une référence au tableau Void affichePremierElement(int[10] tab){ System.out.println(« premier element » + tab[0]); } ● La valeur de t est seulement copiée, mais le ● Tableau est accessible en écriture (tab référence le même tableau)