Discussion :

[Caxton]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[jcdentons]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Une classe fille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Une autre classe fille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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 !

[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

[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.

[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.

[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 !

[tchize_]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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é.

[Caxton]

Ok !

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

Merci pour ces infos

[Caxton]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
}

[Caalador]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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.

[Caalador]

On pourrait imaginer la chose comme cela par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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:

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.

[Caalador]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 donc je laisse les personnes plus compétente répondre

[Caxton]

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.

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


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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[Rams7s]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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é.
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Titi u=new Titi();
u.maMethode();

Il faudra faire, qui est peut-être plus lourd:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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.

[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à.

Voila pour le concept.

[Caalador]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.