Exercices en Java (05-Méthodes)

Sébastien ESTIENNE

Ce cinquième chapitre concerne la notion de méthodes.
Le premier exercice concerne les nombres parfaits et le deuxième exercice les nombres premiers. Le troisième et le quatrième exercice portent sur le PGCD (Plus Grand Commun Diviseur). Le cinquième exercice est un programme d'éducation. Le sixième exercice fait deviner un nombre à l'utilisateur. Le septième exercice concerne la Puissance. Le huitième exercice concerne les Tours de Hanoi.

Les principales notions abordées sont les suivantes :

- Notion de méthode ;

- Composants graphiques simples ;

- Méthodes mathématiques ;

- Méthodes récursives ;

- Nombres aléatoires ;

- Visibilité des variables.

Pour faire et comprendre ces exercices, vous aurez besoin d'un certain nombre de notions sur le Java en rapport avec le chapitre. Pour cela, vous pouvez consulter les tutoriels java de developpez à l'adresse suivante : https://java.developpez.com/cours/

La documentation de l'API sur le site de Sun est aussi une mine d'or : http://java.sun.com/javase/6/docs/api/ ♪

- Titre : Exercices en Java (05-Méthodes)

- Auteur : Sébastien ESTIENNE

- Parution : 5 mai 2007

- Mise à jour : 9 septembre 2007

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2007 Sébastien ESTIENNE. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Nombre parfait

- I-1. Énoncé

- I-2. Aperçu

- I-3. Démonstration

- I-4. Solution

- II. Nombre premier

- II-1. Énoncé

- II-2. Aperçu

- II-3. Démonstration

- II-4. Solution

- III. PGCD

- III-1. Énoncé

- III-2. Aperçu

- III-3. Démonstration

- III-4. Solution

- IV. PGCD2

- IV-1. Énoncé

- IV-2. Aperçu

- IV-3. Démonstration

- IV-4. Solution

- V. Programme d'éducation

- V-1. Énoncé

- V-2. Aperçu

- V-3. Démonstration

- V-4. Solution

- VI. Deviner un nombre

- VI-1. Énoncé

- VI-2. Aperçu

- VI-3. Démonstration

- VI-4. Solution

- VII. Puissance

- VII-1. Énoncé

- VII-2. Aperçu

- VII-3. Démonstration

- VII-4. Solution

- VIII. Tours de Hanoi

- VIII-1. Énoncé

- VIII-2. Aperçu

- VIII-3. Démonstration

- VIII-4. Solution

- IX. Remerciements

I - Nombre parfait

I-1 - Énoncé

Un nombre entier est parfait si ses facteurs y compris 1 mais hormis lui-même s'additionnent pour former le nombre.
Exemple: 6 est un nombre parfait (1 + 2 + 3).
Écrivez une méthode qui détermine si son paramètre nombre est parfait. Utilisez cette méthode dans une application graphique qui affiche tous les nombres parfaits entre 1 et 1000. Affichez aussi les facteurs de chacun de ces nombres pour vérifier.

Classes de l'API utilisées :

- javax.swing.JFrame

- javax.swing.JTextArea

I-2 - Aperçu

Aperçu du résultat.

I-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

I-4 - Solution

Parfait.java

1. /*

2. * Fichier: Parfait.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import javax.swing.JFrame;

28. import javax.swing.JTextArea;

32. /**

33. * <p>Détermine tous les nombres parfaits entre 1 et 1000. Un nombre entier est parfait si ses

34. * facteurs y compris 1 mais hormis lui-même s'additionnent pour former le nombre.</p>

35. * @author Sébastien ESTIENNE.

36. */

37. public class Parfait extends JFrame

38. {

40. /**

41. * <p>Serial version UID.</p>

42. */

43. private static final long serialVersionUID = 1L;

46. /**

47. * <p>Construit l'application.</p>

48. */

49. public Parfait()

50. {

51. // Appel du constructeur de la classe JFrame.

52. super("Parfait");

54. // Créer un JTextArea pour afficher les résultats.

55. JTextArea zoneSortie = new JTextArea();

56. zoneSortie.setEditable(false);

58. // Ajoute la zone de texte à la fenêtre.

59. getContentPane().add(zoneSortie);

61. // Le contenu de la zone de texte.

62. StringBuilder sortie = new StringBuilder();

64. // Cherche les nombres parfaits.

65. sortie.append("Nombre\tFacteurs\n");

66. for(int i = 1; i < 1000; i++)

67. {

68. if(estParfait(i))

69. {

70. // Le nombre.

71. sortie.append(i).append("\t");

72. // Ses facteurs.

73. for(int j = 1; j <= i / 2; j++)

74. {

75. if(i % j == 0)

76. {

77. sortie.append(j).append(" ");

78. }

79. }

80. sortie.append("\n");

81. }

82. }

84. // Met à jour la zone de texte.

85. zoneSortie.setText(sortie.toString());

87. // Modifie les propriétés de la fenêtre.

88. setSize(250, 130);

89. setLocation(100, 100);

90. setVisible(true);

91. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

92. }

95. /**

96. * <p>Déterminer si un nombre est parfait.</p>

97. * @param nombre Le nombre à vérifier.

98. * @return true si le nombre est parfait, false sinon.

99. */

100. public boolean estParfait(int nombre)

101. {

102. // Somme des facteurs du nombre.

103. int somme = 0;

105. // Déterminer les facteurs du nombre.

106. for(int i = 1; i <= nombre / 2; i++)

107. {

108. if(nombre % i == 0)

109. {

110. somme += i;

111. }

112. }

114. return (nombre == somme);

115. }

118. /**

119. * <p>Lance l'application.</p>

120. * @param args Les paramètres de la ligne de commande.

121. */

122. public static void main(String[] args)

123. {

124. new Parfait();

125. }

126. }

II - Nombre premier

II-1 - Énoncé

Un nombre entier est premier s'il n'est divisible que par 1 et lui-même.
Exemple : 2, 7, 13 sont des nombres premiers alors que 4, 9, 12 n'en sont pas.
Écrivez une méthode qui détermine si un nombre est premier. Insérez cette méthode dans une application graphique pour trouver tous les nombres premiers entre 1 et 1000.

Classes de l'API utilisées :

- javax.swing.JFrame

- javax.swing.JScrollPane

- javax.swing.JTextArea

II-2 - Aperçu

Aperçu du résultat.

II-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

II-4 - Solution

Premier.java

1. /*

2. * Fichier: Premier.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import javax.swing.JFrame;

28. import javax.swing.JScrollPane;

29. import javax.swing.JTextArea;

33. /**

34. * <p>Détermine tous les nombres premiers entre 1 et 1000. Un nombre entier est premier s'il n'est

35. * divisible que par 1 et lui-même.</p>

36. * @author Sébastien ESTIENNE.

37. */

38. public class Premier extends JFrame

39. {

41. /**

42. * <p>Serial version UID.</p>

43. */

44. private static final long serialVersionUID = 1L;

47. /**

48. * <p>Construit l'application.</p>

49. */

50. public Premier()

51. {

52. // Appel du constructeur de la classe JFrame.

53. super("Premier");

55. // Créer un JTextArea pour afficher les résultats.

56. JTextArea zoneSortie = new JTextArea();

57. zoneSortie.setEditable(false);

59. // Relier JTextArea à un JScrollPane pour pouvoir faire défiler les étapes.

60. JScrollPane defilant = new JScrollPane(zoneSortie);

62. // Ajoute la zone de texte à la fenêtre.

63. getContentPane().add(defilant);

65. // Pour compter les nombres premiers.

66. int cpt = 0;

68. // Le contenu de la zone de texte.

69. StringBuilder sortie = new StringBuilder();

71. // Cherche les nombres premiers.

72. sortie.append("Nombres\n");

73. for(int i = 1; i < 1000; i++)

74. {

75. if(estPremier(i))

76. {

77. cpt++;

78. sortie.append(i).append(" ");

79. if(cpt % 10 == 0)

80. {

81. sortie.append("\n");

82. }

83. }

84. }

86. // Met à jour la zone de texte.

87. zoneSortie.setText(sortie.toString());

89. // Modifie les propriétés de la fenêtre.

90. setSize(300, 200);

91. setLocation(100, 100);

92. setVisible(true);

93. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

94. }

97. /**

98. * <p>Détermine si un nombre est premier.</p>

99. * @param nombre Le nombre à vérifier.

100. * @return true si le nombre est premier, sinon false.

101. */

102. public boolean estPremier(int nombre)

103. {

104. // Limite des facteurs.

105. int limite = (int) Math.sqrt(nombre);

107. // Vérifier s'il possède des facteurs.

108. for(int i = 2; i <= limite; i++)

109. {

110. if(nombre % i == 0)

111. {

112. return false;

113. }

114. }

116. return true;

117. }

120. /**

121. * <p>Lance l'application.</p>

122. * @param args Les paramètres de la ligne de commande.

123. */

124. public static void main(String[] args)

125. {

126. new Premier();

127. }

128. }

III - PGCD

III-1 - Énoncé

Le plus grand diviseur commun (PGCD) de deux nombres entiers est le plus grand entier qui puisse diviser les deux nombres.
Écrivez une méthode non récursive qui renvoie le PGCD de deux nombres passés en paramètres. Utilisez cette méthode dans une application graphique qui demande les deux valeurs à l'utilisateur et affiche le résultat dans une barre d'état.

Classes de l'API utilisées :

- javax.swing.JFrame

- javax.swing.JOptionPane

- javax.swing.JTextArea

III-2 - Aperçu

Aperçu du résultat.

Aperçu du résultat.

III-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

III-4 - Solution

Pgcd.java

1. /*

2. * Fichier: Pgcd.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import javax.swing.JFrame;

28. import javax.swing.JOptionPane;

29. import javax.swing.JTextArea;

33. /**

34. * <p>Méthode non récursive qui renvoie le PGCD de deux nombres. Le plus grand diviseur commun

35. * (PGCD) de deux nombres entiers est le plus grand entier qui puisse diviser les deux nombres.</p>

36. * @author Sébastien ESTIENNE.

37. */

38. public class Pgcd extends JFrame

39. {

40. /**

41. * <p>Serial version UID.</p>

42. */

43. private static final long serialVersionUID = 1L;

46. /**

47. * <p>Construit l'application.</p>

48. */

49. public Pgcd()

50. {

51. // Appel du constructeur de la classe JFrame.

52. super("Pgcd");

54. // Créer un JTextArea pour afficher les résultats.

55. JTextArea zoneSortie = new JTextArea();

56. zoneSortie.setEditable(false);

58. // Ajoute la zone de texte à la fenêtre.

59. getContentPane().add(zoneSortie);

61. // Premier nombre entré par l'utilisateur.

62. String sNombre1 = "";

64. // Second nombre entré par l'utilisateur.

65. String sNombre2 = "";

67. // Premier nombre converti.

68. int nombre1 = 0;

70. // Second nombre converti.

71. int nombre2 = 0;

73. // Calcul du pgcd.

74. int resultat = 0;

76. // Demander à l'utilisateur un premier nombre et le convertir.

77. sNombre1 = JOptionPane.showInputDialog("Entrez un premier nombre :\n\n");

78. try

79. {

80. nombre1 = Integer.parseInt(sNombre1);

81. }

82. catch(NumberFormatException e)

83. {

84. nombre1 = 0;

85. }

87. // Demander à l'utilisateur un deuxième nombre et le convertir.

88. sNombre2 = JOptionPane.showInputDialog("Entrez un second nombre :\n\n");

89. try

90. {

91. nombre2 = Integer.parseInt(sNombre2);

92. }

93. catch(NumberFormatException e)

94. {

95. nombre2 = 0;

96. }

98. // Calculer le pgcd de ces deux nombres

99. resultat = pgcd(nombre1, nombre2);

101. // Met à jour la zone de texte.

102. zoneSortie.setText("pgcd( " + Integer.toString(nombre1) + ", " + Integer.toString(nombre2)

103. + " ) = " + Integer.toString(resultat));

105. // Modifie les propriétés de la fenêtre.

106. setSize(200, 100);

107. setLocation(100, 100);

108. setVisible(true);

109. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

110. }

113. /**

114. * <p>Déterminer le pgcd de deux nombres.</p>

115. * @param x Le premier nombre.

116. * @param y Le second nombre.

117. * @return Le pgcd de des deux nombres.

118. */

119. public int pgcd(int x, int y)

120. {

121. while(x != 0 && y != 0)

122. {

123. if(x > y)

124. {

125. x -= y;

126. }

127. else

128. {

129. y -= x;

130. }

131. }

133. if(x != 0)

134. {

135. return x;

136. }

138. return y;

139. }

142. /**

143. * <p>Lance l'application.</p>

144. * @param args Les paramètres de la ligne de commande.

145. */

146. public static void main(String[] args)

147. {

148. new Pgcd();

149. }

150. }

IV - PGCD2

IV-1 - Énoncé

Le plus grand diviseur commun (PGCD) de deux nombres entiers est le plus grand entier qui puisse diviser les deux nombres.
Écrivez une méthode récursive qui renvoie le PGCD de deux nombres passés en paramètres. Utilisez cette méthode dans une application graphique qui demande les deux valeurs à l'utilisateur et affiche le résultat dans une barre d'état.

Classes de l'API utilisées :

- javax.swing.JFrame

- javax.swing.JOptionPane

- javax.swing.JTextArea

IV-2 - Aperçu

Aperçu du résultat.

Aperçu du résultat.

IV-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

IV-4 - Solution

Pgcd2.java

1. /*

2. * Fichier: Pgcd2.java

3. * Crée le: 03 décembre 2006.

4. * Auteurs: Sébastien ESTIENNE.

5. * SiteWeb: http://www.prog-info.org/

6. *

7. * This program is free software; you can redistribute it and/or modify

8. * it under the terms of the GNU General Public License as published by

9. * the Free Software Foundation; either version 2 of the License, or

10. * (at your option) any later version.

11. *

12. * This program is distributed in the hope that it will be useful,

13. * but WITHOUT ANY WARRANTY; without even the implied warranty of

14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

15. * GNU General Public License for more details.

16. *

17. * You should have received a copy of the GNU General Public License

18. * along with this program; if not, write to the Free Software

19. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

20. */

22. package chapitre5;

26. import javax.swing.JFrame;

27. import javax.swing.JOptionPane;

28. import javax.swing.JTextArea;

32. /**

33. * <p>Méthode récursive qui renvoie le PGCD de deux nombres. Le plus grand diviseur commun (PGCD)

34. * de deux nombres entiers est le plus grand entier qui puisse diviser les deux nombres.</p>

35. * @author Sébastien ESTIENNE.

36. */

37. public class Pgcd2 extends JFrame

38. {

39. /**

40. * <p>Serial version UID.</p>

41. */

42. private static final long serialVersionUID = 1L;

45. /**

46. * <p>Construit l'application.</p>

47. */

48. public Pgcd2()

49. {

50. // Appel du constructeur de la classe JFrame.

51. super("Pgcd2");

53. // Créer un JTextArea pour afficher les résultats.

54. JTextArea zoneSortie = new JTextArea();

55. zoneSortie.setEditable(false);

57. // Ajoute la zone de texte à la fenêtre.

58. getContentPane().add(zoneSortie);

60. // Premier nombre entré par l'utilisateur.

61. String sNombre1 = "";

63. // Second nombre entré par l'utilisateur.

64. String sNombre2 = "";

66. // Premier nombre converti.

67. int nombre1 = 0;

69. // Second nombre converti.

70. int nombre2 = 0;

72. // Calcul du pgcd.

73. int resultat = 0;

75. // Demander à l'utilisateur un premier nombre et le convertir.

76. sNombre1 = JOptionPane.showInputDialog("Entrez un premier nombre :\n\n");

77. try

78. {

79. nombre1 = Integer.parseInt(sNombre1);

80. }

81. catch(NumberFormatException e)

82. {

83. nombre1 = 0;

84. }

86. // Demander à l'utilisateur un deuxième nombre et le convertir.

87. sNombre2 = JOptionPane.showInputDialog("Entrez un second nombre :\n\n");

88. try

89. {

90. nombre2 = Integer.parseInt(sNombre2);

91. }

92. catch(NumberFormatException e)

93. {

94. nombre2 = 0;

95. }

97. // Calculer le pgcd de ces deux nombres

98. resultat = pgcd(nombre1, nombre2);

100. // Met à jour la zone de texte.

101. zoneSortie.setText("pgcd( " + Integer.toString(nombre1) + ", " + Integer.toString(nombre2)

102. + " ) = " + Integer.toString(resultat));

104. // Modifie les propriétés de la fenêtre.

105. setSize(200, 100);

106. setLocation(100, 100);

107. setVisible(true);

108. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

109. }

112. /**

113. * <p>Déterminer le pgcd de deux nombres.</p>

114. * @param x Le premier nombre.

115. * @param y Le second nombre.

116. * @return Le pgcd de des deux nombres.

117. */

118. public int pgcd(int x, int y)

119. {

120. if(y == 0)

121. {

122. return x;

123. }

125. return pgcd(y, x % y);

126. }

129. /**

130. * <p>Lance l'application.</p>

131. * @param args Les paramètres de la ligne de commande.

132. */

133. public static void main(String[] args)

134. {

135. new Pgcd2();

136. }

137. }

V - Programme d'éducation

V-1 - Énoncé

Construisez un programme qui aide les étudiants de niveau élémentaire à apprendre l'addition, la soustraction, la multiplication et la division.
L'étudiant doit pouvoir choisir au lancement du programme entre cinq types de problèmes arithmétiques via une boîte de dialogue :

- 1 : addition ;

- 2 : soustraction ;

- 3 : multiplication ;

- 4 : division ;

- 5 : tous types.

L'étudiant doit ensuite pouvoir sélectionner le niveau de difficulté toujours via une boîte de dialogue :

- 1 : nombres à un seul chiffre ;

- 2 : nombres à deux chiffres ;

- 3 : nombres à 3 chiffres.

Utilisez « Math.random » pour générer aléatoirement des nombres.
Le programme affiche ensuite la question dans en haut de la fenêtre. Exemple : Combien fait 27 + 35? L'étudiant entre sa réponse au moyen d'un JTextField.
Si la réponse est correcte, un des messages suivants est affiché dans l'application :

- C'est très bien !

- Excellent !

- Tu fais du beau travail !

- Bonne réponse, continue.

Et une nouvelle question est posée.
Si la réponse est incorrecte, un des messages suivants est affiché dans l'application :

- Désolé, essaie encore. ;

- Mauvaise réponse. Essaie une autre fois ;

- Non, essaie à nouveau.

Et la même question est reposée.
Pour déterminer la phrase qui sera affichée, utilisez un nombre aléatoire entre 1 et 4. Utilisez ensuite une structure switch pour afficher les messages.
Le programme doit compter le nombre de réponses correctes et incorrectes entrées par l'étudiant. Au bout de 10 réponses, calculez le taux de réponses correctes. Si celui-ci est inférieur à 75 %, affichez le message « SVP, Demande à ton professeur de t'aider ».
Une nouvelle session doit ensuite démarrer.

Classes de l'API utilisées :

- java.awt.Container

- java.awt.FlowLayout

- java.awt.event.ActionEvent

- java.awt.event.ActionListener

- javax.swing.JFrame

- javax.swing.JLabel

- javax.swing.JOptionPane

- javax.swing.JTextField

V-2 - Aperçu

Aperçu du résultat.

Aperçu du résultat.

V-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

V-4 - Solution

Education.java

1. /*

2. * Fichier: Education.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import java.awt.Container;

28. import java.awt.FlowLayout;

29. import java.awt.event.ActionEvent;

30. import java.awt.event.ActionListener;

32. import javax.swing.JFrame;

33. import javax.swing.JLabel;

34. import javax.swing.JOptionPane;

35. import javax.swing.JTextField;

39. /**

40. * <p>Programme qui aide les étudiants de niveau élémentaire à apprendre l'addition, la

41. * soustraction, la multiplication et la division.</p>

42. * @author Sébastien ESTIENNE.

43. */

44. public class Education extends JFrame implements ActionListener

45. {

46. /**

47. * <p>Serial version UID.</p>

48. */

49. private static final long serialVersionUID = 1L;

51. /** Solution de l'opération. */

52. private int solution = 0;

54. /** Nombre de réponses correctes. */

55. private int nbRepCorrectes = 0;

57. /** Nombre de réponses fausses. */

58. private int nbRepFausses = 0;

60. /** Niveau de difficulté. */

61. private int niveau = 0;

63. /** Type d'exercice (+, -, *, /, tous). */

64. private int typeExo = 0;

66. /** L'opération entre les deux nombres. */

67. private char cOperateur = '+';

69. /** Etiquette pour la question. */

70. private JLabel etiquetteQuestion;

72. /** Etiquette pour la réponse. */

73. private JLabel etiquetteReponse;

75. /** Champ texte pour la réponse. */

76. private JTextField champReponse;

78. /** Etiquette pour un commentaire. */

79. private JLabel etiquetteCommentaire;

82. /**

83. * <p>Construit l'application.</p>

84. */

85. public Education()

86. {

87. // Appel du constructeur de la classe JFrame.

88. super("Education");

90. // Obtenir le panneau de contenu et changer son layout en un FlowLayout.

91. Container conteneur = getContentPane();

92. conteneur.setLayout(new FlowLayout());

94. // Créer l'étiquette et le champ texte du nombre à deviner.

95. this.etiquetteQuestion = new JLabel("");

96. conteneur.add(this.etiquetteQuestion);

98. this.etiquetteReponse = new JLabel("Votre réponse : ");

99. conteneur.add(this.etiquetteReponse);

101. this.champReponse = new JTextField(5);

102. this.champReponse.setEditable(true);

103. conteneur.add(this.champReponse);

104. this.champReponse.addActionListener(this);

106. this.etiquetteCommentaire = new JLabel("");

107. conteneur.add(this.etiquetteCommentaire);

109. // Initialiser le niveau de difficulté.

110. iniNiveau();

112. // Initialiser le type d'exercice.

113. iniExercice();

115. // Initialiser la question.

116. nouvelleQuestion();

118. // Modifie les propriétés de la fenêtre.

119. setSize(210, 110);

120. setLocation(100, 100);

121. setVisible(true);

122. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

123. }

126. /**

127. * <p>Traiter une réponse.</p>

128. * @param actionEvent Un événement sémantique qui indique qu'une action s'est produite dans le

129. *        composant concerné.

130. */

131. public void actionPerformed(ActionEvent actionEvent)

132. {

133. // Reponse de l'utilisateur.

134. int reponse = 0;

135. // Indique si la réponse est valide ou non.

136. boolean valide = true;

138. // Convertir le nombre entré par l'utilisateur.

139. try

140. {

141. reponse = Integer.parseInt(this.champReponse.getText());

142. }

143. // Traite le cas lorsque la valeur rentrée par l'utilisateur n'est pas un nombre entier.

144. catch(NumberFormatException e)

145. {

146. valide = false;

147. }

149. // Vider les champs.

150. this.champReponse.setText("");

151. this.etiquetteCommentaire.setText("");

153. // Vérifier la validité de la réponse.

154. String commentaire = "";

155. if(valide && reponse == this.solution)

156. {

157. commentaire = reponseCorrecte();

158. this.nbRepCorrectes++;

159. nouvelleQuestion();

160. }

161. else

162. {

163. commentaire = reponseFausse();

164. this.nbRepFausses++;

165. }

167. // Modifie les commentaires suite à la réponse de l'utilisateur.

168. this.etiquetteCommentaire.setText(commentaire);

170. // Cas de fin de l'exercice.

171. if(this.nbRepCorrectes + this.nbRepFausses == 10)

172. {

173. // Message de taux de réussite.

174. String message;

176. // Taux de réussite.

177. int taux;

179. taux = this.nbRepCorrectes * 100 / (this.nbRepCorrectes + this.nbRepFausses);

180. message = "Taux de réussite : " + taux + "%.";

182. if(taux < 75)

183. {

184. message += "\n\nDemande à ton professeur de t'aider.";

185. }

187. // Affiche le résultat.

188. JOptionPane.showMessageDialog(null, message, "Taux de réussite",

189. JOptionPane.INFORMATION_MESSAGE);

191. // Initialisation pour l'exercice suivant.

192. iniNiveau();

193. iniExercice();

194. nouvelleQuestion();

195. this.nbRepCorrectes = 0;

196. this.nbRepFausses = 0;

197. }

199. }

202. /**

203. * <p>Génère un nombre aléatoire.</p>

204. * @return Le nombre généré aléatoirement.

205. */

206. public int genereNombre()

207. {

208. return (1 + (int) (Math.random() * Math.pow(10.0, this.niveau)));

209. }

212. /**

213. * <p>Afficher une nouvelle question dans la barre d'état.</p>

214. */

215. public void nouvelleQuestion()

216. {

217. // Initialiser les nombres.

218. int nombre1 = genereNombre();

219. int nombre2 = genereNombre();

221. // Génère un opérateur.

222. if(this.typeExo == 5)

223. {

224. // Nombre aléatoire entre 0 et 3.

225. int i = (int) (Math.random() * 4);

227. // Sélectionne un type d'opération au hasard.

228. switch(i)

229. {

230. case 1:

231. this.cOperateur = '+';

232. break;

233. case 2:

234. this.cOperateur = '-';

235. break;

236. case 3:

237. this.cOperateur = '*';

238. break;

239. default:

240. this.cOperateur = '/';

241. break;

242. }

243. }

245. // Calculer la solution.

246. switch(this.typeExo)

247. {

248. case 1:

249. this.solution = nombre1 + nombre2;

250. break;

251. case 2:

252. this.solution = nombre1 - nombre2;

253. break;

254. case 3:

255. this.solution = nombre1 * nombre2;

256. break;

257. case 4:

258. this.solution = nombre1 / nombre2;

259. break;

260. default:

261. break;

262. }

264. // Met à jour la question.

265. this.etiquetteQuestion.setText("Combien font " + nombre1 + " " + this.cOperateur + " "

266. + nombre2 + ".");

267. }

270. /**

271. * <p>Sélectionne au hasard une phrase de réponse correcte.</p>

272. * @return La réponse correcte au hasard.

273. */

274. public String reponseCorrecte()

275. {

276. // Nombre aléatoire entre 0 et 3.

277. int i = (int) (Math.random() * 4);

279. // Initialisation de la phrase en fonction du nombre aléatoire.

280. switch(i)

281. {

282. case 0:

283. return "C'est très bien!";

284. case 1:

285. return "Excellent!";

286. case 2:

287. return "Tu fais du beau travail!";

288. default:

289. return "Bonne réponse, continue!";

290. }

291. }

294. /**

295. * <p>Sélectionne au hasard une phrase de réponse fausse.</p>

296. * @return La réponse fausse au hasard.

297. */

298. public String reponseFausse()

299. {

300. // Nombre aléatoire entre 0 et 3.

301. int i = (int) (Math.random() * 4);

303. // Initialisation de la phrase en fonction du nombre aléatoire.

304. switch(i)

305. {

306. case 0:

307. return "Désolé, essai encore.";

308. case 1:

309. return "Mauvaise réponse. Essaie encore.";

310. case 2:

311. return "Ne lâche pas, tu y es presque!";

312. default:

313. return "Non, essaie à nouveau.";

314. }

315. }

318. /**

319. * <p>Initialisation du niveau de difficulté.</p>

320. */

321. public void iniNiveau()

322. {

323. String sNiveau = "";

325. this.niveau = 0;

327. // Demander à l'utilisateur le niveau de difficulté tant que le niveau saisi est incorrect.

328. while(this.niveau < 1 || this.niveau > 3)

329. {

330. sNiveau = JOptionPane.showInputDialog("Entrez le niveau de difficulté : \n"

331. + " 1 - Facile\n" + " 2 - Moyen\n" + " 3 - Difficile\n\n");

333. try

334. {

335. this.niveau = Integer.parseInt(sNiveau);

336. }

337. catch(NumberFormatException e)

338. {

339. this.niveau = -1;

340. }

341. }

342. }

345. /**

346. * <p>Initialisation du type d'exercice.</p>

347. */

348. public void iniExercice()

349. {

350. String sTypeExo;

352. this.typeExo = 0;

354. // Demander à l'utilisateur le type d'exercice tant que le niveau saisi est incorrect.

355. while(this.typeExo < 1 || this.typeExo > 5)

356. {

357. sTypeExo = JOptionPane.showInputDialog("Entrez le niveau de difficulté : \n"

358. + " 1 - Addition\n" + " 2 - Soustraction\n" + " 3 - Multiplication\n"

359. + " 4 - Division\n" + " 5 - Tous types\n\n");

361. try

362. {

363. this.typeExo = Integer.parseInt(sTypeExo);

364. }

365. catch(NumberFormatException e)

366. {

367. this.typeExo = -1;

368. }

369. }

371. // Sélectionne un type d'opération.

372. switch(this.typeExo)

373. {

374. case 1:

375. this.cOperateur = '+';

376. break;

377. case 2:

378. this.cOperateur = '-';

379. break;

380. case 3:

381. this.cOperateur = '*';

382. break;

383. case 4:

384. this.cOperateur = '/';

385. break;

386. default:

387. break;

388. }

389. }

392. /**

393. * <p>Lance l'application.</p>

394. * @param args Les paramètres de la ligne de commande.

395. */

396. public static void main(String[] args)

397. {

398. new Education();

399. }

400. }

VI - Deviner un nombre

VI-1 - Énoncé

Écrivez une application graphique qui demande à l'utilisateur de deviner un nombre entier (choisi aléatoirement) entre 1 et 1000. L'application affiche « Devinez le nombre que j'ai choisi entre 1 et 1000 : ».
Un JTextField en dessous permet à l'utilisateur de rentrer un nombre et de valider avec la touche entrée. Si la réponse est incorrecte le programme affiche « Trop grand, essayez encore! » ou « Trop petit, essayez encore » dans une barre d'état et vide le JTextField. Lorsque la réponse est correcte, affichez « Félicitation, vous avez deviné le nombre! ».
Comptez le nombre d'essais du joueur. Quand le joueur a trouvé le nombre, si le nombre de tentatives est inférieur à 10 affichez « Soit vous connaissez le secret, soit vous êtes chanceux! ». Si le nombre de tentatives est égal à 10 affichez « D'accord, vous connaissez le secret! ». Sinon, affichez « Vous pouvez certainement faire mieux! ».

Classes de l'API utilisées :

- java.awt.Container

- java.awt.FlowLayout

- java.awt.event.ActionEvent

- java.awt.event.ActionListener

- javax.swing.JFrame

- javax.swing.JLabel

- javax.swing.JOptionPane

- javax.swing.JTextField

VI-2 - Aperçu

Aperçu du résultat.

VI-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VI-4 - Solution

Deviner.java

1. /*

2. * Fichier: Deviner.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import java.awt.Container;

28. import java.awt.FlowLayout;

29. import java.awt.event.ActionEvent;

30. import java.awt.event.ActionListener;

32. import javax.swing.JFrame;

33. import javax.swing.JLabel;

34. import javax.swing.JOptionPane;

35. import javax.swing.JTextField;

39. /**

40. * <p>Fait deviner un nombre entier choisi aléatoirement à l'utilisateur entre 1 et 1000.</p>

41. * @author Sébastien ESTIENNE.

42. */

43. public class Deviner extends JFrame implements ActionListener

44. {

45. /**

46. * <p>Serial version UID.</p>

47. */

48. private static final long serialVersionUID = 1L;

50. /** Le nombre de l'utilisateur converti en entier. */

51. private int nombre = 0;

53. /** Le nombre à deviner. */

54. private int hasard = 0;

56. /** Le nombre d'essais de l'utilisateur. */

57. private int nbEssais = 0;

59. /** Indique si la saisie de l'utilisateur est valide. */

60. private boolean saisieValide = false;

62. /** Etiquette du nombre à deviner. */

63. private JLabel etiquetteDevine;

65. /** Champ texte du nombre à deviner. */

66. private JTextField champDevine;

68. /** Etiquette indiquant l'état du jeu. */

69. private JLabel etiquetteEtat;

72. /**

73. * <p>Construction de l'application.</p>

74. */

75. public Deviner()

76. {

77. // Appel du constructeur de la classe JFrame.

78. super("Deviner");

80. // Obtenir le panneau de contenu et changer son layout en un FlowLayout.

81. Container conteneur = getContentPane();

82. conteneur.setLayout(new FlowLayout());

84. // Créer l'étiquette et le champ texte du nombre à deviner.

85. this.etiquetteDevine = new JLabel("Devinez le nombre que j'ai choisi entre " + "1 et 1000 :");

86. conteneur.add(this.etiquetteDevine);

87. this.champDevine = new JTextField(5);

88. this.champDevine.setEditable(true);

89. conteneur.add(this.champDevine);

90. this.champDevine.addActionListener(this);

91. this.etiquetteEtat = new JLabel("");

92. conteneur.add(this.etiquetteEtat);

94. // Initialiser le nombre à deviner.

95. this.hasard = initialiserNombre();

97. // Initialiser le nombre d'essais.

98. this.nbEssais = 0;

100. // Modifie les propriétés de la fenêtre.

101. setSize(340, 110);

102. setLocation(100, 100);

103. setVisible(true);

104. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

105. }

108. /**

109. * <p>Traite une proposition de l'utilisateur.</p>

110. * @param actionEvent Un événement sémantique qui indique qu'une action s'est produite dans le

111. *        composant concerné.

112. */

113. public void actionPerformed(ActionEvent actionEvent)

114. {

115. // Convertir le nombre entré par l'utilisateur.

116. try

117. {

118. this.nombre = Integer.parseInt(this.champDevine.getText());

119. this.saisieValide = true;

120. }

121. // Effectue un traitement particulier lorsque la valeur saisie n'est pas un entier.

122. catch(NumberFormatException e)

123. {

124. this.saisieValide = false;

125. }

127. // Vider le champ de la proposition de l'utilisateur.

128. this.champDevine.setText("");

130. // Afficher un message d'état du jeu.

131. afficherMessage();

132. }

135. /**

136. * <p>Initialiser le nombre à deviner.</p>

137. * @return Le nombre à deviner.

138. */

139. public int initialiserNombre()

140. {

141. return (1 + (int) (Math.random() * 1000));

142. }

145. /**

146. * <p>Détermine si l'utilisateur a trouvé le nombre et affiche le message adéquat dans la barre

147. * d'état.</p>

148. */

149. public void afficherMessage()

150. {

151. if(!this.saisieValide)

152. {

153. this.etiquetteEtat.setText("La valeur saisie n'est pas un nombre.");

154. }

155. else if(this.nombre == this.hasard)

156. {

157. // Le commentaire.

158. String commentaire;

160. // Afficher un message de félicitation dans la barre d'état.

161. this.etiquetteEtat.setText("Félicitation vous avez trouvé. Vous pouvez recommencer.");

163. // Déterminer le commentaire à afficher.

164. if(this.nbEssais == 10)

165. {

166. commentaire = "D'accord, vous connaissez le secret!";

167. }

168. else if(this.nbEssais < 10)

169. {

170. commentaire = "Soit vous connaissez le secret, soit vous êtes chanceux!";

171. }

172. else

173. {

174. commentaire = "Vous pouvez certainement faire mieux!";

175. }

177. // Afficher la phrase aléatoire.

178. JOptionPane.showMessageDialog(null, commentaire, "Commmentaire",

179. JOptionPane.INFORMATION_MESSAGE);

181. // Réinitialiser le nombre à deviner et le nombre d'essais.

182. this.hasard = initialiserNombre();

183. this.nbEssais = 0;

184. }

185. // Afficher une aide pour trouver le nombre et incrémenter le nombre d'essais.

186. else

187. {

188. if(this.nombre < this.hasard)

189. {

190. this.etiquetteEtat.setText("Trop petit, essayez encore.");

191. this.nbEssais++;

192. }

193. else

194. {

195. this.etiquetteEtat.setText("Trop grand, essayez encore.");

196. this.nbEssais++;

197. }

198. }

199. }

202. /**

203. * <p>Lance l'application.</p>

204. * @param args Les paramètres de la ligne de commande.

205. */

206. public static void main(String[] args)

207. {

208. new Deviner();

209. }

210. }

VII - Puissance

VII-1 - Énoncé

Écrivez une méthode récursive puissance(bas, exposant) qui renvoie base à la puissance exposant.
Exemple : puissance(5, 3) = 5 * 5 * 5.
Intégrez cette méthode à une application graphique qui permette à l'utilisateur d'entrer la base et l'exposant.

Classes de l'API utilisées :

- java.awt.Container

- javax.swing.JFrame

- javax.swing.JOptionPane

- javax.swing.JTextArea

VII-2 - Aperçu

Aperçu du résultat.

Aperçu du résultat.

VII-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VII-4 - Solution

Puissance.java

1. /*

2. * Fichier: Puissance.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import java.awt.Container;

29. import javax.swing.JFrame;

30. import javax.swing.JOptionPane;

31. import javax.swing.JTextArea;

35. /**

36. * <p>Classe illustrant la méthode récursive puissance.</p>

37. * @author Sébastien ESTIENNE.

38. */

39. public class Puissance extends JFrame

40. {

41. /**

42. * <p>Serial version UID.</p>

43. */

44. private static final long serialVersionUID = 1L;

47. /**

48. * <p>Construction de l'application.</p>

49. */

50. public Puissance()

51. {

52. // Appel du constructeur de la classe JFrame.

53. super("Puissance");

55. // Créer un JTextArea pour afficher les résultats.

56. JTextArea zoneSortie = new JTextArea();

57. zoneSortie.setEditable(false);

59. // Obtenir le panneau de contenu.

60. Container conteneur = getContentPane();

62. // Lier aireSortie au conteneur.

63. conteneur.add(zoneSortie);

65. // Demande à l'utilisateur un premier nombre et le converti.

66. int base = 0;

67. boolean saisieValide = false;

68. while(!saisieValide)

69. {

70. // Demander à l'utilisateur la base.

71. String sBase = JOptionPane.showInputDialog("Entrez la base :\n\n");

72. try

73. {

74. // Essaie de convertir la valeur saisie.

75. base = Integer.parseInt(sBase);

76. saisieValide = true;

77. }

78. // Effectue un traitement particulier lorsque la valeur saisie n'est pas un entier.

79. catch(NumberFormatException e)

80. {

81. saisieValide = false;

82. }

83. }

85. // Demander à l'utilisateur un deuxième nombre et le convertir.

86. int exposant = 0;

87. saisieValide = false;

88. while(!saisieValide)

89. {

90. // Demander à l'utilisateur l'exposant.

91. String sExposant = JOptionPane.showInputDialog("Entrez l'exposant :\n\n");

92. try

93. {

94. // Essaie de convertir la valeur saisie.

95. exposant = Integer.parseInt(sExposant);

96. saisieValide = true;

97. }

98. // Effectue un traitement particulier lorsque la valeur saisie n'est pas un entier.

99. catch(NumberFormatException e)

100. {

101. saisieValide = false;

102. }

103. }

105. // Calculer base à la puissance exposant.

106. int resultat = puissance(base, exposant);

108. // Met à jour la zone de sortie.

109. zoneSortie.setText(base + " puissance " + exposant + " est égal à "

110. + Integer.toString(resultat));

112. // Modifie les propriétés de la fenêtre.

113. setSize(300, 150);

114. setLocation(100, 100);

115. setVisible(true);

116. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

117. }

120. /**

121. * <p>Calculer une 'base' à la puissance 'exposant'.</p>

122. * @param b Le nombre à élever (la base).

123. * @param e L'exposant du nombre.

124. * @return Le résultat du nombre élevé à la puissance.

125. */

126. public int puissance(int b, int e)

127. {

128. // b : base & e : exposant

129. if(e == 1)

130. {

131. return b;

132. }

134. return b * puissance(b, e - 1);

135. }

138. /**

139. * <p>Lance l'application.</p>

140. * @param args Les paramètres de la ligne de commande.

141. */

142. public static void main(String[] args)

143. {

144. new Puissance();

145. }

146. }

VIII - Tours de Hanoi

VIII-1 - Énoncé

Les tours de Hanoi sont composées de trois piquets. Au départ, la pile contient un certain nombre de disques sur le premier piquet empilés du plus grand au plus petit, de bas en haut. Le but est de déplacer tous les disques du premier piquet au troisième piquet sans que jamais un disque plus grand ne se retrouve au-dessus d'un disque plus petit. Le deuxième piquet permet d'empiler temporairement des disques.
L'algorithme récursif permettant de résoudre ce problème est le suivant :

1. Déplacer n-1 disques du premier piquet au deuxième piquet en utilisant le troisième piquet comme piquet d'empilement temporaire ;

2. Déplacer le dernier disque du premier piquet au troisième piquet. (le plus grand) ;

3. Déplacer n-1 disques du deuxième piquet au troisième piquet en utilisant le premier piquet comme piquet d'empilement temporaire.

Créez une application graphique résolvant ce problème. Le nombre de disques étant saisi par l'intermédiaire d'un JTextField. La méthode tour à écrire prend 4 paramètres : le nombre de disques, le piquet où sont placés les disques au départ, le piquet servant d'empilement temporaire et le piquet sur lequel doivent être les disques à la fin.
Ainsi le programme doit afficher les étapes de déplacement des disques d'un piquet à un autre dans un JTextArea avec défilement.
Exemple avec un nombre de disques égal à 3 :
1 -> 3
1 -> 2
3 -> 2
1 -> 3
2 -> 1
2 -> 3
1 -> 3

Classes de l'API utilisées :

- java.awt.Container

- javax.swing.JFrame

- javax.swing.JOptionPane

- javax.swing.JScrollPane

- javax.swing.JTextArea

VIII-2 - Aperçu

Aperçu du résultat.

Aperçu du résultat.

VIII-3 - Démonstration

Lancer avec Java Web Start

Note : javaws -viewer (accessible aussi dans le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VIII-4 - Solution

Hanoi.java

1. /*

2. * Fichier: Hanoi.java

3. * Crée le: 03 décembre 2006.

4. * Modifié: 7 juillet 2007.

5. * Auteurs: Sébastien ESTIENNE.

6. * SiteWeb: http://www.prog-info.org/

7. *

8. * This program is free software; you can redistribute it and/or modify

9. * it under the terms of the GNU General Public License as published by

10. * the Free Software Foundation; either version 2 of the License, or

11. * (at your option) any later version.

12. *

13. * This program is distributed in the hope that it will be useful,

14. * but WITHOUT ANY WARRANTY; without even the implied warranty of

15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

16. * GNU General Public License for more details.

17. *

18. * You should have received a copy of the GNU General Public License

19. * along with this program; if not, write to the Free Software

20. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

21. */

23. package chapitre5;

27. import java.awt.Container;

29. import javax.swing.JFrame;

30. import javax.swing.JOptionPane;

31. import javax.swing.JScrollPane;

32. import javax.swing.JTextArea;

36. /**

37. * <p>Résout le problème des tours de Hanoi.</p>

38. * @author Sébastien ESTIENNE.

39. */

40. public class Hanoi extends JFrame

41. {

42. /**

43. * <p>Serial version UID.</p>

44. */

45. private static final long serialVersionUID = 1L;

47. /** Les différentes étapes. */

48. private StringBuilder sortie;

51. /**

52. * <p>Construction de l'application.</p>

53. */

54. public Hanoi()

55. {

56. // Appel du constructeur de la classe JFrame.

57. super("Hanoi");

59. // Créer un JTextArea pour afficher les résultats.

60. JTextArea aireSortie = new JTextArea();

61. aireSortie.setEditable(false);

63. // Obtenir le panneau de contenu.

64. Container conteneur = getContentPane();

66. // Relier JTextArea à un JScrollPane pour pouvoir faire défiler les étapes.

67. JScrollPane defilant = new JScrollPane(aireSortie);

69. // Lier JScrollPane au conteneur.

70. conteneur.add(defilant);

72. // Demander à l'utilisateur le nombre de disques.

73. int nbDisques = 0;

74. while(nbDisques <= 1 || nbDisques > 12)

75. {

76. String sNbDisques = JOptionPane

77. .showInputDialog("Entrez le nombre de disques (2-12) :\n\n");

78. try

79. {

80. nbDisques = Integer.parseInt(sNbDisques);

81. }

82. catch(NumberFormatException e)

83. {

84. // Affiche un message d'erreur.

85. JOptionPane.showMessageDialog(null,

86. "Le nombre de disques doit être compris entre 2 et 12.", "Erreur",

87. JOptionPane.INFORMATION_MESSAGE);

88. }

89. }

91. // Initialiser la chaine de sortie.

92. this.sortie = new StringBuilder();

94. // Calculer les étapes.

95. tour(nbDisques, 1, 2, 3);

97. // Afficher le résultat. (les étapes)

98. aireSortie.setText("Nombre de disques : " + nbDisques + "\n\n" + this.sortie);

100. // Modifie les propriétés de la fenêtre.

101. setSize(350, 200);

102. setLocation(100, 100);

103. setVisible(true);

104. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

105. }

108. /**

109. * <p>Enregistre les différentes étapes.<p>

110. * @param nb Le nombre de disques.

111. * @param ini Le piquet de départ.

112. * @param tmp Le piquet intermédiaire.

113. * @param fin Le piquet de fin.

114. */

115. public void tour(int nb, int ini, int tmp, int fin)

116. {

117. // Cas de base.

118. if(nb == 1)

119. {

120. this.sortie.append(ini).append(" -> ").append(fin).append("\n");

121. }

122. // Récursivité

123. else

124. {

125. // Déplacer n-1 disques du piquet ini au piquet tmp à l'aide du piquet fin.

126. tour(nb - 1, ini, fin, tmp);

128. // Déplacer le dernier disque du piquet ini au piquet fin.

129. this.sortie.append(ini).append(" -> ").append(fin).append("\n");

131. // Déplacer n-1 disques du piquet tmp au piquet fin à l'aide du piquet ini.

132. tour(nb - 1, tmp, ini, fin);

133. }

134. }

137. /**

138. * <p>Lance l'application.</p>

139. * @param args Les paramètres de la ligne de commande.

140. */

141. public static void main(String[] args)

142. {

143. new Hanoi();

144. }

145. }

IX - Remerciements

Je tiens à remercier wichtounet pour les conseils, remarques et relectures.
Je remercie aussi www.developpez.com me permettant de publier cet article et Nono40 pour ses outils.