[Language] Aide sur mon premier programme Java?

Version imprimable

Bonjour à tous chers développeurs!

Je suis étudiant en gestion et il y a 6 heures je ne connaissais absolument rien à la programmation, mais quand je vous dis rien c'est vraiment niet, meme pas html... (à chacun sa spécialité! :D )
Comme j'étudie le commerce électronique, j'ai quelques scéances d'introduction à Java pour des applications Web...et un TP à rendre avec des fonctions de bases.
Apres une bonne apres-midi de lectures et de recherches, j'ai plus ou moins compris la structure d'une application Java et j'ai meme réussi à faire la moitié de mon TP (cf code).

Mais malgré mes recherches sur les forums et les tutoriels, je n'arrive pas à écrire correctement les fonctions suivantes. :?
Si l'un d'entre vous à la gentillesse de prendre quelques minutes pour m'aider à écrire ces quelques lignes, je lui serai très reconnaissant!

Le but de l'application est ultra simpliste:
1. Afficher son nom, son prénom et son age: ca j'ai réussi et ca fonctionne!
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 public class personne { /** * @param args */ String Nom; String Prenom; int Age; public static void main(String[] args) { new personne(); } public personne() { Nom="Jack"; Prenom="Daniel's"; Age=23; System.out.print(Nom+" "+Prenom+" "+"("+Age+" "+"ans"+")") } }
Apres je bloque:
2. Ajouter une méthode nommée "anniversaire" qui augmente "Age" de 1.

Ici je suppose qu'il faut ecrire une ligne du genre:
Code:

1 2 public void anniversaire (Age++); Age=Age+1;
Mais alors où et comment (syntaxe)? Mystère!

3. Ajouter dans la classe "personne", une méthode nommée setNom qui modifie la valeur de "Nom" en fonction d'un paramètre. Faire de meme pour "Prénom" et "Age".

4. Ajouter une méthode nommée getNom qui rend les valeurs de "Nom", "Prénom" et "Age".

5. Ajouter une méthode nommée afficher qui affiche pour une persone ces 3 attributs.

Voila, c'est tout.
Bon, pour vous ca doit sans doute paraitre ridiculement facile, mais faut bien commencer par la...

Merci encore à ceux qui voudront bien me donner un petit coup de main!
:wink:

Note : en Java (et en C++) il vaut mieux avoir des noms de classes qui commencent en majuscules. Quant aux noms de variables ou de méthodes ils doivent commencer par des minuscules. Rien n'y oblige mais c'est une convention de codage FORTEMENT recommandée => Personne, nom, prenom, age

Note: j'ai fait exprès de détailler certaines étapes en créant des variables temporaires + ou - inutiles (cf anniversaire).

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
 
///////////////////////////////
// Methodes d'instances. //
///////////////////////////////
 
/** Fête l'anniversaire de cette personne.
 * @return L'age après l'anniversaire.  
 */
public int anniversaire() {
  // Tant qu'à faire autant utiliser les methodes set et get pour l'age.
  // sinon 
  // age = anniversaire(age);
  // return age;
  int ancienAge = getAge();
  int nouvelAge = anniversaire(ancienAge);
  setAge(nouvelAge);
  return nouvelAge;
}
 
/** Retourne le nom.
 * @return Le nom ou <code>null</code>.
 * @see #setNom
 */
public String getNom {
  return nom 
}
 
/** Met le nom à la valeur donnée.
 * @param value Nouvelle valeur, peut-être <code>null</code>.
 * @see #getNom
 */
public void setNom(String value) {
  nom = value;
}
 
// Adapter les 2 méthodes ci-dessus pour les autres attributs.
 
/** Affiche les informations de cette personne.
*/
public void afficher() {
  afficher(this);
}
 
////////////////////////////
// Methodes statiques. //
////////////////////////////
 
/** Celèbre l'anniversaire (méthode générale).
 * <br>Incremente l'age.
 * @param age L'age avant l'anniversaire.
 * @return L'age après l'anniversaire.
 */
public static int anniversaire(int age) {
  return age+1
}
 
/** Affiche les informations d'une personne.
* @param toto La personne cible.
* <br>Si <code>toto</code> est <code>null</code> rien n'est fait.  
*/
public static void afficher(Personne toto) {
  if (toto != null) {
     // En temps normal on construira la chaine avec StringBuilder ou StringBuffer histoire d'éviter de créer tout un tas d'objets temporaires.
     System.out.print(toto.nom+" "+toto.prenom+" "+"("+toto.age+" "+"an(s)"+")")  
     // Egalement on aurait put surcharger la methode toString() de la classe Personne et on aurait fait :
     // System.out.println(toto.toString());  
  }
}

23/09/2005, 09h33
barbu0055
Je pense que tu te complique un peu la vie pour ce qui est de la méthode anniversaire.
Les profs aiment les choses simples (et un programme doit l'être le plus possible)
D'après ton enoncé ceci suffit emplement :
Code:

1 2 3 4 public void anniversaire () { //On demande juste d'incrémenter l'age de la personne age++; }
23/09/2005, 09h46
Pill_S

hello,

je voulais juste faire une remarque au sujet de ce commentaire que tu as mis:

Citation:

// En temps normal on construira la chaine avec StringBuilder ou StringBuffer histoire d'éviter de créer tout un tas d'objets temporaires.

Avec le JDK1.5, j'ai remarqué que l'utilisation des StringBuilder était automatisée. Si l'on écrit ["toto"+"titi"], le compilateur va en fait générer le même code binaire que si vous aviez écrit [new StringBuilder("toto").append("titi")].

Vous pouvez faire le test, en compilant puis décompilant: vous récupérez un code source utilisant StringBuilder...... sympa non ?! :wink:

C'est le genre de choses qui font partie des optimisations possibles lors de la compilation d'un soft java... Puisque c'est fait tout seul, pourquoi le faire manuellement ?

Oki avec Barbu0055...

De meme, je suis pas sur que les profs attendent des methodes static...

Pour la methode Afficher, passer par une methode static, c'est p'tet pas ce qu'ils attendent... Si il a juste quelques heures de Java derriere lui, t'es quand meme dur...

En gros, tu as juste besoin de faire six methodes dites accesseurs, les Set et les Get :
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 public String GetNom() { return Nom; } public String GetPrenom() { return Prenom; } public int GetAge() { return Age; } public void SetNom(String NouveauNom) { Nom = NouveauNom; } public void SetPrenomNom(String NouveauPrenom) { Prenom = NouveauPrenom; } public void SetAge(int NewAge) { Age = NewAge; }
Pour la methode Anniversaire, Barbu005 t'a donné la solution simple,

Pour la methode Afficher, je pense que tes profs apprécieraient que tu utilises tes Accesseurs, autant ne pas les faire pour rien :
Code:

1 2 3 4 5 6 public void Afficher() { System.out.println("Nom : " + GetNom()); System.out.println("Prenom : " + GetPrenom()); System.out.println("Age : " + GetAge()); }

23/09/2005, 09h56
ghorgor
Un dernier detail, ce serait bien en debut de methode que tu declares tes attributs de classe soit en public, en protected, ou en private...

A priori, pour ton appli, ca ne changera pas son fonctionnement, mais c'est quand meme plus beau...

Dans le cas présent, tu as des accesseurs sur tes parametres, autant les mettre en private.

Remplacer :
Code:

1 2 3 String Nom; String Prenom; int Age;
par :

private String Nom;
private String Prenom;
private int Age;
23/09/2005, 10h04
Pill_S

Citation:

Envoyé par ghorgor

Pour la methode Afficher, passer par une methode static, c'est p'tet pas ce qu'ils attendent... Si il a juste quelques heures de Java derriere lui, t'es quand meme dur...

Hum... d'habitude, tout le monde s'accorde à dire que le plus compliqué à comprendre en java est la notion d'objet... donc, moi je conseillerais plutôt fortement une utilisation intensive des méthodes et champs statiques !! Sinon, tu vas l'orienter directement sur des concepts beaucoup trop puissants pour être compris en quelques heures... Moi ça m'a pris pas loin de 6 mois de pratique quotidienne avant d'être au clair avec l'OO !

PS: pour rappel, la clause "static" permet de se détacher de la notion d'objet, et de programmer de manière traditionnelle comme on le ferait dans un langage moins récent (Pascal, C, ...). Ca sert à indiquer p.ex. qu'une variable appartient à la classe, c'est à dire qu'elle n'existe qu'en un seul exemplaire dans la mémoire et non pas un exemplaire par instance de la classe.
23/09/2005, 10h07
bouye

Tout à fait d'accord sur la plupart des critiques de sur mon code, mais mieux vaut qu'il en vienne à poser des questions sur le pourquoi du comment (quite à demander au prof) et qu'il ne recopie pas le code tel quel (toujours dangereux ca surtout si on prend pas la peine de tester), l'adaptation lui demandant un peu de réflexion... ;) gnack gnack...

Pour les StringBuilder oui c'est depuis le 5.0, tandis que dans les versions antérieures le compilateur mettait des... StringBuffer à la place. Mais dans le print il y a plusieurs '+' ce qui va faire que le compilateur va générer des StringBuilder/StringBuffer à la pelle...

Et comme celà a été discuté dans plusieurs autres threads, et à pas mal d'endroits (nottement dans divers tips et didacticiel sur le sites de Sun) : là c'est typiquement une fuite mémoire*/trou de performance que la plupart des gens ignorent tant ils sont contents de faire des '+'...

*Temporaire bien sur grace au GC

Voir la FAQ.

Evidement pour un débutant peu lui importe mais j'espère pour lui qu'il note ou mémorise vos/mes sugestions. Ca lui sera toujours utile par la suite avant de venir poser des questions plus ou moins stupides dans une forum (acune insulte sous-entendue).
23/09/2005, 10h18
ghorgor

Citation:

Hum... d'habitude, tout le monde s'accorde à dire que le plus compliqué à comprendre en java est la notion d'objet... donc, moi je conseillerais plutôt fortement une utilisation intensive des méthodes et champs statiques !!

Je suis d'accord, mais je me mets a sa place... Je pense qu'a ce niveau la, vu le probleme posé, le sujet doit simplement etre d'utiliser par les accesseurs les attributes de classe, et accessoirement, de faire une sortie console...

Je ne pense pas qu'ils aient déjà vu les différentes utilisation du static, et ses différentes implications, autre part que dans la methode main...

C'est visiblement un cours pour debutant, aussi bien en programmation qu'en java, be cool with him...

J'apprécies beaucoup la maniere donc bouye a ecrit ca, mais c'est quand meme loin d'etre la methode la plus simple, ni a ecrire, ni a comprendre...

Tu lui mets en plus deux methodes Afficher, l'une faisant appel a l'autre, l'une etant instance de classe, l'autre etant statique, c'est tres joli, mais p'tetre un peu violent pour lui non ?

A ce niveau la, on a qu'a lui dire de faire afficher la sortie via une servlet, et d'utiliser des flux XML au passage... Pis en 3D... Le prof va etre content, mais il risque de se poser des questions quand meme... :wink:

Citation:

Envoyé par ghorgor

Tu lui mets en plus deux methodes Afficher, l'une faisant appel a l'autre, l'une etant instance de classe, l'autre etant statique, c'est tres joli, mais p'tetre un peu violent pour lui non ?

A ce niveau la, on a qu'a lui dire de faire afficher la sortie via une servlet, et d'utiliser des flux XML au passage... Pis en 3D... Le prof va etre content, mais il risque de se poser des questions quand meme... :wink:

c'est pas faux :)

moi je vais essayer de vous proposer un code simplifié à l'extrê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
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
 
class Personne {
  private int age=0; // âge personne
  private String nom=""; // nom
  private String prenom=""; // prénom
 
  /*Constructeur par défaut utilisé: aucun constructeur*/
 
  /*Manipule âge*/
  void setAge(int newAge){
    age = newAge;
  }
  int getAge(){
    return age;
  }
  void birthday(){
    age++;
  }
 
  /*Manipule nom*/
  void setNom(String newNom){
    nom = newNom;
  }
  String getNom(){
    return nom;
  }
 
  /*Manipule prénom*/
  void setPrenom(String newPrenom){
    prenom = newPrenom;
  }
  String getPrenom(){
    return prenom;
  }
 
  /*Affichage infos*/
  void afficher(){
    System.out.println(toString());
  }
  public String toString(){ // ton prof risque d'apprécier cette méthode !
    return nom+" "+prenom+" "+age+" ans"; // zut pour les fuites mémoires
  }
 
  /*Main (point d'entrée)*/
  public static void main(String[] argv){
    Personne p1 = new Personne();
    p1.setNom("SonNom");
    p1.setPrenom("SonPrenom"); 
    p1.setAge(18); // modifie l'âge (18 ans)
    p1.afficher(); // Affichage console
 
    // si veux l'âge de la personne p1:
    int lagedelapersonnep1 = p1.getAge();
 
    // si tu veux faire vieillir le gars p1....
    p1.birthday(); // et pan tu t'es pris 1 an !
 
    // on affiche pour controler que le gars a bien vieilli...
    p1.afficher();
 
    // ...
  }  
}

23/09/2005, 12h52
ghorgor

Bon ben avec tout ca, il n'y a plus qu'a attendre qu'il vienne nous dire ce qu'il en pense...

Il devrait avoir le choix...

Ce code me plait bien. Cependant, je trouve qu'il est mieux (et pas très compliqué) d'ajouter l'accessibilité (private, public, protected) sur les methodes et les variables et meme sur la classe.
J'aurais egalement tendance à utiliser un constructeur pour creer la personne avec son nom et prenom (sachant que dans n'importe quel systeme d'informations, le nom et prenom d'une personne sont obligatoire... donc les repercussions techniques sont qu'on ne peut pas creer une personne sans. Pour l'age c'est selon le systeme d'information utilise...

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
public class Personne { 
  private int age=0; // âge personne 
  private String nom=""; // nom 
  private String prenom=""; // prénom 
 
  /*Constructeur par utilisé*/ 
public Personne (String nom,String prenom) {
  this.nom=nom;
  this.prenom=prenom;
}
 
  /*Manipule âge*/ 
  public void setAge(int newAge){ 
    age = newAge; 
  } 
  public int getAge(){ 
    return age; 
  } 
  public void birthday(){ 
    age++; 
  } 
 
  /*Manipule nom*/ 
  public void setNom(String newNom){ 
    nom = newNom; 
  } 
  public String getNom(){ 
    return nom; 
  } 
 
  /*Manipule prénom*/ 
  public void setPrenom(String newPrenom){ 
    prenom = newPrenom; 
  } 
  public String getPrenom(){ 
    return prenom; 
  } 
 
  /*Affichage infos*/ 
  public void afficher(){ 
    System.out.println(toString()); 
  } 
  public String toString(){ // ton prof risque d'apprécier cette méthode ! 
    return nom+" "+prenom+" "+age+" ans"; // zut pour les fuites mémoires 
  } 
 
  /*Main (point d'entrée)*/ 
  public static void main(String[] argv){ 
    Personne p1 = new Personne("sonNom","sonPrenom"); 
    p1.setAge(18); // modifie l'âge (18 ans) 
    p1.afficher(); // Affichage console 
 
    // si veux l'âge de la personne p1: 
    int lagedelapersonnep1 = p1.getAge(); 
 
    // si tu veux faire vieillir le gars p1.... 
    p1.birthday(); // et pan tu t'es pris 1 an ! 
 
    // on affiche pour controler que le gars a bien vieilli... 
    p1.afficher(); 
 
    // ... 
  }  
}

23/09/2005, 22h25
hash2zo

Merci à tous de vos réponses et du temps que vous y avez consacré! :D

j'ai lu attentivement tous vos post et j'ai bien pris note de vos commentaires.
j'admire vos connaissances, et je me rends compte qu'il y a plusieurs facons plus ou moins complexes de résoudre ce probleme.
Je suis en trains de le tester et de faire des petites modifs pour obtenir ce que je souhaite au niveau de l'affichage.

Je vous tiens au courrant rapidement.

Salut,

Citation:

Envoyé par bouye

Pour les StringBuilder oui c'est depuis le 5.0, tandis que dans les versions antérieures le compilateur mettait des... StringBuffer à la place. Mais dans le print il y a plusieurs '+' ce qui va faire que le compilateur va générer des StringBuilder/StringBuffer à la pelle...

C'est inexact ! Un seul StringBuilder est utilisé pour toute une concaténation, ainsi le code :

Code:

System.out.print(toto.nom+" "+toto.prenom+" "+"("+toto.age+" "+"an(s)"+")");

est strictement équivalent à :
Code:

1 2 3 System.out.print(new StringBuffer(toto.nom).append(" ") .append(toto.prenom).append(" ").append("(") .append(toto.age).append(" ").append("an(s)"+")").toString() );
De plus la convertion du StringBuffer en String est optimisé (les classe String et StringBuffer peuvent se partager le même tableau de caractère). Ainsi dans ce cas l'opérateur + est conseillé car en plus il améliore la lisibilité...

Ce n'est peut-être pas explicite dans la FAQ, mais c'est très clair dans l'API de StringBuffer.

Citation:

Envoyé par bouye

Et comme celà a été discuté dans plusieurs autres threads, et à pas mal d'endroits (nottement dans divers tips et didacticiel sur le sites de Sun) : là c'est typiquement une fuite mémoire*/trou de performance que la plupart des gens ignorent tant ils sont contents de faire des '+'...

Par contre c'est vrai que cela peut poser problème... mais pas dans un simple print()...
Comme indiqué dans la FAQ, le problème vient en particulier lorsqu'on utilise le + dans une boucle, par exemple :
Code:

1 2 3 4 String text = ""; while ( /* condition */ ) { text = text + "autre chaine"; }
Car dans ce cas on crée un StringBuffer à chaque itération :
Code:

1 2 3 4 String text = ""; while ( /* condition */ ) { text = new StringBuffer(text).append("autre chaine").toString(); }
ce qui est très lourd car plus le texte sera grand, plus le StringBuffer sera grand et on se retrouve a allouer plusieurs fois la même chose... et on peut se retrouver avec des temps d'exécution enormes (et de plus en plus important si on augmente le nombre d'itération et la taille du texte final).
Dans ce cas il y a alors un grand intérêt à utiliser directement le StringBuffer :
Code:

1 2 3 4 5 StringBuffer buffer = new StringBuffer(); while ( /* condition */ ) { buffer.append("autre chaine"); } String text = buffer.toString();
Ce qui n'allouera quasiment que la mémoire neccessaire, et donnera le même résultat en quelques millisecondes...

A la rigueur il vaut mieux utiliser des StringBuffer si on va générer un texte un peu long sur plusieurs ligne, par exemple le code suivant utilise implicitement quatre StringBuffer (1 par concaténation):
Code:

1 2 3 4 5 6 String message = "Nom : " + toto.nom + ", "; message += "Prenom : " + toto.prenom; if (afficherAge==true) { message += ", (" + toto.age + " an(s))"; } message += ".";
Ce qui est l'équivalent du code :
Code:

1 2 3 4 5 6 String message = new StringBuffer("Nom : ").append(toto.nom).append(", ").toString(); message = new StringBuffer(message).append("Prenom : ").append(toto.prenom).toString(); if (afficherAge==true) { message = new StringBuffer(message).append(", (").append(toto.age).append(" an(s))").toString(); } message = new StringBuffer(message).append(".").toString();
En utilisant directement un StringBuffer on évite plusieurs allocation/désallocation inutile :
Code:

1 2 3 4 5 6 7 StringBuffer buffer = new StringBuffer("Nom : ").append(toto.nom).append(", "); buffer.append("Prenom : ").append(toto.prenom); if (afficherAge==true) { buffer.append(", (").append(toto.age).append(" an(s))"); } buffer.append("."); String message = buffer.toString();
Mais dans ce cas le gain de performances est vraiment minime (les allocations se limite à quelques octets) alors que le code est nettement moins lisible...
Il vaut mieux réserver cela à la création/modification de grande chaines...

a++

PS : Comme cela a été dit, avec Java 5.0 c'est StringBuilder qui est utilisé par le compilateur pour remplacer les +, mais le méchanisme est exactement le même (StringBuilder n'est pas thread-safe, elle est donc potentiellement plus performante).

24/09/2005, 08h58
bouye

Il est possible que ces optimisation aient été rendues obligatoires (mandatory) dans les specs du language Java plus récentes comme Java 1.4 et 5.0. Mais dans un tip tech datant de 2002, on peut trouver :

Citation:

The other problem concerns a statement found in the Java Language Specification section 15.18.1.2, which says:

Citation:

An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression.

This statement suggests that a Java compiler is not required to optimize an expression such as:

str1 + str2 + str3 + ...

as is currently done for the toString1 method above, but instead can create intermediate string objects.

So it pays to be cautious in your use of the + operator, especially for long strings or within loops.

Comme indiqué cela concerne une longue séquence de +, pas forcement dans une boucle for. Il est donc possible (quoique peu probable) que cette optimisation n'existe que dans le compilateur de Sun (pas chez Apple, IBM, Blackdown, SGI ou autre...). Le choix d'utiliser ou non cette optimisation étant laissé à la décision/interprétation de l'implémenteur du compilateur.
27/09/2005, 19h26
hash2zo

J'ai réussi a faire fonctionner ma petite application grace à vos conseils.
D'aileur Java me parait beaucoup plus clair tout d'un coup...
Merci beaucoup à Bouyre, Vienna, ghorgor, Pill_S et les autres!

:D