Demande aide pour exo très simple

Version imprimable

Bonjour,

Je reviens vers vous pour savoir si j'ai bien compris ce qu'on m'a expliqué précédemment concernant les modif de variables par une méthode.
Je rappelle que je suis complètement débutante en Java. Alors veuillez m'excuser pour mes lacunes.

Voici l'exercice que j'essaie de corriger :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class TD2{ public static void main (String [] args){ char c1='a'; char c2='b'; char[] t=new char [3]; t[0]=c1; t[1]=c2; t[2]=t[0]; mixer (c1,c2,t); System.out.println ("c1="+c1 et "c2="+c2); System.out.println ("t[0]="+t[0] "t[1]="+t[1] "t[2]="+t[2]); } public static void mixer (char x, char y, char [] tc){ tc[2]=x; tc[0]=y; tc[1]=x; } }
Pouvez-vous me dire si mon raisonnement est bon svp ? (je fais du pas à pas pour bien comprendre)

c1 contient un caractère a
c2 contient un caractère b
On crée un tableau à 3 indices.

L'indice 0 contient la référence c1
L'indice 1 contient la référence c2
Et l'indice 2 contient le tableau t[0] ---> Donc d’après moi, la même référence à C1

Après la méthode mixer :

On transforme :
t en tc ---> on obtient donc un autre tableau tc mais qui va pointer vers t
les cellules se nomment tc[0] , tc[1] et tc[2]

Est ce juste jusque là ?

Les nouvelles valeurs du tableau tc sont :
indice 0 : y
indice 1 : x
indice 2 : x

Les valeurs de c1 et c2 n'ont pas changé ? (puisque ce sont des variables de type char : ni objet, ni tableau)
c1=a et c2=b

En revanche t[0], t[1] et t [2] ont changé car il s'agit de tableaux :

on affiche : t[0]= y
t[1]=x
t[2]=x

merci d'avance pour vos commentaires.
Rose

10/03/2014, 12h55
Oussapik

Bonjour,

Attention, dans ta méthode "mixer", ce ne sont pas les caractères x et y qui sont affectés aux variables, mais les valeurs fournies par les paramètres x et y.
En fin d'exécution, ton tableau vaudra donc [b,a,a] et non pas [y,x,x] comme tu les marques dans ton message.

Ensuite au niveau vocabulaire, tu marques à un moment "le tableau t[0]". t est un tableau mais t[0] est un char.

Sinon, le reste de l'explication me parait plutôt bonne :)

Ton raisonnement semble correct.
Sinon, il t'es possible d'utiliser la balise code. Ce qui facile la lecture.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package org.k.developpez.forum;
 
public class TD2 {
	public static void main(String[] args) {
		char c1 = 'a';
		char c2 = 'b';
		char[] t = new char[3];
		t[0] = c1;
		t[1] = c2;
		t[2] = t[0];
		mixer(c1, c2, t);
		System.out.println("c1=" + c1 + " et c2=" + c2);
		System.out.println("t[0]=" + t[0] + " t[1]=" + t[1] + " t[2]=" + t[2]);
	}
 
	public static void mixer(char x, char y, char[] tc) {
		tc[0] = y;
		tc[1] = x;
		tc[2] = x;
	}
}

Cordialement,
Patrick Kolodziejczyk.

Citation:
Envoyé par kolodz
Ton raisonnement semble correct.
Sinon, il t'es possible d'utiliser la balise code. Ce qui facile la lecture.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 package org.k.developpez.forum; public class TD2 { public static void main(String[] args) { char c1 = 'a'; char c2 = 'b'; char[] t = new char[3]; t[0] = c1; t[1] = c2; t[2] = t[0]; mixer(c1, c2, t); System.out.println("c1=" + c1 + " et c2=" + c2); System.out.println("t[0]=" + t[0] + " t[1]=" + t[1] + " t[2]=" + t[2]); } public static void mixer(char x, char y, char[] tc) { tc[0] = y; tc[1] = x; tc[2] = x; } }
Cordialement,
Patrick Kolodziejczyk.
Merci Patrick

Le raisonnement était peut être bon, mais d’après la réponse donnée par oussapik j'avais faux dans mon résultat.
Malheureusement, il s'agit d'un exo que j'ai effectuée en examen sur papier. Pas devant l'ordi....
Il faut vraiment que je m'entraine.

Quelqu'un aurait il un livre d'archi débutant avec exos à me conseiller ? (Ou annales) Car j'ai encore du mal avec la logique de développeur.
Merci

10/03/2014, 14h13
Rose22

Citation:

Envoyé par Oussapik

Bonjour,

Attention, dans ta méthode "mixer", ce ne sont pas les caractères x et y qui sont affectés aux variables, mais les valeurs fournies par les paramètres x et y.
En fin d'exécution, ton tableau vaudra donc [b,a,a] et non pas [y,x,x] comme tu les marques dans ton message.

Ensuite au niveau vocabulaire, tu marques à un moment "le tableau t[0]". t est un tableau mais t[0] est un char.

Sinon, le reste de l'explication me parait plutôt bonne :)

Merci oussapik pour ta réponse :lol:
Bonne journée à toi,
Rose

Salut,

Citation:

Envoyé par Rose22

Les valeurs de c1 et c2 n'ont pas changé ? (puisque ce sont des variables de type char : ni objet, ni tableau)
c1=a et c2=b

Si c1 et c2 n'ont pas changé, ce n'est pas parce que ce sont des char, mais parce que tu ne modifies que le tableau référencé par tc dans ta méthode, tableau qui est le même que celui référencé par t, passé en paramètre dans l'appel de la méthode. Mais effectivement, le fait que cela soit des char ne permet pas de les modifier en les passant en paramètres d'une méthode.

Au lieu de raisonner par rapport au fait que cela soit des types primitifs ou objet, dis-toi que toute variable est un nom donné à une référence. Ignores volontairement (temporairement) le fait que java traite des types primitifs et des types objets de façon différente : la seule différence, c'est que dans le cas type primitif, la variable contient la valeur de la variable, et dans le cas objet, la variable contient la référence (une sorte d'identifiant) à un objet.

Raisonnes par rapport à ce que tu modifies : la valeur/référence contenue dans la variable, dans un cas, ou, quelque chose dans l'objet référencé par la variable, dans l'autre. Dans le premier cas, la modification n'affecte que la variable, dans l'autre que l'objet.

Aussi le fait d'écrire :
Code:

1 2 char c1='a'; char copyc1=c1;
ne signifie pas qu'on dise que c1 et copyc1 c'est la même chose, mais simplement que copyc1 contient la même valeur que c1 au moment ou on fait =. Ensuite si on fait :

Code:

c1='b';

il n'y a que c1 qui change et pas copyc1.
et si on fait ensuite

Code:

copyc1='c';

il n'y a que copyc1 qui change et pas c1.

Pour mieux comprendre, peut-être, supprimes d'abord l'aspect "appel de méthode et passage de paramètres" ;
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 public static void main(String[] args) { char c1='a'; // c1 contient la valeur 'a' char c2='b'; // c2 contient la valeur 'b' char copyc1=c1; // copyc1 contient la valeur que contient c1 (donc copyc1 == c1 ) char copyc2=c2; // copyc2 contient la valeur que contient c2 char tab[] = new char[] { c1, c2 }; // tab est un tableau, dont la première cellule (case, indice, appelles-là comme tu préfères) tab[0] contient la valeur contenue par c1 et la seconde cellule tab[1] celle contenue par c2 char tabcopy[] = tab; // tabcopy contient la référence au tableau tab, donc tabcopy == tab (tant qu'on change ni tab, ni tabcopy) System.out.println("c1="+c1); // affiche 'a' System.out.println("c2="+c2); // affiche 'b' System.out.println("tab="+Arrays.toString(tab)); // affiche [a, b] System.out.println("copyc1="+copyc1); // affiche 'a' System.out.println("copyc2="+copyc2); // affiche 'b' System.out.println("tabcopy="+Arrays.toString(tabcopy)); // affiche [a, b] copyc1='c'; // maintenant on dit que copyc1 contient la valeur 'c' : on a pas touché à c1 là, donc c1 continu de contenir 'a' tabcopy[1]='d'; // maintenant on dit que tabcopy[1], la deuxième case du tableau référencé par tabcopy, contient 'd'. // mais le tableau référencé par tabcopy est le même que celui référencé par tab, donc il forcément modifié System.out.println("copyc1="+copyc1); // affiche 'c' System.out.println("copyc2="+copyc2); // affiche 'b' System.out.println("tabcopy="+Arrays.toString(tabcopy)); // affiche [a, d] System.out.println("c1="+c1); // affiche 'a' System.out.println("c2="+c2); // affiche 'b' System.out.println("tab="+Arrays.toString(tab)); // affiche [a, d] }
Et dans ce code, il se passe exactement la même chose (et l'affichage à l'exécution est le même) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 public static void main(String[] args) { char c1='a'; // c1 contient la valeur 'a' char c2='b'; // c2 contient la valeur 'b' char tab[] = new char[] { c1, c2 }; // tab est un tableau, dont la première cellule (case, indice, appelles-là comme tu préfères) tab[0] contient la valeur contenue par c1 et la seconde cellule tab[1] celle contenue par c2 System.out.println("c1="+c1); // affiche 'a' System.out.println("c2="+c2); // affiche 'b' System.out.println("tab="+Arrays.toString(tab)); // affiche [a, b] // quand on appelle la méthode, on obtient // char copyc1 = c1 // char copyc2 = c2 // char[] tabcopy = tab methode(c1, c2, tab); System.out.println("c1="+c1); // affiche 'a' System.out.println("c2="+c2); // affiche 'b' System.out.println("tab="+Arrays.toString(tab)); // affiche [a, d] } public static void methode(char copyc1, char copyc2, char[] tabcopy) { System.out.println("copyc1="+copyc1); // affiche 'a' System.out.println("copyc2="+copyc2); // affiche 'b' System.out.println("tabcopy="+Arrays.toString(tabcopy)); // affiche [a, b] copyc1='c'; // maintenant on dit que copyc1 contient la valeur 'c' : on a pas touché à c1 là, donc c1 continu de contenir 'a' tabcopy[1]='d'; // maintenant on dit que tabcopy[1], la deuxième case du tableau référencé par tabcopy, contient 'd'. // mais le tableau référencé par tabcopy est le même que celui référencé par tab, donc il forcément modifié System.out.println("copyc1="+copyc1); // affiche 'a' System.out.println("copyc2="+copyc2); // affiche 'c' System.out.println("tabcopy="+Arrays.toString(tabcopy)); // affiche [a, d] }

10/03/2014, 14h31
Rose22

Merci Joel pour tes explications. J'avais commencé à raisonner ainsi (tableau objet et variable simple) par rapport à ce que l'on m'a expliqué précédemment dans un autre exercice : http://www.developpez.net/forums/d14...s/#post7727967

Je trouvais cet aide mémoire plutôt simple pour résoudre mes exercices LOL