Module: P.O.O. C. IGHILAZA
1
Support de TP
Introduction à la syntaxe JAVA
Le langage Java est un langage de programmation crée en 1995 par Sun Microsystems. Il permet une programmation orientée-objet et reprend une syntaxe très proche de celle du langage C.
Outre son orientation objet, le langage Java a l’avantage d’être modulaire (on peut écrire des portions de code génériques, c.-à-d. utilisables par plusieurs applications), rigoureux (la plupart des erreurs se produisent à la compilation et non à l’exécution) et portable (un même programme compilé peut s’exécuter sur différents environnements).
En contrepartie, les applications Java ont le défaut d’être plus lentes à l’exécution que des applications programmées en C par exemple.
1. Environnement Java
Java est un langage interprété, ce qui signifie qu’un programme compilé n’est pas directement exécutable par le système d’exploitation mais il doit être interprété par un autre programme, qu’on appelle interpréteur. La figure suivante illustre ce fonctionnement.
Un programmeur Java écrit son code source, sous la forme de classes, dans des fichiers dont l’extension est .java. Ce code source est alors compilé par le compilateur javac en un langage appelé bytecode et enregistre le résultat dans un fichier dont l’extension est .class. Le bytecode ainsi obtenu n’est pas directement utilisable. Il doit être interprété par la machine virtuelle de Java qui transforme alors le code compilé en code machine compréhensible par le système d’exploitation. C’est la raison pour laquelle Java est un langage portable : le bytecode reste le même quelque soit l’environnement d’exécution.
Les programmeurs travaillent généralement dans ce qu’on appelle un Environnement de développement intégré (Integrated Development Environment ou IDE). On peut y écrire, compiler et exécuter les programmes. Un IDE fournit aussi un utilitaire d’Aide qui décrit tous les éléments du langage et te permet de trouver et de corriger plus facilement les erreurs dans tes programmes. Alors que la plupart des IDE sont très chers, il en existe un excellent, gratuit :
Eclipse. Tu peux le télécharger depuis le site web www.eclipse.org.
2
A retenir :
Structure générale :
- 1 Classe = 1 fichier .java (code source) ou .class (bytecode) - 1 Classe = ensemble d’attributs et de méthodes
- Programme = des Classes dont une contient main
Déroulement
- L’exécution d’une méthode se fait de haut en bas
- L’exécution d’un programme consiste à exécuter son main
Commandes pour l’exécution
- javac : compilation d’un code source en bytecode
- java : machine virtuelle qui interprète du bytecode
Module: P.O.O. C. IGHILAZA
3
2. Syntaxe du langage
La syntaxe de java est proche de celle du langage C concernant les déclarations des types primitifs et des tableaux ou l’utilisation des instructions de contrôle. Il y a cependant des différences importantes : pas de typedef, pas de déclarations de structures (struct en C), pas de variables globales, pas de directives de compilation (#include, #define, etc.), entrées-sorties différentes (printf en C, System.out.println en java), pas de pointeurs, gestion des chaines de caractères différentes, passage des paramètres par valeur, ce qui pose des problèmes pour les types primitifs, gestion automatique de la désallocation de mémoire, etc.
Le langage C a servi de base pour la syntaxe du langage Java :
• le caractère de fin d’une instruction est “ ;”
• les commentaires (non traités par le compilateur) se situent entre les symboles “/*” et
“*/” ou commencent par le symbole “//” en se terminant à la fin de la ligne Ex : int a ; // ce commentaire tient sur une ligne
int b ; Ou
Ex : int a ; /*Ce commentaire nécessite 2 lignes*/
int b ;
• les identificateurs de variables ou de méthodes acceptent les caractères {a..z}, {A..Z}, $, _ ainsi que les caractères {0..9} s’ils ne sont pas le premier caractère de l’identificateur.
Il faut évidemment que l’identificateur ne soit pas un mot réservé du langage (comme int ou for).
2.1. Types de données
Types primitifs
À l’inverse du langage C, Java est un langage très rigoureux sur le typage des données.
Il est interdit d’affecter à une variable la valeur d’une variable d’un type différent 1 si cette seconde variable n’est pas explicitement transformée.
Par exemple : int a ;
double b = 5.0 ; a = b ; est interdit
doit être écrit de la manière suivante : int a ;
double b = 5.0 ; a = (int)b;
Même types qu'en C:
int float double short long char
Plus deux nouveaux types : boolean
byte
Plus la classe : String
Déclaration : int E;
String chaine;
boolean test;
4 Remarque :
Dans les expressions arithmétiques, les entiers de type byte ou short sont considérés comme des int (convertis d’office en int). Si b est un byte, b+1 est considéré comme un int.
L’affectation b=b+1 ; est illégale sans cast (de type int -> byte) alors que b=5 est acceptée.
int i1 ; byte b1 ;
b1=i1 ; // erreur
b1=(byte) i1 ; // correcte b1=b1+1 ; // erreur
b1=(byte) (b1+1). // correcte.
3.2 Les constantes symboliques
Les constantes symboliques sont déclarées comme des variables précédées de final. Leur contenu ne peut être modifié par la suite. L’identificateur de la constante est souvent écrit en majuscules.
Exemple final int MAX=200 ;
final double PI=3.1415926535 ; 3.3Tableaux à une et deux dimensions
Une variable est déclarée comme un tableau dès lors que des crochets sont présents soit après son type, soit après son identificateur. Les deux syntaxes suivantes sont acceptées pour déclarer un tableau d’entiers (même si la première, non autorisée en C, est plus intuitive) :
int[ ] tabEnt;
int tabEnt2[ ];
Dans cette déclaration tabEnt est une référence non initialisée vers un tableau d’entiers.
tabEnt
En java l’espace mémoire n’est pas réservé pour ce tableau. L’allocation doit se faire avec new en indiquant le nombre d’éléments.
Exemple : tabEnt= new int[10] ; // on réserve 10 éléments de type int numérotés de 0 à 9.
tabEnt
0 1 2 3 4 5 6 7 8 9
Après exécution de tabEnt=new int [10] ; tabEnt est une référence sur un tableau d’entiers initialisés à 0.
De plus, la taille de ce tableau est disponible dans une variable length appartenant au tableau et accessible par tabEnt.length.
On peut également créer des tableaux à deux dimensions (matrices) ou des tableaux à plusieurs dimensions en multipliant les crochets. Exemple : int[ ][ ] matrice; .
0 0 0 0 0 0 0 0 0 0
Module: P.O.O., L2 ACAD Section B C. IGHILAZA
5
Un tableau à deux dimensions est un tableau de tableaux. Le nombre d’éléments dans chaque ligne du tableau à deux dimensions peut même varier en java.
tab2D
0 1 2
0 1 2
tab2D est un tableau d’entiers à deux dimensions de 2 lignes et 3 colonnes. tab2DVar 0 1 2
0 1
tab2DVar est un tableau d’entiers à deux dimensions de 2 lignes et d’un nombre variable de colonnes. tab2DV.length : nombre de lignes de la matrice tab2Dv[0].length : nombre de colonnes de la ligne 0 3.4 Chaînes de caractères Les chaînes de caractères ne sont pas considérées en Java comme un type primitif ou comme un tableau. On utilise une classe particulière, nommée String, fournie dans le package java.lang. Les variables de type String ont les caractéristiques suivantes : • leur valeur ne peut pas être modifiée • on peut utiliser l’opérateur + pour concaténer deux chaînes de caractères. String s1 = "Bon"; String s2 = "jour"; String s3 = s1 + s2 ; //Après ces instructions s3 vaut "Bonjour" • l’initialisation d’une chaîne de caractères s’écrit : String s = new String(); //pour une chaîne vide String s2 = new String("Bonjour"); // pour une chaîne de valeur "Bonjour" • un ensemble de méthodes de la classe java.lang.String permettent d’effectuer des opérations ou des tests sur une chaîne de caractères. (Voir §4) 1 2 3
4 5 6
1 2 3
4 5
6 3.5Opérateurs :
+, -, *, /, +=, -=, *=, /=
%, %=
++, --
>, <, <=, >=, ==, !=
&&, ||, !
3.6 Structures de contrôle
Les structures de contrôle permettent d’exécuter un bloc d’instructions soit plusieurs fois (instructions itératives) soit selon la valeur d’une expression (instructions conditionnelles ou de choix multiple). Dans tous ces cas, un bloc d’instruction est :
• soit une instruction unique ;
• soit une suite d’instructions commençant par une accolade ouvrante “{” et se terminant par une accolade fermante “}”.
3.6.1 Instructions conditionnelles
if (<condition>) <bloc1> [else <bloc2>]
ou <condition>?<bloc1>[ :<bloc2>]
<condition> doit renvoyer une valeur booléenne. Si celle-ci est vraie c’est <bloc1> qui est exécuté sinon <bloc2> est exécuté. La partie else <bloc2> (respectivement:<bloc2>) est facultative.
Exemple : if (a == b) { a = 50 ; b = 0 ; } else a = a - 1 ;
3.6.2 Instructions itératives
• while (<condition>) <bloc>
Exemple : while (a != b) a = a + 1 ;
• do <bloc> while (<condition>);
Exemple : do { a = a + 1 ;}
while (a != b) ;
• for (<init> ;<condition>;<instr_post_itération>) <bloc>
Exemple :
for (int i = 0, j = 49 ; (i < 25) && (j >= 25) ; i++, j--) {
if (tab[i] > tab[j]) { int tampon = tab[j];
tab[j] = tab[i];
tab[i] = tampon;
} }
Module: P.O.O., L2 ACAD Section B C. IGHILAZA
7
3.6.3 Instructions de choix multiple
switch(<variable>) { case <val1> :<bloc1>
case <val2> :<bloc2>
case ... :...
default :<blocdefaut>
}
Exemple : switch (car) {
case ’A’ : car = ’a’ ;break;
case ’B’ : car = ’b’ ;break;
case ’C’ : car = ’c’ ;break;
case ’a’ : case ’b’ : case ’c’ : break;
default : car = ’ ?’ ; }
3.6.4 Instructions break et continue
L’instruction break est utilisée pour sortir immédiatement d’un bloc d’instructions (sans traiter les instructions restantes dans ce bloc). Dans le cas d’une boucle on peut également utiliser l’instruction continue avec la différence suivante :
break : l’exécution se poursuit après la boucle (comme si la condition d’arrêt devenait vraie) ;
continue : l’exécution du bloc est arrêtée mais pas celle de la boucle. Une nouvelle itération du bloc commence si la condition d’arrêt est toujours vraie.
Exemple :
for (int i = 0, j = 0 ; i < 100, i++) { if (i > tab.length) break ; if (tab[i] == null) continue ; tab2[j] = tab[i] ;
j++ ; }
3.7Lecture et affichage de données
Pour communiquer une information, l’ordinateur affiche un message à l’écran. On dit qu’il réalise une opération de sortie (out) ou d’écriture de données. A l’inverse l’utilisateur communique des données au programme par l’intermédiaire du clavier, il effectue une opération d’entrée (in) ou de lecture de données. La gestion de ces opérations se fait grâce à la bibliothèque System.
Pour dissocier les opérations d’entrée ou de sortie, la librairie System est composée de deux sous-ensembles, in et out.
L’affichage d’une opération de sortie fait donc partie des éléments out de la classe System. Le point (.) qui relie le mot System à out permet d’expliquer à l’ordinateur que l’on souhaite accéder au sous-ensemble out de la librairie System plutôt qu’au sous ensemble in. Pour finir, nous faisons appel, dans le sous-ensemble out, à la méthode print.
8
Dans le langage java, les opérations de sortie sont donc réalisées grâce à l’instruction : System.out.print(), qui permet d’afficher des informations à l’écran.
objet méthode
Par exemple, l’instruction :
System.out.print("Bonjour ") ; affiche le texte Bonjour
int A=10, B=5 ;
System.out.print("La somme de " + A + "et " + B + " = "+ (A+B)) ; affiche à l’écran le texte La somme de suivi du contenu de la variable A, puis le texte et suivi du contenu de la variable B, puis affiche le signe =, puis le résultat de la somme (A+B).
Important :
- Pour afficher le résultat d’une addition, il est nécessaire de placer entre parenthèse le calcul à afficher.
- Pour distinguer le commentaire du nom de la variable, le commentaire est placé entre guillemets. Le contenu de la variable est affiché en réunissant la variable au commentaire à l’aide du signe +.
Pour afficher des résultats sur plusieurs lignes, il convient d’utiliser l’instruction : System.out.println()
Les opérations d’entrée sont réalisées par l’intermédiaire de la classe Scanner grâce aux instructions suivantes :
Scanner lire=new Scanner(System.in) ; int i=lire.nextInt();
Les méthodes de lecture ont pour nom d’appel :
• nextByte() pour saisir une valeur de type byte ;
• nextShort() pour saisir une valeur de type short ;
• nextInt() pour saisir une valeur de type int ;
• nextLong() pour saisir une valeur de type long ;
• nextFloat() pour saisir une valeur de type float ;
• nextdouble() pour saisir une valeur de type double ;
• next() pour saisir une valeur (un mot, sans l’espace blanc) de type String ;
• nextLine() pour saisir une phrase de type String ;
• next().charAT(0) pour saisir une valeur de type char ;
Module: P.O.O., L2 ACAD Section B C. IGHILAZA
9 3. Éléments de programmation Java
Un programme écrit en Java consiste en un ensemble de classes représentant les éléments manipulés dans le programme et les traitements associés. L’exécution du programme commence par l’exécution d’une classe qui doit implémenter une méthode particulière “public static void main(String[] args)”. Les classes implémentant cette méthode sont appelées classes exécutables.
Exemple1 :
Classe Bonjour
Une première classe Java Bonjour qui affiche la chaîne de caractères "Bonjour"
s’écrit :
public class Bonjour {
public static void main(String[] args) { System.out.println("Bonjour");
} }
Remarque : Le tableau de chaînes de caractères args qui est un paramètre d’entrée de la méthode main est initialisé par le système et contient des valeurs précisées à l’exécution (contient les arguments de la ligne de commande). Si la classe avait été exécutée par la ligne de commande “%java Bonjour USTHB 2012”.
for (int i=0 ;i<args.length ;i++) { System.out.print(args[i]+ “ “) ; }
Ce tableau contiendrait 3 éléments dont les valeurs seraient respectivement Bonjour USTHB et 2012.
Exemple2 :
// SomTab.java somme des nb éléments d’un tableau d’entiers class SomTab {
public static void main (string[ ] args) {
int [ ] tabEnt= {1, 2, 3} ; // tableau de int nommé tabEnt // int tabEnt [ ] = {1, 2, 3} identique à l’instruction précédente
int somme=0 ;
// for (int i=0 ; i<3 ; i++) somme += tabEnt [ i ] ;
for (int i=0 ; i<tabEnt . length ; i++) somme =+ tabEnt [ i ] ; System.out.println (" Somme : " + somme) ;
} // fin de main } // class SomTab
Le résultat de l’exécution est le suivant : Somme : 6
10 Exemple 3:
class Tableau1D {
public static void main (String[ ] args) { int [ ] tab1= {1, 2, 3} ; // tableau de 3 entiers // tab1.length= la longueur de tab1
for (int i=0 ; i<tab1.length ; i++) { System.out.print ( tab1[i] + " ") ; }
System.out.println( ) ; // saut de ligne
// allocation d’un tableau de 5 valeurs entières int [ ] T = new int [5] ; // initialisation à 0 par défaut T [2] = 20 ;
T [4] = 50 ;
T [5] = 80 ; // message d’erreur à l’exécution (exception) // T.length= la longueur de T
for (int i=0 ; i<T.length ; i++) {
System.out.print (T[i] + " ") ; }
} // fin de main } // class Tableau1D Résultat d’exécution :
1 2 3
0 0 20 0 50 tableau initialisé à 0 par défaut Exemple 4 :
Dans ce programme très simple, une seule classe est utilisée. Cependant, la conception d’un programme orienté-objet nécessite, pour des problèmes plus complexes, de créer plusieurs classes et la classe exécutable ne sert souvent qu’à instancier les premiers objets. La classe exécutable suivante créé un objet en instanciant la classe Rectangle et affiche sa surface :
public class HelloWorld {
public static void main(String[] args) { Rectangle rect = new Rectangle(5, 10);
System.out.println("La surface est " + rect.surface());
} }
* Remarque importante : il est très fortement recommandé d’implémenter chaque classe publique dans un fichier séparé et il est indispensable que ce fichier ait le même nom que celui de la classe. Dans le cas précédent, deux fichiers ont ainsi été créés :
RectangleMain.java et Rectangle.java.
Module: P.O.O., L2 ACAD Section B C. IGHILAZA
11 4. Les chaines de caractères
Les chaines de caractères en java « String » sont une suite de séquences de caractères.
En C un string est un tableau de caractère, alors qu’en JAVA un string est un objet.
Les chaines de caractères sont définies dans les classes String et StringBuffer de java.lang.
La classe String, est utilisée pour les chaînes fixes (non modifiables), La classe StringBuffer pour les chaînes variables (modifiables).
5.1 La classe String :
On y trouve les méthodes suivantes :
new String("Bonjour") création d’une chaîne initialisée new String(String str); création d’une chaîne initialisée new String(); création d’une chaîne non initialisée new String(int taille); création d’une chaîne non initialisée boolean equals(String) comparaison de chaînes
if (str1.equals(str2))…
int compareTo(String) Cette méthode retourne 0 si les deux chaines sont égales, une valeur négative si str1 est plus petit que str2, ou une valeur positive si str1 est plus grand que str2.
str1.compareTo(str2)
int indexOf(char) recherche d’un caractère et obtention de son rang
int indexOf(char, int) recherche d’un caractère et obtention de son rang en faisant démarrer la recherche à partir d'un rang donné en second paramètre
int indexOf(String) recherche d’une sous chaîne et obtention de son rang
int indexOf(String, int) recherche d’une sous chaîne et obtention de son rang en faisant démarrer la recherche à partir d'un rang donné en second paramètre
char charAt(int) extraction d’un caractère par son rang
String subString(int,int) extraction d’une sous chaîne par rangs de début et de fin
int length() Longueur de la chaine
String concat(String) concaténation : on peut aussi utiliser l’opérateur +
12 Exemple :
class TestString1 {
public static void main (String[ ] args) { String ch1="Hichem" ; int i1=21 ;
String ch2=ch1 + i1 ; System.out.println("ch2 : " + ch2) ; //Hichem21 String ch3=i1+ch1 ; System.out.println("ch3 : " + ch3) ; //21Hichem String ch4=ch1 + i1+ 2 ; System.out.println("ch4 : " + ch4) ; //Hichem212 String ch5=ch1 + (i1+ 2) ; System.out.println("ch5 : " + ch5) ; //Hichem23 // String ch6=i1+2 ; // impossible de convertir int en String
String ch7=" " + i1 + 2 ; System.out.println("ch7 : " + ch7) ; // 212 String ch8= i1 + 2 + " " ; System.out.println("ch8 : " + ch8) ; // 23 String ch9=Integer.toString (i1+2) ; System.out.println("ch9 : " + ch9) ; // 23 } // main
} //class TestString1
// testString2.java class testString2 {
public static void main(String [ ] args) {
String s1= new String() ; String s2= " " ; String s3= null ;
String s4 = new String ("Madame") ; String s5 ="Mademoiselle" ;
String s6 = "Monsieur" ; String s7= s4 + ", " + s5 + ", " + s6 ; String s8="Madame" ; System.out.ptrintln (
"\ns1 : " + s1 + ", s1.length() : " + s1.length() +
"\ns2 : " + s2 + ", s2.length() : " + s2.length() +
"\ns4 : " + s4 + ", s4.length() : " + s4.length() ) ; System.out.println ("s3 : " + s3) ;
// System.out.println (", s3.length() : " + s3.length()) ; // s3.length provoque une exception (erreur) (s3 est null) System.out.println ("s7 : " + s7) ;
String s9 = s4.concat (", " + s6) ; String s10 = s4.toUpperCase() ; String s11= s4.toLowerCase() ; char c1= s4.charAt (2) ;
int comp1=s4.compareTo (s5) ; int comp2=s4.compareTo (s8) ; int comp3= s6.compareTo(s4) ;
boolean eq1 = s4.equals (s8) ; // equals compare les chaines boolean eq2 = (s4==s8) ; // == compare les références boolean eq3 = s6.equals (s4) ;
System.out.println ( "\ns4 : " + s4 + "\ns5 : " + s5 + "\ns6 : " + s6 + "\ns7 : " + s7 + "\ns8 : " + s8 + "\ns9 : " + s9 +
Module: P.O.O., L2 ACAD Section B C. IGHILAZA
13
"\ns10 : " + s10 + "\ns1 : " + s11 + "\n" + "\ncaractère 2 de s4 : " + c1 + "\ncomp1 de s4 et s5 : " + comp1 + "\ncomp2 de s4 et s8 : " + comp2 + "\ncomp3 de s6 et s4 : " + comp3 + "\neq1 de s4 et s8 : " + eq1 +
"\neq2 de s6 et s4 : " + eq2 + "\neq3 de s4 et s8 : " + eq3 ) ; System.out.println (
"\n indexOf a pour s4 : " + s4.indexOf ('a') +
"\n indexOf a pour s4 : " + s4.indexOf ('a', 2) +
"\n indexOf x pour s4 : " + s4.indexOf ("x") +
"\n indexOf si pour s6 : " + s6.indexOf ("si") +
"\n LastIndexOf a pour s4 : " + s4.LastIndexOf ("a") ) ;
Sysrem.out.println ( "\ns4 commence par Mad : "+ s4.startsWith ("Mad") +
"\ns6 fini par ieur : "+ s6.endsWith ("ieur") +
"\ns6 fin à partir de 2 : "+ s6.substring (2) +
"\ns6 sous-chaine de 2 à 4 : "+ s6.substring (2, 4) ) ;
String s12 = " 127 " ; boolean b=true ; int i1 = 243 ; System.out.println (
"\ns12 sans espaces : "+ s12.trim( ) +
"\nvalueOf b : "+ String.valueOf (b) +
"\nvalueOf i1 : "+ String.valueOf (i1) ) ; } //main
} // class TestString2
Remarque : valueOf () est une méthode static appelée en préfixant du nom de la classe String.
5.2 La classe StringBuffer :
Un objet de type StringBuffer représente une chaîne de caractères modifiable.
On peut changer un caractère, ajouter des caractères au tampon interne de l’objet défini avec une capacité qui peut être changée si besoin est.
0 19 sb
Un objet sb de la classe StringBuffer. Il contient 6 caractères et a une capacité de 20 caractères, numérotés de 0 à 19.
Madame
14
Un StringBuffer évolue dynamiquement. Si on augmente la longueur de son contenu, l’espace mémoire alloué est automatiquement augmenté.
Plusieurs méthodes importantes différencient la classe StringBuffer et la classe String, dont : length, capacity, setLength, charAt, setCharAt, append, insert et toString.
On y trouve les méthodes suivantes :
new StringBuffer("Bonjour") création d’une chaîne initialisée new StringBuffer(String str); création d’une chaîne initialisée new StringBuffer(); création d’une chaîne non initialisée
construit un tampon ayant 0 caractères mais d’une capacité par défaut de 16 caractères new StringBuffer(int taille); création d’une chaîne non initialisée
construit un tampon de capacité n caractères StringBuffer nom =
StringBuffer.ValueOf(variable)
création d’une chaîne à partir d’une variable primitive
Les méthodes suivantes concatènent au tampon de l’objet courant la
représentation sous forme de caractères de leur argument (boolean, int, etc…) StringBufffer append (boolean)
StringBufffer append (char) StringBufffer append (char[ ]) StringBufffer append (double) StringBufffer append (float) StringBufffer append (int) StringBufffer append (long)
StringBufffer append (Object) : ajoute toString( ) de l’objet StringBufffer append (String)
Les méthodes ci-dessous insèrent dans le tampon de l’objet, à partir de l’indice du paramètre 1, la représentation sous forme de caractères de leur argument.
StringBufffer insert (int, boolean) StringBufffer insert (int, char) StringBufffer insert (int, char[ ]) StringBufffer insert (int, double) StringBufffer insert (int, float) StringBufffer insert (int, int) StringBufffer insert (int, long)
StringBufffer insert (int, Object) ajoute toString( ) de l’objet StringBufffer insert (int, String)
Module: P.O.O., L2 ACAD Section B C. IGHILAZA
15
D’autres méthodes fournissent la capacité de l’objet de type StringBuffer, l’accès à un caractère à partir de son indice, la longueur de la chaine, la chaine inverse, ou l’objet de type String équivalent.
int capacity ( ) fournit la capacité de cet objet (nombre maximum de caractères)
char charAt (int n) fournit le caractère d’indice n
StringBuffer reverse () inverse les caractères de l’objet (gauche- droite devient droite-gauche)
String toString () convertit en un objet String
ensureCapacity (int n) la capacité de l’objet est au moins n sinon un nouveau tampon est alloué
void setCharAt (int index, char ch) le caractère index reçoit ch (0<=index<longueur)
