Petite question sur exercice Java

Bonsoir,
J'ai acheté le bouquin Programmer en Java et j'ai un exemple de programme pour donner des moyennes. J'ai purement fait un copier coller du CD-rom jusqu'à Jcreator. Et j'ai deux messages d'erreurs :
cannot find symbol variable Clavier line 17
cannot find symbol variable Clavier line 21

Merci de votre aide. Parce que là je trouve pas.

Voici le programme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class exercicetableau 
 
{ public static void main (String args[])
  {  int i, nbEl, nbElSupMoy ;
     double somme ;
     double moyenne ;
     System.out.print ("Combien d'eleves ") ;
     nbEl = Clavier.lireInt();
     double notes[] = new double[nbEl] ;
     for (i=0 ; i<nbEl ; i++)
      { System.out.print ("donnez la note numero " + (i+1) + " : " ) ;
        notes[i] = Clavier.lireDouble() ;
      }
     for (i=0, somme=0 ; i<nbEl ; i++)  somme += notes[i] ;
     moyenne = somme / nbEl ;
     System.out.println ("\nmoyenne de la classe  " + moyenne) ;
     for (i=0, nbElSupMoy=0 ; i<nbEl ; i++ )
       if (notes[i] > moyenne) nbElSupMoy++ ;
     System.out.println (nbElSupMoy + " eleves ont plus de cette moyenne") ;
  }
}

Il manque la classe «Clavier» pour te permettre de compiler ce code.

Sur le CD-ROM cette classe doit se trouver à quelque part tu dois l'ajouter à ton projet dans JCreator.

Je bloque toujours!

Salut, je ne comprend pas parce que j'ai déjà effectuer des exercices avec les mêmes codes sans aucun problème. Pour moi c'est un mystère :(

Dans cet exercice il y a une référence à la classe Clavier. Cette classe a été écrite par le rédacteur du bouquin pour aider à la saisie. Il faut que tu récupère cette classe (probablement dans les annexes) et que tu l'ajoute à ton projet.

Clavier.java

Peut-être que cette classe Clavier est la même que celle dont tu as besoin

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
// Clavier.java
// Developpe par Didier Ferment, puis Cyrille Randrianamaro
// Changement de nom pour TP algo UE1 MIAS: G. Richomme
 
   import java.io.BufferedReader;
   import java.io.InputStreamReader;
   import java.io.IOException;
   import java.util.StringTokenizer;
 
/**
 * Classe pour saisir des entiers, des flottants, ... comme scanf
 * de C ou read de Pascal sans se soucier du passage ý la ligne
 * et avec un tampon gÈrÈ automatiquement.<BR>
 * traite immÈdiadement ses IOExceptions<BR>
 * Par exemple, pour saisir un entier au clavier,
 * puis une chaine, puis ... :
 * <pre>
 *    Clavier clav = new Clavier();
 *    int valeur = clav.lireInt();
 *    String mot = clav.lireString();
 *    ...
 * </pre>
 * Ou alors (sans instanciation d'objet) :
 * <pre>
 *    int valeur = Clavier.nextInt();
 *    String mot = Clavier.nextString();
 *    ...
 * </pre>
 * la variable CLASSPATH ou l'option -classpath des commandes
 * javac et java doivent comporter le rÈpertoire de cette classe<br>
 * Fonctionne a partir de java 1.2
 *
 */
 
    public final class Clavier {
      private static int instance = 0;
      private static BufferedReader bufIn = null;
      private static StringTokenizer st = null;
 
   /**
   * initialise les variables de la classe.
   * Les donnÈes sont saisies par dÈfaut au clavier (stdin)
   * Cette action (l'allocation) n'est exÈcutÈe qu'une fois.
   * <BR>
   * Cette fonction est appelÈe lors de chaque lecture (via la fonction
   * read().
   *
   */
       public static void initialise() {
         if (bufIn == null)
            bufIn= new BufferedReader(new InputStreamReader(System.in));
      }
 
   /**
   * instancie un objet de saisie de donnÈes caractËres :
   * sur stdin, par dÈfaut au clavier (cf fonction initialise())<BR>
   * <b>la classe n'est instanciable qu'1 seule fois !</b>
   * @return un objet Clavier
   */
 
       public Clavier() {
         if (instance++ == 0)
            initialise();
         else {
            System.err.println("Clavier : 1 seule instance au plus !");
            System.exit(1);
         }
      }
 
       private static void read()  {
         if (bufIn == null)
            initialise();
         try {
            String s = bufIn.readLine();
            st = new StringTokenizer(s);
         } 
             catch (IOException e) {
               System.err.println(e.getMessage());
               System.exit(2);
            }
 
      }
 
 
 
   /**
   * vide le tampon (buffer) et donc les caractËres tapÈs non utilisÈs
   */
       public static void flush() {
         st = null;
      }
 
   /** analyse la prochaine entitÈ dans le buffer comme une constante
   * de type entier int<BR>
   * les espaces, tabulations et sauts de lignes sont "passÈs"
   * et attend l'arrivÈe de caractËres sur le flot d'entrÈe,
   * par dÈfaut, le clavier<BR>
   * @return    le nombre lu de type int
   * @exception NumberFormatException
   * si la prochaine entitÈ ne rÈpond pas au type entier int
   */
       public static int lireInt()  {
         if (st == null)
            read();
         while (! st.hasMoreTokens())
            read();
         String ss = st.nextToken();
         int i = Integer.parseInt(ss);
         return(i);
      }
 
   /** analyse la prochaine entitÈ dans le buffer comme une constante
   * de type entier long<BR>
   * les espaces, tabulations et sauts de lignes sont "passÈs"
   * et attend l'arrivÈe de caractËres sur le flot d'entrÈe,
   * par dÈfaut, le clavier<BR>
   * @return    le nombre lu de type long
   * @exception NumberFormatException
   * si la prochaine entitÈ ne rÈpond pas au type entier long
   */
       public static long lireLong()  {
         if (st == null)
            read();
         while (! st.hasMoreTokens())
            read();
         String ss = st.nextToken();
         long i = Long.parseLong(ss);
         return(i);
      }
 
   /** analyse la prochaine entitÈ dans le buffer comme une constante
   * de type rÈel flottant : float<BR>
   * les espaces, tabulations et sauts de lignes sont "passÈs"
   * et attend l'arrivÈe de caractËres sur le flot d'entrÈe,
   * par dÈfaut, le clavier<BR>
   * @return    le nombre lu de type float
   * @exception NumberFormatException
   * si la prochaine entitÈ ne rÈpond pas au type entier float
   */
       public static float lireFloat()  {
         if (st == null)
            read();
         while (! st.hasMoreTokens())
            read();
         String ss = st.nextToken();
         float f = Float.parseFloat(ss);
         return(f);
      }
 
   /** analyse la prochaine entitÈ dans le buffer comme une constante
   * de type rÈel flottant en double prÈÁision : double<BR>
   * les espaces, tabulations et sauts de lignes sont "passÈs"
   * et attend l'arrivÈe de caractËres sur le flot d'entrÈe,
   * par dÈfaut, le clavier<BR>
   * @return    le nombre lu de type double
   * @exception NumberFormatException
   * si la prochaine entitÈ ne rÈpond pas au type entier double
   */
       public static double lireDouble()  {
         if (st == null)
            read();
         while (! st.hasMoreTokens())
            read();
         String ss = st.nextToken();
         double f = Double.parseDouble(ss);
         return(f);
      }
 
   /** analyse la prochaine entitÈ dans le buffer comme une constante
   * de type chaine de caractËres<BR>
   * les espaces, tabulations et sauts de lignes sont "passÈs"
   * et attend l'arrivÈe de caractËres sur le flot d'entrÈe,
   * par dÈfaut, le clavier<BR>
   * @return    la chaine de caractËres lue de type String
   * @exception NumberFormatException
   * si la prochaine entitÈ ne rÈpond pas au type entier String
   */
       public static String lireString()  {
         if (st == null)
            read();
         while (! st.hasMoreTokens())
            read();
         return(st.nextToken());
      }
   }