Discussion :

[jon4ci]

Bonjour à toute la communauté développez.net, j'epsere que vous vous portez bien.
Je tiens à m'excuser de la longueur de mon message.

Je suis débutant en programmation Java, et ce Mr Java me pose quelques soucis. Néanmoins j'aime ce que je fais , et j'ai envie de comprendre pour mieux avancer.
Je bûche actuellement sur un exercice qui concerne la création d'un carnet d'adresse et j'ai quelques questions que je vous poserai sans doute par ci par là ^^.
J'explique brièvement les consignes de l'exercice :

*Création d'un carnet d'adresse, composé de plusieurs types(connaissances, amis, famille).
*Les fiches personnes de ces types sont stockés dans un Vecteur.
*Selon les attributs déterminés dans l'exercice, la hiérarchie est la suivante : connaissances est superclasse de amis, qui est une superclasse de famille.
*il est possible d'ajouter(ds ordre alphabétique) ou supprimer une fiche à partir du nom(l'attribut) de la personne qui est saisit.

A partir de la tout est clair dans ma tête, donc en bref:
-je crée une classe carnet avec une méthode de stockage, et une méthode d'affichage de l'ensemble des fiches.
-je crée une superclasse connaissances ayant comme comportement l'affichage des caractéristiques des fiches.
-Amis hérite de connaissances et famille hérite de amis; les deux héritent de la méthode et des attributs de connaissances.
-D'après moi un carnet n'ajoute ou ne supprime pas lui même une fiche, donc je crée une classe reglages qui prendra en charge ces méthodes.

Ensuite ça se brouille.
Ma méthode d'ajout est la suivante :

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
    Vector fiches=new Vector();
 
public void ajout(connaissances c){
        String nom="";
 
 
        try {
            System.out.println("veuillez saisir un nom :");
            nom=saisies.saisie(); //méthode de saisie importée
 
            if(nom.equals(c.nom)){
                for(int i=0;i<fiches.size();i++){
                   //déclaration du type dobjet de mon vecteur
                   connaissances co=(connaissances)fiches.get(i);
                     if(c.nom.compareTo(co.nom)>0){
                         fiches.add(i+1,c);
           }}}
        } catch (Exception ex) {
            System.out.println("erreur saisie");}
    }

J'ai passé une référence à l'objet connaissances en paramètre de ma méthode, donc j'aurai besoin de le passer lors de l'appel de la méthode dans la classe main où j'exécute le prg.

Quand j'appelle ma méthode - mesreglages.ajout(parametre); -, je passe en paramètre la référence précise d'une instance(ex : a1 qui représente ma fiche ami1), donc ma méthode ne travaille que pour cette instance, en gros je dois saisir l'attribut nom correspondant et le mettre en paramètre de ma méthode pour qu'il s'ajoute ds le Vecteur !! :/
De même si je saisis un nom différent, mais existant, de l'attribut nom de l'objet référencé en paramètre(ex : a1), rien n'est ajouté dans mon Vecteur. Double problème.

Or je souhaite que ma méthode :
-compare le nom saisi parmi tout les attributs nom de toutes mes instances fiches
-et que si ce nom existe, ajouter cette fiche dans mon Vecteur ds l'ordre alpha.

Comment appeler une méthode avec en paramètre une référence permettant de fonctionner avec n'importe quel type d'instances d'un même objet(ici connaissances), et pas justement avec une instance précise?

Je me prends la tête dessus depuis quelques jours; une aide, des éclaircissements, ou une correction pédagogique seraient appréciés !

[rebel64]

Quelques remarques:

- Conventionnellement le nom des classes débutent par un majuscule et le nom des instances par une minuscules.
- A partir de JAVA 1.5 tu peux typer tes collections
dans ton code ...

Code :

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

1
2
Vector<Connaissances> fiches=new Vector<Connaissances>(); 
public void ajout(Connaissances c) {...

- Concernant le bout de code:

Au départ tu n'as rien dans tes fiches (fiches.size()==0). Donc tu ne rentre jamais dans ta boucles.

Je te conseil donc d'écrire:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
	        int i;
                for(i=0;i<fiches.size();i++){
                   //déclaration du type dobjet de mon vecteur
                   connaissances co=(connaissances)fiches.get(i);
                   if (c.nom.compareTo(co.nom)<=0){      // co est après le nom à insérer
                       break;
                   }
                }
                if (c.nom.compareTo(co.nom)<0) fiches.add(i,c); // Insère si ce n'est déjà fait

- Je ne vois pas trop l'intérêt de passer en paramètre "connaissance c" Et juste après demander sont nom .
Si tu passes connaissance en paramètre c'est que tu as déjà son nom ?!

- Si l'énoncer de ton exercice te laisse le choix utilise un TreeSet<Connaissances> au lieu d'un Vector
Lors d'un ajout dans un TreeSet, tes connaissances resteront uniques (via equals) et triées (via compareTo)

- Bizare de hiérachiser des propriétés "mutables" pour une même personne...

Selon les attributs déterminés dans l'exercice, la hiérarchie est la suivante : connaissances est superclasse de amis, qui est une superclasse de famille

Si une connaissance devien ton meilleur ami puis se marie avec ta soeur ... Il devra changer 2X d'instance de classe .

[rebel64]

Voici un bout de code...J'espère que çà pourra t'aider

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
import java.util.Vector;
 
 
public class TestCarnetAdresse {
 
	/**
         * Fiche concernant une personne...
         */
	class Personne implements Comparable<Personne>{
		private String nom;
		//...et d'autres propriétés...
 
		public Personne(String nom) throws IllegalArgumentException{
			if (nom==null) throw new IllegalArgumentException();
			this.nom = nom;
		}
 
		public String getNom() {
			return nom;
		}
 
		public String toString() {
			return nom;
		}
 
		/**
                 * Equivalence de deux personnes 
                 */
		public boolean equals(Object o) {
			if (o instanceof Personne && o!=null) {
				return nom.equals(((Personne)o).nom);
			}
			else {
				return super.equals(o);
			}
		}
 
		/**
                 * Pour le tri
                 */
		public int compareTo(Personne o) {
			if (o==null) return -1;
			return this.nom.compareTo(o.nom);
		}
	}
 
	class Connaissance extends Personne {
		public Connaissance(String nom) throws IllegalArgumentException {super(nom);}
	}
	class Ami extends Connaissance {
		public Ami(String nom) throws IllegalArgumentException {super(nom);}
	}
	class AmiDeLaFamille extends Ami {
		public AmiDeLaFamille(String nom) throws IllegalArgumentException {super(nom);}
	}
 
	/**
         * Personnes qui constituent un carnet d'adresse
         *
         * @param <T>
         */
	class Personnes<T extends Personne> extends Vector<T> {
 
		/**
                 * Ajouter une personne au carnet en respectant l'ordre des personnes
                 * 
                 * @param personne
                 * @return true si la personne à été ajoutée ou remplacée dans le carnet
                 */
		public boolean ajout(T personne) {
			int i=0;
			for (T p:this) {
				int compare = p.compareTo(personne);
				if (compare==0) {
					/*
					 * Remarque:
					 * une connaissance peut devenir un ami 
					 * un ami peut se marier avec votre soeur ...devient donc un ami de la famille
					 */
					if (p.getClass().isAssignableFrom(personne.getClass()) && !personne.getClass().isAssignableFrom(p.getClass())) {
						i=indexOf(p);
						remove(i); // ICI et les référence qui pourraients exister ailleur...PROBLEME !!!
						break;
					}
					else return false;
				}
				if (compare < 0) i++; 
				else break;
			}
			add(i,personne);
			return true;
		}
 
		public void supprime(String nom) {
			//TODO 
		}
 
		/**
                 * Extraction des personnes d'une classe donnée
                 * 
                 * @param <C>
                 * @param personneClass
                 * @return
                 */
		public <C extends T> Personnes<C> get(Class<C> personneClass) {
			Personnes<C> personnes=new Personnes<C>();
			for (Personne personne : this) {
				if (personneClass.isAssignableFrom(personne.getClass())) {
					personnes.add((C)personne);
				}
			}
			return personnes;
		}
 
		/**
                 * Editer la liste des personnes
                 * 
                 * @param titre
                 */
		public void printSystemOut(String titre) {
			if (this.elementCount>0) {
				System.out.println("\n"+titre);
				for (T personne : this) {
					System.out.println(personne); // Idem que... System.out.println(personne.toString());
				}
			}
		}
	}
 
	Personnes<Connaissance> fiches=new Personnes<Connaissance>();
 
	// Methodes de saisie a voir... dans la classe Reglages...
	{
		fiches.ajout(new Connaissance("Adrien Sambre"));
		fiches.ajout(new Connaissance("Elisa Duprés")); // Connaissance devenue une amie
		fiches.ajout(new Connaissance("Jacques Dupont"));
		fiches.ajout(new Connaissance("Alexei Popov"));
		fiches.ajout(new Connaissance("Julie Dumont"));
 
		fiches.ajout(new AmiDeLaFamille("Pauline Desmet")); // Amie qui s'est marié avec Jules
		fiches.ajout(new AmiDeLaFamille("Jules Desmet"));
		fiches.ajout(new AmiDeLaFamille("Annie Desmet"));
 
		fiches.ajout(new Ami("Pauline Desmet"));  // Amie qui s'est marié avec Jules
		fiches.ajout(new Ami("Elisa Duprés")); // Connaissance devenue une amie
	}
 
	public static void main(String[] args) {
		TestCarnetAdresse testCarnetAdresse=new TestCarnetAdresse();
 
		Personnes<Ami> amis = testCarnetAdresse.fiches.get(Ami.class);
		Personnes<AmiDeLaFamille> amisDeLaFamille = testCarnetAdresse.fiches.get(AmiDeLaFamille.class);
		Personnes<Connaissance> connaissances = testCarnetAdresse.fiches.get(Connaissance.class);
 
		connaissances.printSystemOut("-- Connaissances ");
		amis.printSystemOut("--  Amis");
		amisDeLaFamille.printSystemOut("--  Amis de la Familles");
	}
 
}

[jon4ci]

Salut;

- Je ne vois pas trop l'intérêt de passer en paramètre "connaissance c" Et juste après demander sont nom .
Si tu passes connaissance en paramètre c'est que tu as déjà son nom ?!

Tout à fait, je voyais également un soucis dans cette façon de procéder.

Finalement j'ai modifié tout le tintouin; et, pour ce cas, crée une methode ajoutype specifique à mon type de fiche(connaissances, amis et famille).

Celle ci permet de créer un objet connaissances à partir de son constructeur.
A noter que amis est un type de connaissances et famille également, étant donné qu'ils sont sous classes.

Les constructeurs amis et famille héritent de la super classe connaissances; ils leurs sont rajouter des parametres eventuels, et leurs constructeurs sont ainsi surchargés.

Dès lors , à chaque instanciation, avec une autre méthode ajoutfiches je rajoute l'instance, trié par ordre alphabétique, dans mon Vector fiches

j'éditerai le code que j'ai ecrit plus tard dans la soirée; là je manque de temps.

Merci encore rebel64 pour ta contribution.

- Bizare de hiérachiser des propriétés "mutables" pour une même personne...

Il me semble, effectivement que le plus logique aurait été une hierarchie transverse, du type :
carnet superclasse de connaissances - amis - famille.

mais l'exercice exigeait une hiérarchie connaissances superclasse de amis qui est superclasse de famille; et carnet étant une classe à part -_-.

[jon4ci]

Bonjour;

au final, j'ai pensé à un carnet d'adresses, avec un menu qui gère toutes les instructions(les comportements) du carnet.
cela va de l'ajout, affichage, à la suppression, en passant par la sauvegarde de contacts.

selon l'exercice, j'ai une classe carnet à part; une classe connaissances qui est super classe d'une classe amis, qui est elle même super classe d'une classe famille.

NB : dans mes classes connaissances, amis et famille, les constructeurs sont vides mais font appel à une saisie des parametres; c'est à ce moment que les objets sont instanciés(via la methode menu).
et étant donné que ma methode menu gère une fonction supprimer, je n'ai mis aucun set ou get .

et pour lancer mon programme, j'ai une classe main, dans laquelle j'instancie un Vecteur, un carnet, et où j'appelle seulement ma méthode menu(qui gère tout).

pour un apercu,
ma superclasse connaissances se présente comme ceci :

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
package objet7;
 
import clavier.saisies;
import java.io.Serializable;
 
public class connaissances implements Serializable{
 
    protected String nom;
    protected String prenom;
    protected String rue;
    protected String cp;
    protected String ville;
    protected String tel;
    protected String email;
 
    //constructeur
    public connaissances(){
        System.out.println("nom?");
        nom=saisies.saisie();
        System.out.println("prenom?");
        prenom=saisies.saisie();
        System.out.println("tel?");
        tel=saisies.saisie();
        System.out.println("rue?");
        rue=saisies.saisie();
        System.out.println("cp?");
        cp=saisies.saisie();
        System.out.println("ville?");
        ville=saisies.saisie();
        System.out.println("email?");
        email=saisies.saisie();
    }
 
    public void caracteristiques(){
        System.out.println("type : "+this.getClass().getSimpleName());
        System.out.println("nom : "+nom);
        System.out.println("prenom : "+prenom);
        System.out.println("tel : "+tel);
        System.out.println("adresse : "+rue+" - "+cp+" "+ville);
        System.out.println("mail : "+email);}
}

la classe carnet donne cela :

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
package objet7;
 
import clavier.saisies;
import java.util.Vector;
import Vector.sauVector;
 
public class carnet {
 
    Vector fiches;
 
    public void menu(){
 
        fiches=sauVector.recuperer();
        if(fiches==null){
           fiches=new Vector();
        }
 
        String choix="";
        int ent=0;
 
        do{
        System.out.println("--------------");
        System.out.println("MENU PRINCIPAL");
        System.out.println("--------------");
        System.out.println("-1- ajouter une connaissance");
        System.out.println("-2- ajouter un ami");
        System.out.println("-3- ajouter un parent");
        System.out.println("-4- afficher mon repertoire");
        System.out.println("-5- afficher par type de contacts");
        System.out.println("-6- supprimer un contact");
        System.out.println("-7- supprimer tout le répertoire");
        System.out.println("-8- sauvegarder mon répertoire");
        System.out.println("-9- quitter");
 
        do{
            System.out.println("-------");
            System.out.println("choix ?");
            choix=saisies.saisie();
            if(!choix.equals("")&& (choix.equals("1")||choix.equals("2")||choix.equals("3")
                        ||choix.equals("4")||choix.equals("5")||choix.equals("6")||choix.equals("7")
                        ||choix.equals("8")||choix.equals("9"))){
                        ent=Integer.parseInt(choix);
            }else{
                ent=0;
                System.out.println("un chiffre est demandé");
            }            
        }while(ent<1||ent>9);
 
        switch(ent){
            case 1 : System.out.println("-------------------------");
                     System.out.println("ajouter une connaissances");
                     System.out.println("-------------------------");
                     //instanciation
                     connaissances c=new connaissances();
                     //ajout dans vecteur
                     ajoutfiches(c);break;
            case 2 : System.out.println("--------------");
                     System.out.println("ajouter un ami");
                     System.out.println("--------------");
                     amis a=new amis();
                     ajoutfiches(a);break;
            case 3 : System.out.println("-----------------");
                     System.out.println("ajouter un parent");
                     System.out.println("-----------------");
                     famille f=new famille();
                     ajoutfiches(f);break;
            case 4 : System.out.println("-------------------");
                     System.out.println("repertoire général");
                     System.out.println("-------------------");
                     affichecarnet();break;
            case 5 : System.out.println("----------------------------");
                     System.out.println("affichage par type de contact");
                     System.out.println("----------------------------");
                     affichetype();break;
            case 6 : System.out.println("--------------------");
                     System.out.println("supprimer un contact");
                     System.out.println("--------------------");
                     supfiches();break;
            case 7 : supall();break;
            case 8 : sauvegarder();break;
            case 9 : quitter();break;
        }
        }while(ent!=9);
 
    }   
 
    public void affichecarnet(){
 
        if(fiches.size()>0){
        for(int i=0;i<fiches.size();i++){
            connaissances c=(connaissances)fiches.get(i);
            c.caracteristiques();
            System.out.println("----------------------");}
        }else{
            System.out.println("-----------------");
            System.out.println("repertoire vide !");
            System.out.println("-----------------");
        }}
 
    public void affichetype(){
        String type="";
        boolean contact=false;
 
 
        System.out.println("type ?");
        type=saisies.saisie();
       while(!type.equals("connaissances")&& !type.equals("amis")&& !type.equals("famille")){
           System.out.println("-----------------------------");
           System.out.println("veuillez saisir un type valide");
           System.out.println("-----------------------------");
           type=saisies.saisie();
       }
 
        System.out.println("--------------------------");
        System.out.println("répertoire  "+type);
        System.out.println("--------------------------");
 
        for(int i=0;i<fiches.size();i++){
            connaissances c=(connaissances)fiches.get(i);
            if(type.equals(c.getClass().getSimpleName())){
                contact=true;
                c.caracteristiques();                
                System.out.println("--------------");}
            }
               if(contact==false){
                  System.out.println("------------------------------------------");
                  System.out.println("il n'y a aucun contact du type "+type);
                  System.out.println("------------------------------------------");}
       }
 
    public void ajoutfiches(connaissances c){
        int i=0;
        while(i<fiches.size() && ((connaissances)fiches.get(i)).nom.compareTo(c.nom)<0){
            i++;
        }
        fiches.add(i,c);
    }
 
    public void supfiches(){
 
    String nom="";
    String prenom="";
    boolean sup=false;
 
    do{
    System.out.println("quel nom?");
    nom=saisies.saisie();
    }while(nom.equals(""));
    do{
    System.out.println("quel prenom?");
    prenom=saisies.saisie();
    }while(prenom.equals(""));
 
    for(int i=0;i<fiches.size();i++){
       connaissances co=(connaissances)fiches.get(i);
 
           if(nom.equals(co.nom)&& prenom.equals(co.prenom)){
                sup=true;
                fiches.remove(i);}
    }
    if(sup==false){
          System.out.println("-------------------------------------------------------");
          System.out.println("le nom '"+nom+"' et le prenom '"+prenom+"' n'existent pas");
          System.out.println("-------------------------------------------------------");}
    }
 
    public void supall(){
        String sup="";
        System.out.println("etes vous sur de vouloir tout supprimer? O/N");
        sup=saisies.saisie();
 
        while(!sup.equals("o")&&!sup.equals("n")){
            System.out.println("O ou N ?");
            sup=saisies.saisie();}
        if(sup.equals("o")){
            System.out.println("-------------------");
            System.out.println("Répertoire supprimé");
            System.out.println("-------------------");
            fiches.removeAllElements();
            sauVector.sauver(fiches);
        }
    }
 
    public void sauvegarder(){
        String sauv="";
 
        System.out.println("etes vous sûr de vouloir sauvegarder? O/N");
        sauv=saisies.saisie();
        while(!sauv.equals("o")&&!sauv.equals("n")){
            System.out.println("O ou N ?");
            sauv=saisies.saisie();
        }
        if(sauv.equals("o")){
            System.out.println("---------------------");
            System.out.println("répertoire sauvegardé");
            System.out.println("---------------------");
            sauVector.sauver(fiches);
        }
    }
 
    public void quitter(){
        String quit="";
 
        System.out.println("etes vous sûr de vouloir quitter? O/N");
        quit=saisies.saisie();
        while(!quit.equals("o")&&!quit.equals("n")){
            System.out.println("O ou N ?");
            quit=saisies.saisie();
        }
        if(quit.equals("n")){
            menu();
        }else{
            System.out.println("----------------");
            System.out.println("fin du programme");
            System.out.println("----------------");
        }
    }
}

je pense qu'il est possible d'optimiser le tout, mais c'est une autre histoire.
enfin le programme tourne, c'est déjà pas mal !

[rebel64]

Pour la partie découpage en classes çà c'est ok.

Par contre au niveau de l'implémentation et de la "mécanique" de tes classes, il y a pas mal de choses à faire remarquer:

- Attention aux conventions de notation...Je me répète...Les noms de classe doivent commencer par une lettre majuscule Connaissances, Famille, Carnet,Saisie...
Cà parait idiot mais c'est indispensable pour s'y retrouver entre les classe et les instances.
Programmer Orienté Objet c'est un peu comme devoir respecter des dogmes .

Responsabilité : Est-ce que cette méthode est de la responsabilité de cet objet ?
Délégation : Ne dois-je pas déléguer cette tache à un autre objet ?
Validité: Est-ce que les propriétés de mon objet sont valides ?
Encapsulation : Est-ce que les méthodes n'ont pas d'effets de bord ?
Réutilisabilité : Est-ce que mes classe seront réutilisables ?
...

- Les appel de méthode statiques doivent se faire avec parcimonie...
Saupoudrer tes classe avec Saisie.saisie dès que tu à besoins de données c'est contraire au principe d'encapsulation et rend tes classes inutilisables en dehors de ton programme.
Tu n'as plus aucuns paramètres dans tes méthode MAIS tes classes sont totalement liées à cette méthode spécifique d'encodage. (Réutilisabilité !)

- Il n'y a aucune validation de tes données...

au final, j'ai pensé à un carnet d'adresses, avec un menu qui gère toutes les instructions(les comportements) du carnet.
cela va de l'ajout, affichage, à la suppression, en passant par la sauvegarde de contacts.

Oups le piège du gros fourre tout...
Responsabilité et Délégation !

Un projet comporte des packages séparés généralement découpés comme suit:

Le modèle des données :
- Ce sont tes classe Connaissances,Amis,Famille et Carnet
- Ces classes comportent les propriétés et les méthodes de modification et validation de ces propriétés.

Persistance de ces données :
- Classes des Fichiers, DB,... et les mécanismes annexes (écritures, lectures...)

Les interfaces utilisateurs (UI)
- C'est ta classe Saisies
- panneaux, console,...
- Capable de visualiser certains changements dans les données.

Les controleurs
- Absent de ton code mais en gros c'est ce que tu as écris dans Carnet et dans le constructeur de Connaissances

- Ces classes devraient reprendre les intructions clefs des interactions entre les données et UI
- Réagissent aux evènements de l'UI pour impacter les données

J'espère ne pas avoir été trop
A+

[jon4ci]

Bonjour;

- Attention aux conventions de notation...Je me répète...Les noms de classe doivent commencer par une lettre majuscule Connaissances, Famille, Carnet,Saisie...
Cà parait idiot mais c'est indispensable pour s'y retrouver entre les classe et les instances.
Programmer Orienté Objet c'est un peu comme devoir respecter des dogmes.

Merci pour l'info.

Responsabilité : Est-ce que cette méthode est de la responsabilité de cet objet ?
Délégation : Ne dois-je pas déléguer cette tache à un autre objet ?
Validité: Est-ce que les propriétés de mon objet sont valides ?
Encapsulation : Est-ce que les méthodes n'ont pas d'effets de bord ?
Réutilisabilité : Est-ce que mes classe seront réutilisables ?
...

Oui c'est vrai, il faut toujours se poser les bonnes questions.
Encore faut il connaitre l'existence/la pertinence des ces questions et l'utilité des réponses à ces questions. Ce que je ne maitrise pas encore, car je débute.
Merci pour ce rappel.

- Les appel de méthode statiques doivent se faire avec parcimonie...
Saupoudrer tes classe avec Saisie.saisie dès que tu à besoins de données c'est contraire au principe d'encapsulation et rend tes classes inutilisables en dehors de ton programme.

Je le conçois tout à fait, mais quand bien même elle ne sont pas utilisables seules en dehors du programme, une importation de la bibliothèque contenant la ou les méthodes suffirait pour rendre les classes de nouveau fonctionnelles.
A ce niveau là, je dirai que c'est arbitraire; à moins qu'il existe un réel défaut ds l'optimisation du programme de par ce genre de procédé.

- Il n'y a aucune validation de tes données...

En quoi consiste la validation stp.

Un projet comporte des packages séparés généralement découpés comme suit:

Le modèle des données :
- Ce sont tes classe Connaissances,Amis,Famille et Carnet
- Ces classes comportent les propriétés et les méthodes de modification et validation de ces propriétés.

Persistance de ces données :
- Classes des Fichiers, DB,... et les mécanismes annexes (écritures, lectures...)

Les interfaces utilisateurs (UI)
- C'est ta classe Saisies
- panneaux, console,...
- Capable de visualiser certains changements dans les données.

Les controleurs
- Absent de ton code mais en gros c'est ce que tu as écris dans Carnet et dans le constructeur de Connaissances

- Ces classes devraient reprendre les intructions clefs des interactions entre les données et UI
- Réagissent aux évènements de l'UI pour impacter les données

Il y a encore des notions que je ne saisis pas, peut être me faudrait il des exemples pour visualiser concrètement ce découpage.
Je pense que je comprendrai au fur et à mesure de mon apprentissage.
Je prends tout de même note ce que tu as dit; merci rebel64.

[rebel64]

Je le conçois tout à fait, mais quand bien même elle ne sont pas utilisables seules en dehors du programme, une importation de la bibliothèque contenant la ou les méthodes suffirait pour rendre les classes de nouveau fonctionnelles.
A ce niveau là, je dirai que c'est arbitraire; à moins qu'il existe un réel défaut ds l'optimisation du programme de par ce genre de procédé.

...Fonctionnelles oui mais pas dans n'importe quel contexte...
Ecrire System.out.println suppose que tu utilises une console pour visualiser et encoder tes données.
Cà ne marchera plus si tu veux réutiliser ta classe Connaissance en encodant tes données dans panneau graphique ou une page Web.
Les classes qui dans ton exercices devraient pouvoir être réutilisables sont tes données (Carnets, Connaissances, Amis,...).
Donc les instructions dans ces classes qui dépendent du contexte (Saisie.saisie, System.out) devraient figurer ailleurs dans des classes du style EncodageCarnet (au lieu de mettre toutes tes actions dans Carnet), EncodageFiche.
Evidement pour un petit programme individuel cà pas paraitre superflux. Mais pour un projet plus lourd ce découpage est vital pour l'aboutissement et la périnité du projet.

En quoi consiste la validation stp

Par exemple quand tu écris...

Code :

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

1
2
3
 
System.out.println("email?");
email=saisies.saisie();

...Rien ne garanti que cet encodage est un email correct au niveau syntaxique.

Questions annexes à cette question:
Jusqu'où faut-il raffiner le modèle des données ?
Faut-il avoir des classes Email, Adresse... avec des méthodes de validation, ...?

Pas facile de débuter en Java.
A ce stade je t'invite à glaner des infos et à lire des tutoriels au fur et à mesure.
Il y a beaucoup de choses à savoir pour écrire un "simple petit programme".
Cà prend beaucoup de temps de lire ces montagnes de tutoriels et de documentations...c'est indigeste et parfois
Donc tu t'en sort pas mal.
Bonne continuation

[jon4ci]

Salut;

...Fonctionnelles oui mais pas dans n'importe quel contexte...
Ecrire System.out.println suppose que tu utilises une console pour visualiser et encoder tes données.
Cà ne marchera plus si tu veux réutiliser ta classe Connaissance en encodant tes données dans panneau graphique ou une page Web.

et si je passe un objet en parametre d'une methode d'affichage.
je pourrai caster le System.out.println comme ceci :

Code :

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

(System(mon objet)).out.println(ce que je veux afficher)

lors d'une réutilisation ds panneau graphique par exemple, il suffirait de remplacer le System.out.println par un objet correspondant à la fenêtre d'affichage.

en gros, une modification du code sera necessaire, mais pas la modification des signatures(je ne sais pas si je suis clair).

est ce possible, est ce utile.

Par exemple quand tu écris...

Code :

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

1
2
3
 
System.out.println("email?");
email=saisies.saisie();

...Rien ne garanti que cet encodage est un email correct au niveau syntaxique.

Questions annexes à cette question:
Jusqu'où faut-il raffiner le modèle des données ?
Faut-il avoir des classes Email, Adresse... avec des méthodes de validation, ...?

ok je vois, un petit programme peut se transformer en grosse toile d'araignée; mais à quel prix.