Design Pattern - étendre un POJO sans le modifier
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:
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:
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:
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:
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:
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:
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:
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.
