Fonctionnement d'un programme, le mecanisme d'éxecution et affichage en Java

Version imprimable

Bonjour à tous;

Je cherche à comprendre le mecanisme de fonctionnement de ces 2 programmes java, entre les fonctions et leurs appels,
Voici le premier programme affiche H;H;H, je cherche une explication pourquoi il n'affiche pas HELLO

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
public class HelloWorld{
    public static void main(String[] args){
String maString ="H";
afficheMaString (maString);
changeMaString (maString);
afficheMaString (maString);
String uneString = 
ajouteEOuL(changeMaString(changeMaString(maString)));
afficheMaString (uneString);
}
public static void afficheMaString(String maString){
System.out.print(maString + ";");
}
public static String changeMaString(String  maString){
        String uneString = ajouteEOuL (maString) + "0" ;
       return maString;
}
 public static String ajouteEOuL(String maString){
        if(maString.length() == 1){
            maString += "E";
        }else if(maString.length() == 2){
            maString += "L";
       }else{
            maString = "HELLO";
        }
        return maString;
   }
}

Le deuxième affiche des i=0, i=0 et i=0, je pensais qu'il doit afficher i=0, i=20 et i=30 j'aimerais avoir des explications sur le fonctionnement du programme.

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
39
public static void 
monSousProgramme(){
int i = 0;
afficheI(i);
changeI(i);
afficheI(i);
i = changeEtRetourne
(
changeEtRetourne(changeEtRetourne(i))
);
afficheI(i);
}
public static void afficheI(int i){
System.out.print(" i = " + i + " ;");
}
pu
blic static int changeEtRetourne
(int i){
int y = ajouteDixOuVingt(i) + 20
;
return i;
}
public static void changeI(int i){
i = 
ajouteDixO
uVingt(i) + 20
;
}
public 
static 
int ajouteDixOuVingt(int i){
if(i  == 10){
i = i + 20;  
}else{
i = i + 10;
}
return i;
}
}

Avec quelques petit commentaire pour le premier exemple :

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 class HelloWorld
{
	public static void main(String[] args)
	{
		String maString = "H";
		afficheMaString(maString); // Affiche le string H
		changeMaString(maString); // Ne fait rien dutout (voir changemastring)
		afficheMaString(maString); // Affiche le meme string que 2 lignes avant forcement
		String uneString = ajouteEOuL(changeMaString(changeMaString(maString))); // ma String valant toujours H sa valeur initiale on obtient HE 
		afficheMaString(uneString); // Affiche HE
	}
 
	public static void afficheMaString(String maString)
	{
		System.out.print(maString + ";");
	}
 
	public static String changeMaString(String maString)
	{
		String uneString = ajouteEOuL(maString) + "0"; // Ne fait rien dutout puisque la variable retournée ne va pas etre utilisé par après
		return maString;
	}
 
	public static String ajouteEOuL(String maString)
	{
		if (maString.length() == 1)
		{
			maString += "E";
		} else if (maString.length() == 2)
		{
			maString += "L";
		} else
		{
			maString = "HELLO";
		}
		return maString;
	}
}

Pour le 2 eme, ce que tu crois qu'il est censé faire ne peut pas se faire

Code:

1
2
3
4
public static void changeI(int i)
	{
		i = ajouteDixOuVingt(i) + 20;
	}

le i = quelque chose, ne va pas modifié le i passé a la fonction. Les types primitif sont passé par copie et pas par référence, donc ton i que crois qui va être modifié ne le sera pas.

Slt,
Voici qlqs explications pour ton premier progr

Code:

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args){
		String maString ="H";
		afficheMaString (maString);//jusque là ça va : résultat => H; maString vaut toujours H
		changeMaString (maString);//résultat => HE0 mais maString vaut tjs H. Tu ne pas pas récupérer HE car tu ne stockes pas le retour de ta mth
		afficheMaString (maString);//toujours résultat H; car maString vaut toujours H.  tu ne stockes pas le retour de ta mth
		String uneString = ajouteEOuL(changeMaString(changeMaString(maString)));
		//appel 1: changeMaString(maString) uneString = > résultat HE0, maString vaut toujours H. Attention tu retournes maString et non uneString
		//appel 2: changeMaString(maString) uneString = > résultat HE0, maString vaut toujours H. Attention tu retournes maString et non uneString
		//appel 3: ajouteEOuL uneString vaut HE car maString vaut H => ça revient à faire ajouteEOuL("H");
		afficheMaString (uneString);//résultat sysout => HE;
	}

Pour ton deuxième progr wax78 t'a donné les explications; Par contre un conseil évite les mth du genre

Code:

1
2
3
4
public static int changeEtRetourne(int i) {
		int y = ajouteDixOuVingt(i) + 20; // pourquoi créer y, pour ne rien en faire
		return i; //pourquoi mettre un return plutôt qu'un void => soit tu stockes le retour de ta mth soit tu créé une void
	}

12/10/2015, 11h12
Alkhan

bonjour,

Citation:

Envoyé par wax78

Les types primitif sont passé par copie et pas par référence, donc ton i que crois qui va être modifié ne le sera pas.

@wax78 je suis entièrement d'accord avec toi, mais pour évité toute confusion j'ajouterais que la référence d'une instance est aussi passé par copie, et que la création d'une nouvelle instance dans une méthode ne modifira pas l'instance passé en paramètre !