[Débutant] Class - Je ne comprends plus rien !

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,

Je cherche désespérément à comprendre les getter et setter d'une classe. Jusque là, j'ai compris que dans le premier cas on récupère les informations alors que dans l'autre on écrit les informations.

Me basant sur ce constat, j'ai essayer de me faire un exemple afin de tester la validité de mes dires. Et la miracle, c'est deux erreurs que je ne comprends pas!

Tout d'abord voici ma classe de test:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package AppliClasses;
 
public class Chanson {
 
    /*
     * Les méthodes de la classe chanson
     */
    public void setChanson(String titleChanson) {
        this.nomChanson = titleChanson;
    }
 
    public void getChanson() {
        //System.out.println(nomChanson);
 
        return nomChanson;
    }
 
    /*
     * Les champs de la classe chansson
     */
    private String nomChanson;
}

Lorsque je place mon return nomChanson, je cherche à retourné le nom via le getter, vue qu'il est censé le renvoyer. A moins que je ne me trompe !
L'erreur que me retourne netBeans est la suivante .

Citation:

cannot return a value from methode whose result type is void

En gros, si j'ai bien compris, on ne peux pas retourné de valeur car la méthode est de type void.

Pourquoi ? Et comment alors je devrais faire mon getter pour qu'il me retourne la valeur?

Ensuite, passons du cotés du main. ou j'ai un autre type d'erreur et je ne sait pas si c'est le complément de la première. Je suppose que oui.

Si j'écris le main suivant:

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
 
package Appli;
import AppliClasses.Chanson;
 
public class MainForm extends javax.swing.JFrame {
 
    /** Creates new form MainForm */
    public MainForm() {
        initComponents();
    }
 
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    private void initComponents() {
 
        jScrollPane1 = new javax.swing.JScrollPane();
        jTextAreaOut = new javax.swing.JTextArea();
        jBtnTester = new javax.swing.JButton();
 
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
 
        jTextAreaOut.setColumns(20);
        jTextAreaOut.setRows(5);
        jScrollPane1.setViewportView(jTextAreaOut);
 
        jBtnTester.setText("Tester");
        jBtnTester.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jBtnTesterActionPerformed(evt);
            }
        });
 
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 376, Short.MAX_VALUE)
                    .addComponent(jBtnTester))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 243, Short.MAX_VALUE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(jBtnTester)
                .addContainerGap())
        );
 
        pack();
    }// </editor-fold>
 
    private void jBtnTesterActionPerformed(java.awt.event.ActionEvent evt) {
 
        Chanson ch = new Chanson();
        ch.setChanson("Butterfly");
 
        //ch.getChanson();
        jTextAreaOut.setText(ch.getChanson());
    }
 
 
    /**
    * @param args the command line arguments
    */
    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new MainForm().setVisible(true);
            }
        });
    }
 
    // Variables declaration - do not modify
    private javax.swing.JButton jBtnTester;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTextArea jTextAreaOut;
    // End of variables declaration
 
}

J'obtiens le message d'erreur suivant:

Citation:

'void' type not allowed here.

Donc en gros je n'ai pas alloué de type void à mon affichage.

Je précise que ce n'est pour moi qu'un exercice visant à comprendre comment fonctionne une classe. Il se peut que j'ai commis d'énormes erreurs, mais ce n'est pas simple avec le nombre de messages ne disant pas la même chose.

Je sollicite donc votre aide pour éclairer ma lanterne et y voire plus clair en ce qui concerne les classes. :ccool:

Merci beaucoup pour votre aide.

30/05/2010, 17h53
igor24
Là ta méthode get retourne void (vide ou rien). Pour retourner un type donné, il faut le déclarer dans la signature de ta méthode.
Code:

1 2 3 4 5 6 public String getChanson() { //System.out.println(nomChanson); return nomChanson; }
30/05/2010, 18h46
Caxton

Ok pour l'histoire du void.

Mais cela ne me dit en rien pourquoi la fonction ne prendrais pas directement le champ nomChanson dans le getter alors que nomChanson est cencé se remplir avec le setter. A moins que je ne me trompe. Ce qui se peut aussi.
30/05/2010, 21h00
jcdentons
Bonjour.

Citation:

Envoyé par Microbulle

Mais cela ne me dit en rien pourquoi la fonction ne prendrais pas directement le champ nomChanson dans le getter alors que nomChanson est cencé se remplir avec le setter. A moins que je ne me trompe. Ce qui se peut aussi.

De quelle fonction parlez vous ?

L'intérêt de la classe est de créer un type.
Ce type va contenir des attributs (ici, il n'y a qu'un seul attribut : nomChanson). En règle général, ces attributs sont "privés", ce qui signifie que seule des méthodes de la classe vont pouvoir y accéder.
Si l'on veut que d'autres classes y accèdent, il faut créer ce que l'on appelle des getters et setters pour chaque attribut.
Les getters/setters sont des méthodes de la classe retournant (get) ou affectant (set) un attribut privé. L'intérêt est que l'attribut ne peut pas être directement modifié dans une autre classe (cela évite les choses du genre :
Code:

1 2 Chanson ch = new Chanson(); ch.nomChanson = "blabla";
On est ainsi obligé de passer par les méthodes des classes pour y accéder en lecture comme en écriture.

Ainsi, lorsque vous faîtes :

Code:

Chanson ch = new Chanson();

Vous créez un nouvel objet de la classe Chanson.
Cet objet possède alors l'état suivant :
ch
nomChanson == null
Ensuite, vous affectez le nomChanson en utilisant le setter (donc vous modifiez votre objet ch de classe Chanson) :

Code:

ch.setChanson("Butterfly");

Votre objet possède alors l'état suivant :
ch
nomChanson == "Butterfly"

Enfin, vous accédez à l'attribut nomChanson via son getter (vous ne modifiez pas l'objet) :

Code:

jTextAreaOut.setText(ch.getChanson());

Je suis bien d'accord avec ce qui est dit plus haut.
Mais si on se doit d'éviter ce que j'ai écrit, comme dit au précédent post. Il faut faire comment pour que ça fonctionne ?

Je vais faire un édit.
Je me suis baladé sur les tutoriaux, quand d'un coup je me suis rendu compte que des getters était écris comme suit:

Code:

1 2 3 4 public String getName() { return cached; }

Si je regarde bien mon code, j'avais mis void à la place de String. C'est pour ça que dans mon main, j'avais une erreur du à void.

Je n'avais pas saisie que l'on pouvais forcé un getter à un type comme String. Du coup, j'ai écrit ma classe ainsi:

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 package AppliClasses; public class Chanson { /* * Les méthodes de la classe chanson */ public void setChanson(String titleChanson) { this.nomChanson = titleChanson; } public String getChanson() { //System.out.println(nomChanson); return nomChanson; } /* * Les champs de la classe chansson */ private String nomChanson; }

Maintenant j'aimerais en savoir un peux plus en ce qui concerne les possibilités d'étendre la classe depuis une autre classe. C'est à dire déjà savoir si c'est possible et y ajouter un attribue durée par exemple.

31/05/2010, 00h10
jcdentons

En fait, le getter retourne un attribut.
L'attribut nomChanson est du type String, donc le getter de nomChanson ne peut que retourner un type String.

Code:

Maintenant j'aimerais en savoir un peux plus en ce qui concerne les possibilités d'étendre la classe depuis une autre classe. C'est à dire déjà savoir si c'est possible et y ajouter un attribue durée par exemple.

Ce dont vous parlez doit s'agir d'héritage ?
C'est à dire créer une nouvelle classe identique à la classe Chanson, cependant cette classe aurait en plus un attribut duree, est-ce bien cela ?

Si c'est ce que vous souhaitez, je vous conseille de lire le didacticiel conseillé dans un sujet plus haut du forum :
http://java.developpez.com/livres/javaEnfants/ et en particulier le paragraphe suivant : http://java.developpez.com/livres/ja...e=classes#LV-D

Avec les indications suivantes, j'ai réaliser ceci:

Classe parente :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
package AppliClasses;
public class Chanson {
 
    /*
     * Les méthodes de la classe chanson
     */
 
    public void setChanson(String titleChanson) {
        this.nomChanson = titleChanson;
    }
 
    public String getChanson() {
        return nomChanson;
    }
 
    /*
     * Les champs de la classe chansson
     */
    private String nomChanson;
}

La classe enfant:

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
 
package AppliClasses;
public class ChansonPlus extends Chanson {
    /*
     * Les méthodes de la classe chanson
     */
 
    public void setDuree(int Duree) {
        this.dureeChanson = Duree;
    }
 
    public void setTimeExtension(String Extension) {
        this.extensionTemps = Extension;
    }
 
    public String getDuree() {
        String LaDuree = dureeChanson + " " + extensionTemps;
        return LaDuree;
    }
 
    /*
     * Les champs de la classe chansson
     */
    private int dureeChanson;
    private String extensionTemps;
}

et enfin le main modifier:

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
 
package Appli;
import AppliClasses.Chanson;
import AppliClasses.ChansonPlus;
 
public class MainForm extends javax.swing.JFrame {
 
    /** Creates new form MainForm */
    public MainForm() {
        initComponents();
    }
 
    @SuppressWarnings("unchecked")
 
    private void jBtnTesterActionPerformed(java.awt.event.ActionEvent evt) {                                           
 
        ChansonPlus ch = new ChansonPlus();
        ch.setChanson("Butterfly");
 
        ch.setDuree(10);
        ch.setTimeExtension("min");
 
 
        jTextAreaOut.setText("Le titre de la chanson est : " + ch.getChanson() + " Durée : " + ch.getDuree());
    }       
 
    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new MainForm().setVisible(true);
            }
        });
    }
 
    // Variables declaration - do not modify                     
    private javax.swing.JButton jBtnTester;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTextArea jTextAreaOut;
    // End of variables declaration                   
 
}

Si je comprends bien, lorsque on utilise une classe hérité, pour accéder aux setter et getter de la classe parente, on doit indiqué la classe enfant, mais si on s'en tiens aux setter et getter uniquement, on peut laisser le constructeur sur la classe parente. :ccool:

J'espère que je ne dis pas là trop de bêtises de débutant. Rectifiez-moi si je met des erreurs.

31/05/2010, 09h22
jcdentons
Citation:

Si je comprends bien, lorsque on utilise une classe hérité, pour accéder aux setter et getter de la classe parente, on doit indiqué la classe enfant

En fait, les méthodes de la classe parente sont ici "publiques" (via le mot clé public), c'est à dire qu'elles peuvent être appelées de n'importe quelle classe.
Si je crée un objet de la classe Chanson, je vais pouvoir appeler toutes ses méthodes publiques, à savoir setChanson et getChanson. Par contre, je ne vais pas pouvoir accéder directement à son champ nomChanson, car celui-ci est privé (mot clé private), ce qui signifie que l'on restreint son accès à la classe courante. On ne va pas pouvoir non plus accéder à cet attribut dans les classes filles.
En clair, dans la classe ChansonPlus, on ne peut pas, dans une nouvelle méthode, faire :

Code:

this.nomChanson = "blabla";

Si vous voulez accéder à ce champ dans la classe fille ChansonPlus, il faut le mettre en "protégé" (mot clé protected) et non en privé.
Code:

1 2 3 4 /* * Les champs de la classe chansson */ protected String nomChanson;
Citation:

, mais si on s'en tiens aux setter et getter uniquement, on peut laisser le constructeur sur la classe parente.

Si vous appelez le constructeur d'une classe, vous créez un objet de cette classe.
La classe Chanson n'est pas la classe ChansonPlus, et la classe ChansonPlus n'est pas la classe Chanson.
Si vous créez un objet de la classe Chanson :

Code:

Chanson ch = new Chanson();

Vous ne pouvez pas exécuter ceci :

Code:

ch.setDuree(10);

Alors pourquoi dans le cas ou j'écris:
Code:

1 2 3 4 5 6 7 8 9 ChansonPlus ch = new ChansonPlus(); ch.setChanson("Butterfly"); ch.setDuree(10); ch.setTimeExtension("min"); jTextAreaOut.setText("Le titre de la chanson est : " + ch.getChanson() + " Durée : " + ch.getDuree());
Ça fonctionne ?

J'aurais certainement du avoir deux constructeurs avec deux appels différents. Ou j'ai oublier quelque-chose ? :roll:

31/05/2010, 11h22
Caalador

Code:

public class ChansonPlus extends Chanson { ... ...

ChansonPlus est une chanson, donc elle hérite des attributs et des méthodes de la class parente.
Donc pas besoin d'avoir 2 constructeurs.

Par contre l'inverse n'est pas vrai.

Tu peux utiliser d'autres types d'objet plus parlant :

Code:

public class Animal { ... ...

Code:

public class Oiseau extends Animal { ... ...

Tous les animaux peuvent manger, donc tous les oiseaux (qui sont des animaux) peuvent aussi manger.
Par contre les oiseaux peuvent voler, mais cela ne veut pas dire que tous les animaux le peuvent.
31/05/2010, 17h47
Caxton

Je suis bien d'accord effectivement pour le principe. Mais ce que je n'arrive pas à comprendre en revanche c'est que si on à le schéma suivant:

Citation:

class Chanson ->[setChanson] [getChanson]
class ChansonPlus extends Chanson -> [setDuree] [setTimeExtension] [getDuree]

Citation:

Si on ne veux que setChanson et GetChanson, on fait un constructeur du type Chanson ch = new Chanson;

Si on veut l'intégralité des setters et getters il faudrais que je face un constructeur du type ChansonPlus ch = new Chanson; au lieu de Chanson ch = new Chanson;

Pourquoi ?

Je dis pourquoi car il me semble plus logique de pouvoir accéder aux paramètre de l'enfant depuis le parent plus que l'inverse. Mais je fait surement une mauvaise interprétation de la relation parent enfant (dans le domaine informatique)...
31/05/2010, 17h55
jcdentons

Pour imager :
L'enfant a les mêmes caractéristiques que le parent, et peut avoir des caractéristiques en plus.
31/05/2010, 18h10
Caalador

Le mot enfant est peut-être trompeur.
C'est une class étendue => extends

Pour reprendre mon exemple des animaux, quand on a un oiseau, on sait que c'est un animal, par contre quand on a un animal, on ne sait pas si c'est un oiseau.

Donc pour toi, quand tu as une ChansonPlus, tu sais que c'est une chanson.
Par contre quand tu fais une simple Chanson, tu ne sais pas si c'est une chansonplus et tu ne peux donc pas en appeler les méthodes.
31/05/2010, 20h18
Caxton

Ok je comprends mieux.

C'est vrai que de partir avec une classe abstraite n'est peut-être pas la meilleure chose à faire.

Vous allez peut-être me dire que je suis pénible. Mais que fait-on du mot super ? A quoi sert-il ? Dans quel mesure il peur aider la programmation. Enfin tout ce qui touche autour du mot super au niveau des classes.

En attendant, je vais refaire mon exemple pour un animal, il sera plus parlant. :mouarf:

Le mot super est à utiliser dans le cas où une méthode de la classe mère est redéfinie dans la classe fille, c'est à dire que l'on une méthode ayant le même nom dans la classe mère et dans la classe fille.

Exemple de redéfinition de méthode :

Code:

1
2
3
4
5
6
7
public class Animal {
  ...
  public boolean peutVoler() {
    return false;
  }
  ...
}

Code:

1
2
3
4
5
6
7
public class Oiseau extends Animal {
  ...
  public boolean peutVoler() {
    return true;
  }
  ...
}

Exemple d'utilisation du mot super :

Code:

1
2
3
4
5
6
7
public class Animal {
  private int nbPattes;
  public void setNbPattes(int nouveauNbPattes)  {
    this.nbPattes = nouveauNbPattes;
  }
  ...
}

Code:

1
2
3
4
5
6
7
8
public class Oiseau extends Animal {
  ...
  public void setNbPattes(int nouveauNbPattes)  {
    super.setNbPattes(nouveauNbPattes);
    //autres opérations
  }
  ...
}

Le mot clé super est souvent utilisé également dans les constructeurs.
Par exemple :

Code:

1
2
3
4
5
6
7
public class Animal {
  public Animal() {
  // Initialisation de l'objet
   ...
  }
  ...
}

Code:

1
2
3
4
5
6
7
8
9
10
public class Oiseau extends Animal {
  ...
  public Oiseau() {
  //Appel du constructeur de la classe mère : Animal()
  super();
  //Opérations d'initialisation propres à la classe Oiseau
  ...
  }
  ...
}

01/06/2010, 10h21
Caalador

Voilà, dans le dernier exemple de jcdentons, le fait de mettre super(); dans le constructeur de la class Oiseau, va déclancher le constructeur de la class Animal.

Le constructeur va permettre d'initialiser l'animal générique. Ensuite dans la class oiseau, à la suite de super(), tu vas pouvoir initialiser les attirbuts spécifiques de la class oiseau.
01/06/2010, 11h26
Caxton

J'essaie de comprendre et c'est pour cela que je ne vais émettre que des hypothèses.

Si je comprend correctement ce qui a été mis comme exemple et comme explication, on commence par posé le constructeur de l'animal et avec le mot super on ira cherché les propriété de l'enfant c'est à dire oiseau, chat etc...

Ce qui me fait pensé que ça risque aussi de partir dans tous les sens (et ça ce n'est pas bon du tout).

Une autre possibilité est que nous déclarons toujours l'enfant ce qui permet d'accéder au parent mais depuis l'enfant avoir des propriété qui sont normalement protégé accédé par le mot super.

Ca serais alors plus propre que précédemment et cela permettrait de poussé plus loin la classe enfante.

Mais je n'ai que ces deux hypothèse, je suis peut-être dans le faux. A voir avec ma nouvelle classe que je n'ai pas eu le temps de re écrire complètement !
01/06/2010, 11h41
jcdentons

Citation:

Si je comprend correctement ce qui a été mis comme exemple et comme explication, on commence par posé le constructeur de l'animal et avec le mot super on ira cherché les propriété de l'enfant c'est à dire oiseau, chat etc...

Non, le mot clé super permet d'exécuter des méthodes ou d'accéder à des attributs public ou protected du PARENT et non de l'enfant.
Ce mot clé est à utiliser dans la classe enfant pour accéder aux données du parent.

Ok !
La je comprends parfaitement :)

donc si j'écris ceci dans Animal.java:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package AppliClasses;
public class Animal {
 
    /*
     * Les méthodes de la classe Animal
     */
 
    public void setAnimal(String Nom) {
        this.nomAnimal = Nom;
    }
 
    public String getAnimal() {
        return nomAnimal;
    }
 
    /*
     * Les champs de la classe Animal
     */
 
    private String nomAnimal;
 
}

Puis dans Chien.java

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
 
package AppliClasses;
public class Chien extends Animal {
    /*
     * Les méthodes de la classe Chien
     */
 
    public void setRace(String Race) {
        this.nomRace = Race;
    }
 
    public void setPoils(String Poils) {
        this.typePoils = Poils;
    }
 
    public String getChien() {
        String Chien = super(nomAnimal) + nomRace + " à poils " + typePoils;
        return Chien;
    }
 
    /*
     * Les champs de la classe Chien
     */
 
    private String nomRace;
    private String typePoils;
}

Ça devrait fonctionné.

01/06/2010, 12h21
jcdentons
Presque.

Code:

private String nomAnimal;

Le mot clé private interdit d'accéder au champ nomAnimal dans les autres classes.
Par contre, vous pouvez accéder au getter, qui lui est déclaré en public :

Code:

public String getAnimal()

Cette méthode n'étant pas redéfinie dans la classe Chien, le mot clé super n'est pas nécessaire.

Vous pouvez donc essayer ceci dans la classe Chien :
Code:

1 2 3 4 5 6 7 8 ... public String getChien() { String Chien = getAnimal() + nomRace + " à poils " + typePoils; return Chien; } ...
Pour information, le mot clé super s'utilise de cette manière :
Code:

1 2 3 super.nomAttribut; super.nomMethodeSansArgument(); super.nomMethodeAvecArguments(argument1, argument2, ... argumentn);

Donc si je continue dans le même ordre, il me faudrait faire ce cas là:

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
 
package AppliClasses;
public class Chien extends Animal {
    /*
     * Les méthodes de la classe Chien
     */
 
    public void setRace(String Race) {
        this.nomRace = Race;
    }
 
    public void setPoils(String Poils) {
        this.typePoils = Poils;
    }
 
    public String getChien() {
        //Attention getAnimal() viens de la classe parente déclarer en public
        String Chien = getAnimal() + nomRace + " à poils " + typePoils;
        return Chien;
    }
 
    /*
     * Les champs de la classe Chien
     */
 
    private String nomRace;
    private String typePoils;
}

Si je devais utilisé le mot super.nomAnimal il faudrait alors que la classe enfante redéfinisse la classe parent. Oui mais comment ? Et pourquoi redéfinir une classe parente déjà créer et qui fonctionne ?

Voici un exemple d'intérêt de redéfinir une méthode d'une classe parent :
Classe mère :

Code:

1
2
3
4
5
6
7
 
public class Animal {
 
    public boolean peutVoler() {
        return false;
    }
}

Une classe fille :

Code:

1
2
3
4
5
6
7
 
public class Oiseau extends Animal {
 
    public boolean peutVoler() {
        return true;
    }
}

Une autre classe fille :

Code:

1
2
3
4
 
public class Chien extends Animal {
 //pas de redéfinition de la méthode
}

Utilisation :

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
 
public class ClassMain {
 
    public static void main() {
        Chien chien = new Chien();
        Animal animal = new Animal();
        Oiseau oiseau = new Oiseau();
 
        System.out.println("Un chien peut-il voler ?");
        if (chien.peutVoler()) {
                System.out.println("Oui");
        } else {
                System.out.println("Non");
        }
 
        System.out.println("Un animal peut-il voler ?");
        if (animal.peutVoler()) {
                System.out.println("Oui");
        } else {
                System.out.println("Non");
        }
 
        System.out.println("Un oiseau peut-il voler ?");
        if (oiseau.peutVoler()) {
                System.out.println("Oui");
        } else {
                System.out.println("Non");
        }
    }
}

Ceci est un exemple vite fait, je ne l'ai pas testé, mais le principe y est.

01/06/2010, 13h18
Caxton

Il y a quelque chose qui me choque...

Normalement nous serions obliger dans la classe enfante de déclarer en quelque part notre peutVoler... Donc y faudrait un champs dans la classe enfante pour l'utiliser... Ce n'est pas très clair sans mon esprit !
01/06/2010, 14h39
jcdentons

Disons que le mot clé extends permet la déclaration implicite de tous les attributs et méthodes public et protected de la classe Mère à l'intérieur de la classe fille.

Je vous conseille de bien lire ce chapitre :
http://java.developpez.com/livres/ja...age=classes#LV
01/06/2010, 14h41
Caalador

La class enfant hérite de la class parente, donc non ce n'est pas obligé.

La class chien est une class Animal, mais étendue.
Elle contient donc ce que contient la class Animal.

Si Animal contient une méthode peutVoler(), alors Chien contient aussi cette méthode par extension.
Après 2 solutions :
- soit la méthode peutVoler() doit réagir de la même façon pour un simple animal que pour un chien. Dans ce cas là, rien à faire. Exemple de la class Chien.
- soit la méthode peutVoler() doit se comporter différemment. Dans ce cas là, il faut la redéfinir. Exemple de la class Oiseau.
01/06/2010, 18h39
Caxton

Alors si extends fais la liaison des deux classes, pourquoi donc on a créer un super() ?

Excusez mon ambiguïté mais je ne pense pas que super() à été créer pour pas être usité. Si je puis m'exprimer ainsi.
01/06/2010, 18h54
Génoce

Bonjour, je me joint à la discussion.

L'héritage et le mot clef super servent surtout à factoriser le code, c'est à dire ne pas écrire 50 fois la même chose.

Ici chien et oiseau ont des points commun, définis dans la classe Animal, on ne les écrits qu'une fois! les spécificités sont écrits dans chaque classe !

Citation:

Envoyé par Microbulle

Alors si extends fais la liaison des deux classes, pourquoi donc on a créer un super() ?

Excusez mon ambiguïté mais je ne pense pas que super() à été créer pour pas être usité. Si je puis m'exprimer ainsi.

super() (avec les parenthèse) sert à appeler le constructeur du parent. Si tu n'appelle pas explicitement le constructeur du parent, son constructeur par défaut sera appelé. Donc en pratique, on utilise l'appel explicite si on veux appeler un constructeur autre que le constructeur par défaut.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class A { public int i; public A(){ i=-1; } public A(int i){ this.i=i; } } public class B extends A { public B(){ super(69); // i vaudra 69 } } public class C extends A { // i vaudra -1 }
J'ai l'impression que tu te casse la tête a essayé de chercher des trucs compliqué à l'intérieur de quelque chose de simple. Une classe enfant hérite de tous les attributs et méthodes qui se trouvent dans la classe parent. Ensuite, les mots clés (protected, private, public) permette de déterminer parmis tout ce ce qui est visible et appelable, mais tout a été hérité.

01/06/2010, 19h37
Caxton

Ok !

A moi maintenant de mettre en pratique ce que j'ai appris là.

Merci pour ces infos :)

Bonjour,

J'ai de nouvelles questions à propos des classes, j'ai naturellement retirer le tag résolu car du coup, j'ai un nouveau problème !

C'est bien simple, j'ai attaqué ma classe, et d'ailleurs, je vais juste parler des setter/getter. Actuellement ma classe est du type j'envoie des données, elles sont traiter en semi récursivité car des retour dans le main sont réinjecter dans la même classe pour faire autre chose. A un moment donnée, j'ai besoin de tester la présence d'un fichier et en fonction créer ou non le fichier.

Mon premier choix aurais été de le faire depuis le main (mais si je doit tester à chaque manip utilisateur, ca deviens épique), du coup je me suis dit je vais l'écrire dans la classe. Et là, c'est une nouvelle question existentielle qui m'est venu !

C'est un setter car on envoie une url+nom fichier+extension mais c'est aussi un getter car elle renvoie un booléen. Donc c'est un setget(). Boarf ! C'est pas beau et ça ne veut rien dire.

Donc comment faire pour que dans une classe, au moment du setCreate(), je puisse aller sur mon setget() faire le test et au retour exécuter tel ou tel fonction.

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
 
package jGeeksClass;
 
import java.io.*;
import java.util.Properties;
 
public class jProperties {
    /*
     * ******************************************
     * * Les méthodes de la classe jProperties. *
     * ******************************************
     */
 
 
    /*
     * Méthode : Setter
     * Action : Mémoriser l'url du fichier à traiter
     * Paramettres : Chaine de caractère étant une url
     *
     */
    public void setUrl(String urlFichier) {
        this.urlFic = urlFichier;
    }
 
    /*
     * Méthode : Setter
     * Action : Ajouter une extension à un chemin absolu
     * Paramettres : Chaine de caractère étant un ajout du type "/repertoire"
     *
     */
    public void setRepAbsolu(String extAbsolu) {
        this.repAbsolu = extAbsolu;
    }
 
    /*
     * Méthode : Setter
     * Action : Place le nom du fichier à traiter
     * Paramettres : Chaine de caractère étant un nom
     *
     */
    public void setNameFichier(String nameFichier) {
        this.nameFic = nameFichier;
    }
 
    /*
     * Méthode : Setter
     * Action : Création d'un fichier properties vide
     * Paramettres : Aucun car défini dans la méthode setUrl(Chaine)
     */
    public void setCreate() {
 
        //Construction du properties
        Properties ficProp = new Properties();
        try {
             //Ici on fais un test ver le "setget()"... ???
 
             //Construction d'un flux de sortie fichier en mémoire.
            OutputStream fluxOutMem = new FileOutputStream(urlFic + nameFic + ".properties");
 
            //Construction d'un flux de sortie fichier avec un encodage.
            OutputStreamWriter fluxOutFic = new OutputStreamWriter(fluxOutMem, "UTF-8");
 
            //Création du fichier.
            ficProp.store(fluxOutFic, "Fichier properties");
 
            //Actualisation du flux.
            fluxOutFic.flush();
 
            //Fermeture du flux
            fluxOutFic.close();
        }
        catch (FileNotFoundException erreur) {
            erreur.printStackTrace();
        }
        catch (IOException erreur) {
            erreur.printStackTrace();
        }
    }
 
    /*
     * Méthode : Getter
     * Action : Retourner le path de l'exécutable
     * Paramettres : Aucun
     */
    public String getPath() {
 
        //Renvoie le path du logiciel
        return System.getProperty("user.dir");
    }
 
    public String getPathRep() {
 
        //Renvoie le path du logiciel et y ajoute un répertoire absolu
        return System.getProperty("user.dir") + repAbsolu;
    }
 
    /*
     * 
     * Test la présence du fichier
     * 
     */
 
    /*
     * Les champs de la classe
     */
 
    private String urlFic;      //Url du fichier à traiter
    private String repAbsolu;   //Répertoire absolu du fichier à traiter
    private String nameFic;     //Nom du fichier à traiter
}

20/06/2010, 23h28
Caalador

Citation:

Envoyé par Microbulle

C'est un setter car on envoie une url+nom fichier+extension mais c'est aussi un getter car elle renvoie un booléen. Donc c'est un setget(). Boarf ! C'est pas beau et ça ne veut rien dire.

Oula, tu te prends un peu la tête ! ;)
Dans une class, il n'y a pas que des getters et des setters !
Une méthode n'a pas l'obligation d'être un getter ou un setter.
Ces derniers sont en général créé pour gérer l'accès et l'écriture aux attributs d'un objet. Mais ensuite tu as des méthodes qui servent à "utiliser" ton objet pour faire tel ou tel action. Ou à questionner son état.
D'ailleurs, dans ton code, tu utilises des méthodes qui ne sont ni l'un ni l'autre. (flush(), close(), ...)

Pour ta class de propriété, ce que tu pourrais faire, c'est une méthode :

Code:

JProperties properties = JProperties.getInstance();

Cette méthode static, vérifirait la présence ou non du fichier, si il n'existe pas, elle le fabriquerait, et dans les 2 cas, elle fini par le retourner.
22/06/2010, 01h02
Caxton

Justement, plus je réfléchit à la possibilité de faire ainsi, moins j'arrive à comprendre comment l'intégré totalement...

Un petit exemple serais le bienvenu.

On pourrait imaginer la chose comme cela par 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
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
import java.io.*;
import java.util.Properties;
 
public class MyProperties {
	// Constante
	private final static String PROPERTIES_PATH = System.getProperty("user.dir") + "/myapp.properties";
 
	// Singleton
	private static MyProperties instance = null;
 
	// Attribut
	private Properties prop = null;
 
	// Constructeur
	private MyProperties(){
		prop = new Properties();
 
		// Si le fichier n'existe pas, on le crée
		if(!new File(PROPERTIES_PATH).exists()){
			save();
		}
 
		// lecture des proprietes
		read();
	}
 
	// récupération de l'instance
	public static MyProperties getInstance(){
		// Si l'instance n'existe pas, on la crée
		if(instance==null)instance = new MyProperties();
 
		return instance;
	}
 
 
	// Lecture/Ecriture des proprietes
	private void save(){
		try {			
			FileOutputStream out = new FileOutputStream(PROPERTIES_PATH);
			prop.store(out, null);
			out.flush();
			out.close();
		} catch (IOException e) {e.printStackTrace();}
	}
 
	private void read(){
		try{
			FileInputStream in = new FileInputStream(PROPERTIES_PATH);
			prop.load(in);
			in.close();
		}catch(Exception e){e.printStackTrace();}
	}
 
 
	// Ajout/Récupération des proprietes
	public void add(String key, String value){
		prop.setProperty(key, value);
		save();
	}
 
	public String get(String key){
		return (String)prop.get(key);
	}
}

L'ajout de propriété ce ferait comme ceci :

Code:

1
2
3
MyProperties prop = MyProperties.getInstance();
prop.add("PROP1", "propiété 1");
prop.add("PROP2", "propiété 2");

Et la récupération ce ferait comme ceci :

Code:

1
2
MyProperties prop = MyProperties.getInstance();
System.out.println(prop.get("PROP1"));

23/06/2010, 08h55
Caxton
Effectivement, ça serais une solution.
Cependant, il va falloir que je comprenne deux ou trois choses. ;)

Premièrement. Si je regarde cette exemple, j'ai remarqué qu'un appel pouvait ressemblé à ceci:
Code:

1 2 if(instance==null)instance = new MyProperties();
Je pensait qu'on était obliger de faire un truc du style Titi Polux = new Titi(); (c'est pas beau mais c'est pour l'exemple) et ensuite on l'utilisait ainsi Polux.methodeCastor();.

Cela voudrais-t-il dire qu'avec un simple [Test] instance = new Titi(); on face la même chose ?

Si oui, je comprends mieux comment je pourrait réaliser des tests à l'intérieur de ma classe.

Autre chose... J'ai parlé de semi-récursivité. Dans mon main, je fais appel à ma fonction, unique, pour chercher le chemin de base. Je lui réinjecte ce qu'elle à trouvé avec le dossier en plus et le nom du properties puis je le lui renvoie pour qu'elle procède à sa création / modification / rappel de donnée. Ce qui revient en algorithmie à faire ceci:

Citation:

si on initialise le programme
début
path <- jProperties().path
path <- path + dossier
jProperties() <- path
jProperties().création
fin

Je me demander du coup si c'est une utilisation normal ou s'il fallait que je sépare en deux classes.
23/06/2010, 10h20
Caalador
Citation:
Envoyé par Microbulle

Premièrement. Si je regarde cette exemple, j'ai remarqué qu'un appel pouvait ressemblé à ceci:

Code:

1 2 if(instance==null)instance = new MyProperties();

Je pensait qu'on était obliger de faire un truc du style Titi Polux = new Titi(); (c'est pas beau mais c'est pour l'exemple) et ensuite on l'utilisait ainsi Polux.methodeCastor();.

Cela voudrais-t-il dire qu'avec un simple [Test] instance = new Titi(); on face la même chose ?
On peut faire :
Titi polux = new Titi();

Mais on peut aussi faire :
Titi polux; (ou Titi polux = null; )
puis :
polux = new Titi();

C'est la 2e solution qui est utilisée. Si tu regardes dans les attributs de la class, il y a bien un MyProperties instance = null;

J'ai utilisé une forme du Design pattern Singleton, qui permet de verrouiller l'instanciation d'un objet à 1. Il n'est pas possible de fabriquer 2 instances de cet objet. Et étant donné que cet objet représente un fichier unique sur ton disque, il m'a semblé intéressant de l'utiliser. Je t'invite d'ailleur à te documenter sur ce pattern, qui est un des plus simples mais malgré tout très utile. Par exemple dans les applications desktop, cela peut permettre d'empêcher l'utilisateur d'ouvrir 15 fois la même fenêtre.

En ce qui concerne la suite de ton message, je n'ai pas tout compris :aie: donc je laisse les personnes plus compétente répondre ;)

Et bien quel bond en avant. Je voyais parfois des posts sur le design patterns, sans vraiment comprendre de quoi il s'agissait réellement.

Maintenant que je voie à quoi ça sert, je fonce sur les cours et je tombe ma classe car il faut qu'elle devienne facilement modifiable pour la suite. 8-)

Un grand merci Caalador pour ce petit message qui m'aura tant appri. :mouarf:

Je fais un édit car je veux éviter le double post. J'essai de créer un éventuel singleton dans ma classe mais je me rend compte que celle-ci s'intègre très mal. Je pense que je vais devoir tout reprendre à 0 ou presque !

D'ailleurs voici ce que j'ai fait. Je laisse les commentaires car elles permettrons, j'espère de mieux cerner mon problè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
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
 
package jGeeksClass;
 
import java.io.*;
import java.util.Properties;
 
public class jProperties {
    /*
     * ******************************************
     * * Les méthodes de la classe jProperties. *
     * ******************************************
     */
 
 
    /*
     * Méthode : Setter
     * Action : Mémoriser l'url du fichier à traiter
     * Paramettres : Chaine de caractère étant une url
     *
     */
    public void setUrl(String urlFichier) {
        this.urlFic = urlFichier;
    }
 
    /*
     * Méthode : Setter
     * Action : Ajouter une extension à un chemin absolu
     * Paramettres : Chaine de caractère étant un ajout du type "/repertoire"
     *
     */
    public void setRepAbsolu(String extAbsolu) {
        this.repAbsolu = extAbsolu;
    }
 
    /*
     * Méthode : Setter
     * Action : Place le nom du fichier à traiter
     * Paramettres : Chaine de caractère étant un nom
     *
     */
    public void setNomFichier(String nameFichier) {
        this.nameFic = nameFichier;
    }
 
    /*
     * Méthode : Setter
     * Action : Création d'un fichier properties vide
     * Paramettres : Aucun car défini dans la méthode setUrl(Chaine)
     */
    public void setCreate() {
 
        //Construction du properties
        Properties ficProp = new Properties();
        try {
 
            //Met en forme l'url
            String urlFinale = urlFic + nameFic + ".properties";
 
            //Si le chemin du fichier à traiter n'est pas présent
            //Ici on irait cherché le singleton à la place du if
            //if(new File(urlFinale).exists()) {
 
                //Construction d'un flux de sortie fichier en mémoire.
                OutputStream fluxOutMem = new FileOutputStream(urlFinale);
 
                //Construction d'un flux de sortie fichier avec un encodage.
                OutputStreamWriter fluxOutFic = new OutputStreamWriter(fluxOutMem, "UTF-8");
 
                //Création du fichier.
                ficProp.store(fluxOutFic, "Fichier properties");
 
                //Actualisation du flux.
                fluxOutFic.flush();
 
                //Fermeture du flux
                fluxOutFic.close();
            //}
        }
        catch (FileNotFoundException erreur) {
            erreur.printStackTrace();
        }
        catch (IOException erreur) {
            erreur.printStackTrace();
        }
    }
 
    /*
     * Méthode : Getter
     * Action : Retourner le path de l'exécutable
     * Paramettres : Aucun
     */
    public String getPath() {
 
        //Renvoie le path du logiciel
        return System.getProperty("user.dir");
    }
 
    public String getPathRep() {
 
        //Renvoie le path du logiciel et y ajoute un répertoire absolu
        return System.getProperty("user.dir") + repAbsolu;
    }
 
    /*
     * Singleton éventuel
     * Action : Tester la présence du fichier à traiter sous le path fourni
     * Paramètre : Aucun car fourni par urlFic + nameFic + ".properties";
     */
    //private static jProperties instanceTest = null;
 
 
 
    /*
     * Les champs de la classe
     */
 
    private String urlFic;      //Url du fichier à traiter
    private String repAbsolu;   //Répertoire absolu du fichier à traiter
    private String nameFic;     //Nom du fichier à traiter
}

J'espère que je ne me suis pas lancé dans une méthode spaghetti !

Javadoc?

Bonjour,

Je voudrais simplement apporter un petit conseil.;)
Le code est commenté, ce qui est très bien, néanmoins je conseillerai d'utiliser la javadoc.
Dans un EDI type eclipse, ça se fait tout seul, au dessus du nom de méthode il suffit de taper /** <Entrée>
Du coup on obtient quelque chsoe de ce type là:
Code:

1 2 3 4 5 6 7 /** * Effectue une recherche. * * @param criteres les critères de recherche * @return une liste de Tools correspondant aux critères */ private void maMethode(int u){
L'avantage, c'est que ça permet de générer directement la documentation, comme sur le site java, qui est standard. Et ensuite, c'est ce qui est affiché quand on survole un nom de fonction dans l'EDI.

Pour le dernier post, si le but est de mettre un patron singleton, ce n'est pas très compliqué...Dans la classe où il est installé.:lol:
Dans la classe jProperties, il suffit simplement d'y installer le patron.
http://fr.wikibooks.org/wiki/Patrons...Singleton#Java

En revanche, ça va induire du travail dans le reste du code, chaque fois que la classe jProperties était utilisé.
Au lieu de faire:
Code:

1 2 Titi u=new Titi(); u.maMethode();
Il faudra faire, qui est peut-être plus lourd:

Code:

jProperties.getInstance().maMethode();

Ça peut-être intéressant de se poser les questions pourquoi on souhaite utiliser un patron particulier, chacun ayant des avantages et inconvénients.

24/06/2010, 13h19
Caalador

Ta class est plutôt bien écrite, même si je n'ai pas l'habitude d'utiliser le même ordre que toi pour les méthodes et attributs. Par contre, je ne suis pas sûr que tu es choisi les bons attributs pour ta class.

Ce qu'il faut que tu te poses comme question, c'est que représente ma class jProperties ? (au passage, il est de convention qu'un nom de class commence par une capitale).

D'après ce que j'ai cru comprendre, tu souhaites qu'elle représente un fichier de propriete, qui sera à un emplacement prédéfini (et qui ne changera pas).
Avec laquelle tu souhaites pouvoir écrire des propriétés et les lire.

Du coup, les attributs que tu as choisi :
private String urlFic; //Url du fichier à traiter
private String repAbsolu; //Répertoire absolu du fichier à traiter
private String nameFic; //Nom du fichier à traiter

ne me semblent pas correspondre à ce que tu souhaites faire.

Sauf si je n'ai pas compris ce que tu comptes faire, je pense que la class que je t'ai proposé plus haut correspondrait mieux, non ? Sinon, explique nous plus en détail ce que représente ta class, et ce qu'elle doit être capable de faire.
24/06/2010, 20h50
Caxton

Et bien ma classe est divisé en plusieurs morceaux.

Le premier morceau est créer pour gérer le chemin avec diverses demandes.

Demande numéro 1. Dans le cas ou on veut travailler avec un fichier de configuration logiciel. On a alors soi la possibilité du /home.user/ soit la possibilité de se dire que le logiciel est sur une clef USB qui navigue de machine en machine.

Demande numéro 2. Dans le cas ou on sait ou est le début du chemin, on complète avec le dossier s'il y en a un. Métons que nous somme sur un fichier de travail. Il peut être situer n'importe ou est la donnée est complété par l'humain. (C'est dans ce cadre que je suis obliger de cherché la présence du chemin+fichier).

Demande numéro 3. Dans le cas ou on a le chemin, on peut alors créer la donnée en dur sur le disque en un fichier properties. On peut aussi, si on a le chemin et le fichier rappeler des données, voir en supprimer dans le fichier.

Donc à partir d'une seule classe (et c'est peut être pour ça que ca fait bazard) je voudrais gérer le ou les fichiers. Pour ce qui est de lire et d'écrire, j'ai déjà ce qu'il faut. Je cherche juste la meilleure organisation pour que le code me soit facilement modifiable. Ensuite il faut bien songé à ce que la classe ne soit pas juste un bout de code à tout faire mais elle doit permettre de travaillé avec d'autres programme et de partagée le concept. Pour le moment, je travaille sur des programme de tests mais les configurations sont exotique. Alors pour palier à ce souci, j'ai prévus d'avoir une classe centrale qui s'occupe des fichier + chemin puis chaque programme l'utilise.

C'est peut être pas très clair ce que je dis là. :triste:

Voila pour le concept.

Donc, si je comprend bien, tu veux écrire une librairie qui permette de gérer des fichiers properties.
La seule chose qui à l'air de changer en fonction des différentes demandes que tu as donné, c'est l'emplacement des fichiers properties.
Dans ce cas là, tu devrais gérer l'emplacement du fichier depuis tes autres applications et faire une librairie plus générique à laquelle tu lui donnes le chemin où tu veux mettre le fichier... oula c'est moi qui ne suis plus très clair..

Du code :
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 import java.io.*; import java.util.Properties; public class MyProperties { // Attribut private Properties prop = null; private String path; // Constructeur public MyProperties(String path){ prop = new Properties(); this.path = path; // Si le fichier n'existe pas, on le crée if(!new File(path).exists()){ save(); } // lecture des proprietes read(); } // Lecture/Ecriture des proprietes private void save(){ try { FileOutputStream out = new FileOutputStream(path); prop.store(out, null); out.flush(); out.close(); } catch (IOException e) {e.printStackTrace();} } private void read(){ try{ FileInputStream in = new FileInputStream(path); prop.load(in); in.close(); }catch(Exception e){e.printStackTrace();} } // Ajout/Récupération des proprietes public void add(String key, String value){ prop.setProperty(key, value); save(); } public String get(String key){ return (String)prop.get(key); } }
Ensuite, dans ton premier programme tu pourras faire :
Code:

1 2 3 MyProperties prop = new MyProperties(System.getProperty("user.dir") + "/myapp.properties"); prop.add("PROP1", "propiété 1"); prop.add("PROP2", "propiété 2");
Dans le 2e :
Code:

1 2 3 MyProperties prop = new MyProperties(textfield_path.getText()); prop.add("PROP1", "propiété 1"); prop.add("PROP2", "propiété 2");
et ainsi de suite.

Ta bibliothèque gère les propriétés, il suffit de lui dire où les mettre.

Voir 40 message(s) de cette discussion en une page