Discussion :

[lr.remy]

Bonjour,

je nécessite de l'aide pour comparer 2 objets, je m'explique.

J'ai un premier objet instancier, puis l'utilisateur le modifie.
J'aimerai savoir comment connaître quelles modifications l'utilisateur a apporté et les sauvegarder.

Mon objet est composé d'attributs de type primitif (String, float ...) ainsi que d'objet (Polynome, Unites...)

Actuellement j'arrive à obtenir quelque chose qui fonctionne pour mes objets mais pas pour les types primitifs, mais qui est très lourde à mon sens.

Voilà une partie de mon 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
 
try {
Field[] ancienAttributsCorps = //objetAvantModification;
Field[] nouveauAttributsCorps = //objetApresModification;
for (int i = 0; i < nouveauAttributsCorps.length; i++){			nouveauAttributsCorps[i].setAccessible(true);
	ancienAttributsCorps[i].setAccessible(true);
 
	if (nouveauAttributsCorps[i].get(nouveauCorps).getClass() == Polynome.class) {
                  Field[] ancienPoly = //ancien attributs du polynome
	     Field[] nouveauPoly = // nouveau attributs du polynome
	for (int j = 0; j < nouveauPoly.length ; j++) {
	     [j].setAccessible(true);
	     ancienPoly[j].setAccessible(true);
                  float ancien = (Float) ancienPoly[j]...;
	      float nouveau = (Float) nouveauPoly[j]...

Je vous épargne tout le reste, qui permet d'indiquer à l'utilisateur les modifications...

Je me doute qu'il va falloir utiliser un fichier log regroupant toutes les modifications, mais avant cela j'aimerai savoir quelle amélioration dois je effectuer dans mon code.


Merci,
Rémy.


Pour ceux qui veulent, voila mon code entier :

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
 
try {
Field[] ancienAttributsCorps = voie.getCorpsEpreuve()[corps].getClass().getSuperclass().getDeclaredFields();
Field[] ancienAttributsGenerique = voie.getCorpsEpreuve()[corps].getClass().getSuperclass().getSuperclass().getDeclaredFields();
Field[] nouveauAttributsCorps = nouveauCorps.getClass().getSuperclass().getDeclaredFields();
Field[] nouveauAttributsGenerique = nouveauCorps.getClass().getSuperclass().getSuperclass().getDeclaredFields();
 
for (int i = 0; i < nouveauAttributsCorps.length; i++){
	nouveauAttributsCorps[i].setAccessible(true);
	ancienAttributsCorps[i].setAccessible(true);
	if (nouveauAttributsCorps[i].get(nouveauCorps).getClass() == Polynome.class) {
	Field[] ancienPoly = ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]).getClass().getDeclaredFields();
	Field[] nouveauPoly = nouveauAttributsCorps[i].get(nouveauCorps).getClass().getDeclaredFields();					for (int j = 0; j < nouveauPoly.length ; j++) {				nouveauPoly[j].setAccessible(true);
	ancienPoly[j].setAccessible(true);
									float ancien = (Float) ancienPoly[j].get(ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]));
	float nouveau = (Float) nouveauPoly[j].get(nouveauAttributsCorps[i].get(nouveauCorps));
									if(ancien != nouveau) {
	System.out.print("\nChangement pour " + ancienPoly[j].getName() + " : " + 	ancienPoly[j].get(ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps])) +" -> "+nouveauPoly[j].get(nouveauAttributsCorps[i].get(nouveauCorps)));
 
}else {
	System.out.print("\nIdentique pour " + ancienPoly[j].getName() + " : " + ancienPoly[j].get(ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps])) +" = "+nouveauPoly[j].get(nouveauAttributsCorps[i].get(nouveauCorps)));
									nouveauPoly[j].setAccessible(false);
	ancienPoly[j].setAccessible(false);
}
 
} else {
	if (nouveauAttributsCorps[i].get(nouveauCorps) != ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps])) 
{
System.out.print("\nChangement pour " + ancienAttributsCorps[i].getName() + " : " + 	ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]) +" -> "+	nouveauAttributsCorps[i].get(nouveauCorps));
} else {	System.out.print("\nIdentique pour " + ancienAttributsCorps[i].getName() + " : " + ancienAttributsCorps[i].get(voie.getCorpsEpreuve()[corps]) +" -> "+	nouveauAttributsCorps[i].get(nouveauCorps));
		}
	}
nouveauAttributsCorps[i].setAccessible(false);
ancienAttributsCorps[i].setAccessible(false);
			}

[kox2ee]

Bonjour,
je ne sais pas exactement quel est ton objectif, mais s'il s'agit simplement de comparer 2 objets membre à membre, je ne vois pas trop l'intérêt de passer par l'introspection (reflexion), à moins que le nombre des membres à comparer soit vraiment important...

C'est plus à l'objet lui même de savoir se comparer à un autre :

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
public class MaClasse {
	private int member= 0;
 
	public List<Modification>getModifications(Object newObject) {
		List<Modification> result= new ArrayList<>();
		if(newObject.getClass().equals(getClass())){
			if(member!=newObject.getMember()){
				result.add(new Modification("member",member,newObject.getMember()));
			}
		}
		return result;
	}
 
	public int getMember() {
		return member;
	}
}

La classe gérant les modifications :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public class Modification{
	private String name;
	private Object oldValue;
	private Object newValue;
 
	public Modification(String name,Object oldValue,Object newValue){
		this.name=name;
		...
	}
	//Accesseurs

Ou tu peux utiliser la reflexion, mais pour faire par exemple une comparaison plus systématique de tous les membres :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
	public List<Modification>getModifications(Object newObject) {
		List<Modification> result= new ArrayList<>();
		if(newObject.getClass().equals(getClass())){
			for (Field field : this.getDeclaredFields()) {
				field.setAccessible(true);
				if(field.get(this)!=null&&!field.get(this).equals(field.get(newObject)){
					result.add(new Modification(field.getName(),field.get(this),field.get(newObject)));
				}
			}
		}
		return result;
	}

S'il s'agit de tracer les modifications effectuées, tu peux aussi implémenter Observable sur tes objets, et créer des messages dans les logs en cas de modifications des membres...

Dernière chose, pour des comparaisons de valeurs non primitives, tu devrais utiliser equals plutôt que ==.

[lr.remy]

Je te remercie, c'est exactement le style de réponse que j'attendais. J'approfondirai ceci demain mais je pense qu'avec ça je serai quoi faire
Mille merci,
Rémy.