Et y'a un équivalent de const (C++) ??
Bon, je suis bien content que vous confirmiez ce qui commencé à troter dans ma tête, à savoir:
Bon sang mais pourquoi tous les paramètres ne sont ils pas naturellement FINAL !?? (en C++ toutes les références sont lié une seule fois, comme si elles étaient 'final' au sens JAVA).
Mais deuxième problème.
Si final ne permet pas du tout de protéger son objet, mais simplement de protéger la référence, existe t'il un équivalent au powerfull mot clef C++ "const" en JAVA ?
C'est à dire un mot clef spécifiant tout simplement que le paramètre est une ENTREE, et qui garanti donc que celui-ci (l'objet) ne sera pas modifié au sein de la méthode.
Bon sang, il me semble que c'est hachement important comme concept de pouvoir spécifier dans le prototype de ces méthodes que tel paramètre est une entrée, et tel autre non.
Dites moi que c'est prévu en JAVA ?
PS: après queques recherches je n'ai rien trouvé, si ce n'est une ruse de sioux qui consiste à définir 2 classes au lieu d'une, à l'image du couple "String" qui passé en paramètre ne permet pas de modifier l'objet en sortie. et "StringBuffer" qui lui justement le permet.
je m'explique:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
void ChangeMaChaine(String string, StringBuffer stringbuf)
{
string = "CaMarchePas";
stringbuf.setlength(0);
stringbuf.append("CaMarche");
}
// quelque part dans un main...
String s = new String("Entree");
StringBuffer sb = new StringBuffer("EntreeSortie");
ChangeMaChaine(s, sb);
System.format("String: %s\nStringBuffer: %s", s, sb);
/* Affiche :
String: Entree
StringBuffer: CaMarche
*/ |
Distinguer les paramètres d'ENTREE, de SORTIE, et d'ENTRE/SORTIE ? Comme en C++ ?
Bonjour, j'ai une assez bonne pratique du C++ (je veux dire que j'ai poussé le langage dans pas mal de coins sombres, templates, foncteurs, tout ça..)
et je me met à JAVA parceque ça a l'air merveilleux, sauf que:
Je n'ai pas trouvé comment l'on spécifie dans le prototype de sa méthode les paramètres qui seront des ENTREE, et ceux qui seront des SORTIE (ou E/S..)
Je ne peut pas croire que ça n'existe pas; En C++ il y'a le mot clef "const" pour celà, ça ajoute une vrai garantie que l'objet ne sera pas modifié (vérifié par le compilateur) et je ne peut pas croire que celà n'est pas possible en JAVA..
J'ai fait quelques recherches, le mieu que j'ai trouvé est le mot clef "final" mais ce n'est pas la meme chose.
final permet de spécifier que la REFERENCE est constante, ce que fait naturellement C++ pour toutes ses références (impossible de les modifier) car ça n'aurait de toute manière AUCUN SENS de modifier la référence passée en paramètre, puisque celle-ci est locale à la méthode... On est d'accord ?
Donc, 1ere remarque: il me semble que dans tous les cas, il est bon de mettre TOUS les paramètres, (quelque soit entre ou sortie) en FINAL.
2eme remarque, celà ne résoud pas le problème du const, une référence constante ne fait pas un objet constant.. alors COMMENT FAIRE ?
3eme remarque, ce problème de paramètre constant suppose également qu'on puisse distinguer les méthodes constantes (pour lesqelles 'this' est constant, ex: getters) et celles qui ne le sont pas (ex: setters)). Là non plus je n'ai rien trouvé :( (en C++ on ajoute le mot clef "const" en bout de ligne du prototype de la méthode).
Hypothèse: JAVA serait un langage merveilleux qui pourrait se passer de ce concept non moins génial parceque par ailleurs il y aurait une façon de penser que je n'ai pas saisie ? Pour l'instant j'en doute.. Mais je veux croire que JAVA est un langage merveilleux (tout comme je voulais croire que la STL c'est portable.. meuh..).
Merci à ceux qui ont la réponse de répondre !!
Yeah ! J'ai trouvé comment wrapper easily n'importe quelle classe
J'ai réfléchi, et j'me suis dis..
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public static void RefDeTableau(String[] stab)
{
// Je me sert de l'entrée
if (stab[0].compareTo("Yeah baby") == 0)
{
stab[0] = new String("Ca marche baby ?");
}
else
{
stab[0] = new String("Ca marche tout court ?");
}
}
// Quelque par dans un Main..
String[] ma_string_io = {new String("Yeah baby")};
System.out.format("Ma chaine en entrée : %s\n", ma_string_io[0]);
RefDeTableau(ma_string_io);
System.out.format("Ma chaine en sortie : %s\n", ma_string_io[0]); |
// Ca nous donne quelque chose comme :
Ma chaine en entrée : Yeah baby
Ma chaine en sortie : Ca marche baby ?
