Discussion :

[domiq44]

Bonjour,

Je cherche à nettoyer du code existant.

Voilà résumé ce que je vois.

J'ai des classes de type POJO ou Bean, disons par exemple A et B.

Je vois aussi des classes de traitement G.

Ces classes possèdent des méthodes de garnissage, par exemple garnir(c1, c2), qui garnit une instance nouvellement créée c1 avec des éléments de l'instance c2.

Un exemple sera plus parlant :

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
package garnissage.model;
 
public class A {
	private String ma1;
	private String ma2;
	private String ma3;
 
	public String getMa1() {
		return ma1;
	}
 
	public void setMa1(String ma1) {
		this.ma1 = ma1;
	}
 
	public String getMa2() {
		return ma2;
	}
 
	public void setMa2(String ma2) {
		this.ma2 = ma2;
	}
 
	public String getMa3() {
		return ma3;
	}
 
	public void setMa3(String ma3) {
		this.ma3 = ma3;
	}
 
	@Override
	public String toString() {
		return "A [ma1=" + ma1 + ", ma2=" + ma2 + ", ma3=" + ma3 + "]";
	}
}

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
package garnissage.model;
 
public class B {
	private String mb1;
	private String mb2;
	private String mb3;
 
	public String getMb1() {
		return mb1;
	}
 
	public void setMb1(String mb1) {
		this.mb1 = mb1;
	}
 
	public String getMb2() {
		return mb2;
	}
 
	public void setMb2(String mb2) {
		this.mb2 = mb2;
	}
 
	public String getMb3() {
		return mb3;
	}
 
	public void setMb3(String mb3) {
		this.mb3 = mb3;
	}
 
	@Override
	public String toString() {
		return "B [mb1=" + mb1 + ", mb2=" + mb2 + ", mb3=" + mb3 + "]";
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
package garnissage.process;
 
import garnissage.model.A;
import garnissage.model.B;
 
public class G {
	public static void garnir(A instA, B instB) {
		instA.setMa1(instB.getMb1());
		instA.setMa2(instB.getMb2());
		instA.setMa3(instB.getMb3());
	}
}

L'application principale est:

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
package garnissage;
 
import garnissage.model.A;
import garnissage.model.B;
import garnissage.process.G;
 
public class App {
 
	public static void main(String[] args) {
		B instB = new B();
		instB.setMb1("bbb1");
		instB.setMb2("bbb2");
		instB.setMb3("bbb3");
 
		A instA = new A();
		G.garnir(instA, instB);
		System.out.println(instA.toString());
	}
}

Et voici le résultat:

Code :

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

A [ma1=bbb1, ma2=bbb2, ma3=bbb3]

Ma question, ne serait-il pas mieux que ces méthodes de garnissage soient implémentées dans des classes étendant la classe A et que l'on appellerait par instA.garnirFrom(instB) ?

En utilisant les Design Pattern par exemple?

Par exemple (ce code ne fonctionne pas) G serait :

Code :

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

1
2
3
4
5
6
7
public class G extends A {
	public void garnirFrom(B instB) {
		this.setMa1(instB.getMb1());
		this.setMa2(instB.getMb2());
		this.setMa3(instB.getMb3());
	}
}

et le main serait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class App {
 
	public static void main(String[] args) {
		B instB = new B();
		instB.setMb1("bbb1");
		instB.setMb2("bbb2");
		instB.setMb3("bbb3");
 
		A instA = new A();
		instA.garnirFrom(instB);
		System.out.println(instA.toString());
	}
}

Mais sans changer A et B.

Merci d'avances pour votre aide.

[tchize_]

Pas vraiment:

la classe qui étends n'ajoute pas vraiment de comportement spécifique à A ou à B, elle est liée au comportement liant A et B. Du coup, la méthode devrait etre dans A ou dans B ??
Il y a souvent de bonne raison pour lesquelles A et B sont séparés quand ont fait ce genre de transfert. Genre une des classes et un DTO devant etre sérialisé chez le client, l'autre est une classe de stockage. Faire un mix entre les deux avoir des conséquence en aval.

Soit tu ajoute une méthode dans A ou B, mais tu n'étends pas, la sous classe n'apporte rien.
Soit tu garde des helper method qui font le transfert.

Les deux se valent selon moi.

[domiq44]

Pas vraiment:

Bonsoir tchize_.

Ca me dérange de modifier A et B. Parce que ça m'obligerait à les lier l'une à l'autre, ce qui n'est pas le cas actuellement.

Par contre j'ai lu qu'il était possible d'ajouter un comportement à une classe existante sans la modifier. Mais je ne vois pas comment.

[tchize_]

Dans ce cas, go pour les helpers tels qu'ils sont actuellement déjà implémentés dans ton code. Qu'est-ce qui ne te plait pas là dedans?

Pour la liaison, sans savoir le role des classes, difficile de savoir si ça a du sens de les liers. Quand on parle d'un EJB et d'un DTO, ça a du sens d'avoir des méthodes dans l'EJB qui génèrent et lisent le DTO. Dans d'autres cas, ça n'a pas de sens.

[domiq44]

Dans ce cas, go pour les helpers tels qu'ils sont actuellement déjà implémentés dans ton code. Qu'est-ce qui ne te plait pas là dedans?

Ce n'est pas que ça me déplait, mais je pensais que cela aurait été plus propre et plus objet.

Mais si ça ne choque pas, ça me va. Donc go pour les helpers.

Merci tchize_

[domiq44]

Mais tout de même, le fait d'étendre peu fonctionner ou pas ?

Si oui, comment ?

Moi j'arrive à ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
package garnissage.process;
 
import garnissage.model.A;
import garnissage.model.B;
 
public class G extends A {
	public void garnirFrom(B instB) {
		setMa1(instB.getMb1());
		setMa2(instB.getMb2());
		setMa3(instB.getMb3());
	}
}

et pour la classe principale :

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
package garnissage;
 
import garnissage.model.B;
import garnissage.process.G;
 
public class App {
 
	public static void main(String[] args) {
		B instB = new B();
		instB.setMb1("bbb1");
		instB.setMb2("bbb2");
		instB.setMb3("bbb3");
 
		G instA = new G();
		instA.garnirFrom(instB);
		System.out.println(instA.toString());
	}
}

qui donne bien le résultat :

Code :

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

A [ma1=bbb1, ma2=bbb2, ma3=bbb3]

Mais c'est G que j'ai instancié et non A !!!

Qu'en penses-tu ?

[thelvin]

Hello,

bah que veux-tu en penser ? Tu as plutôt bien résumé la chose...
Ça marche, mais ce que tu as instancié, c'est G, pas A.

Maintenant ça te dérange ou pas, moi je trouve ça tiré par les cheveux.

[domiq44]

Merci thelvin pour ton retour.

Moi aussi je trouve ça un peu tiré par les cheveux.
Je voulais simplement aller jusqu'au bout pour voir ce qu'il était possible de faire et si ça en valait la peine.
Apparemment non.

Encore merci à tous les deux.