Problème de mutualisation des setters

Version imprimable

Bonjour,

Je suis en présence de code que je cherche à simplifier (c'est un « test case »).

J'ai les 2 classes suivantes A et B :

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
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
public class A {
	private String ma1;
	private String ma2;
	private String ma3;
	private String m1;
	private String m2;
	private String m3;
 
	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;
	}
 
	public String getM1() {
		return m1;
	}
 
	public void setM1(String m1) {
		this.m1 = m1;
	}
 
	public String getM2() {
		return m2;
	}
 
	public void setM2(String m2) {
		this.m2 = m2;
	}
 
	public String getM3() {
		return m3;
	}
 
	public void setM3(String m3) {
		this.m3 = m3;
	}
 
	@Override
	public String toString() {
		return "A [ma1=" + ma1 + ", ma2=" + ma2 + ", ma3=" + ma3 + ", m1=" + m1 + ", m2=" + m2 + ", m3=" + m3 + "]";
	}
}

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
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
public class B {
	private String mb1;
	private String mb2;
	private String mb3;
	private String m1;
	private String m2;
	private String m3;
 
	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;
	}
 
	public String getM1() {
		return m1;
	}
 
	public void setM1(String m1) {
		this.m1 = m1;
	}
 
	public String getM2() {
		return m2;
	}
 
	public void setM2(String m2) {
		this.m2 = m2;
	}
 
	public String getM3() {
		return m3;
	}
 
	public void setM3(String m3) {
		this.m3 = m3;
	}
 
	@Override
	public String toString() {
		return "B [mb1=" + mb1 + ", mb2=" + mb2 + ", mb3=" + mb3 + ", m1=" + m1 + ", m2=" + m2 + ", m3=" + m3 + "]";
	}
}

On remarquera que les 2 classes ont 3 membres ayant le même nom (m1, m2, m3).

Et voici schématisé le programme principale :

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
public class App1 {
 
	public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
		mapRow(a);
		System.out.println("a: " + a.toString());
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
		mapRow(b);
		System.out.println("b: " + b.toString());
	}
 
	private static void mapRow(A obj) {
		obj.setM1("ccc111");
		obj.setM2("ccc222");
		obj.setM3("ccc333");
	}
 
	private static void mapRow(B obj) {
		obj.setM1("ccc111");
		obj.setM2("ccc222");
		obj.setM3("ccc333");
	}
}

qui me retourne cela:

Code:

1
2
a: A [ma1=aaa111, ma2=aaa222, ma3=aaa333, m1=ccc111, m2=ccc222, m3=ccc333]
b: B [mb1=bbb111, mb2=bbb222, mb3=bbb333, m1=ccc111, m2=ccc222, m3=ccc333]

Le problème consiste à valoriser les membres (m1, m2, m3) par la même méthode en utilisant par exemple la généricité.
Est-ce possible ?
Par exemple comme ça (cela ne fonctionne pas bien sur !) :

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
public class App2 {
 
	public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
		mapRow(a);
		System.out.println("a: " + a.toString());
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
		mapRow(b);
		System.out.println("b: " + b.toString());
	}
 
	private static <T> void mapRow(T obj) {
		obj.setM1("ccc111");
		obj.setM2("ccc222");
		obj.setM3("ccc333");
	}
}

Quelqu'un peut-il m'aider svp ?
Merci.

Ce n'est pas un problème de généricité, juste un problème d'héritage tout simple. Pour refactorer du code commun, on crée une classe parent commune.

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
public class M {
	private String m1;
	private String m2;
	private String m3;
 
	public String getM1() {
		return m1;
	}
 
	public void setM1(String m1) {
		this.m1 = m1;
	}
 
	public String getM2() {
		return m2;
	}
 
	public void setM2(String m2) {
		this.m2 = m2;
	}
 
	public String getM3() {
		return m3;
	}
 
	public void setM3(String m3) {
		this.m3 = m3;
	}
 
	@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
public class A extends M{
	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 + ", m1=" + getM1() + ", m2=" + getM2() + ", m3=" + getM3() + "]";
	}
}

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
public class B extends M{
	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 + ", m1=" + getM1() + ", m2=" + getM2() + ", m3=" + getM3() + "]";
	}
}

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
public class App2 {
 
	public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
		mapRow(a);
		System.out.println("a: " + a.toString());
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
		mapRow(b);
		System.out.println("b: " + b.toString());
	}
 
	private static void mapRow(M obj) {
		obj.setM1("ccc111");
		obj.setM2("ccc222");
		obj.setM3("ccc333");
	}
}

Quand ce n'est pas possible, on peut toujours faciliter l'usage de la classe en utilisant plutot un interface à la place d'une classe parent. Les getter restent alors multipliés, mais on peut les manipuler de manière générale.

04/12/2015, 05h13
domiq44
Citation:

Envoyé par tchize_

Ce n'est pas un problème de généricité, juste un problème d'héritage tout simple. Pour refactorer du code commun, on crée une classe parent commune.

Bonjour et merci pour ta réponse tchize_.

Oui, si je pouvais modifier ces classes, je l'aurais fait comme ça. Mais ce n'est hélas pas possible pour des raisons techniques non exposées dans ce post.

Toutefois, je souhaite vraiment mutualiser ces méthodes identiques.

Citation:

Envoyé par tchize_

Quand ce n'est pas possible, on peut toujours faciliter l'usage de la classe en utilisant plutot un interface à la place d'une classe parent. Les getter restent alors multipliés, mais on peut les manipuler de manière générale.

Cela serait donc possible en utilisant des interfaces !
Code:

1 2 3 4 5 6 7 8 public interface Z { public String getM1(); public void setM1(String m1); public String getM2(); public void setM2(String m2); public String getM3(); public void setM3(String m3); }
Je ne vois pas comment ?
04/12/2015, 09h15
tchize_

En ayant ta classe A et B implémentant cette interface

Citation:

Envoyé par tchize_

En ayant ta classe A et B implémentant cette interface

Yes ! :)

Effectivement, ça fonctionne.

Merci encore à toi tchize_.

Je résume :

Code:

1
2
3
4
5
6
7
8
public interface Z {
	public String getM1();
	public void setM1(String m1);
	public String getM2();
	public void setM2(String m2);
	public String getM3();
	public void setM3(String m3);
}

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
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
public class A implements Z {
	private String ma1;
	private String ma2;
	private String ma3;
	private String m1;
	private String m2;
	private String m3;
 
	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;
	}
 
	public String getM1() {
		return m1;
	}
 
	public void setM1(String m1) {
		this.m1 = m1;
	}
 
	public String getM2() {
		return m2;
	}
 
	public void setM2(String m2) {
		this.m2 = m2;
	}
 
	public String getM3() {
		return m3;
	}
 
	public void setM3(String m3) {
		this.m3 = m3;
	}
 
	@Override
	public String toString() {
		return "A [ma1=" + ma1 + ", ma2=" + ma2 + ", ma3=" + ma3 + ", m1=" + m1 + ", m2=" + m2 + ", m3=" + m3 + "]";
	}
}

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
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
public class B implements Z {
	private String mb1;
	private String mb2;
	private String mb3;
	private String m1;
	private String m2;
	private String m3;
 
	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;
	}
 
	public String getM1() {
		return m1;
	}
 
	public void setM1(String m1) {
		this.m1 = m1;
	}
 
	public String getM2() {
		return m2;
	}
 
	public void setM2(String m2) {
		this.m2 = m2;
	}
 
	public String getM3() {
		return m3;
	}
 
	public void setM3(String m3) {
		this.m3 = m3;
	}
 
	@Override
	public String toString() {
		return "B [mb1=" + mb1 + ", mb2=" + mb2 + ", mb3=" + mb3 + ", m1=" + m1 + ", m2=" + m2 + ", m3=" + m3 + "]";
	}
}

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
public class App3 {
 
	public static void main(String[] args) {
		A a = new A();
		a.setMa1("aaa111");
		a.setMa2("aaa222");
		a.setMa3("aaa333");
		mapRow(a);
		System.out.println("a: " + a.toString());
 
		B b = new B();
		b.setMb1("bbb111");
		b.setMb2("bbb222");
		b.setMb3("bbb333");
		mapRow(b);
		System.out.println("b: " + b.toString());
	}
 
	private static void mapRow(Z obj) {
		obj.setM1("ccc111");
		obj.setM2("ccc222");
		obj.setM3("ccc333");
	}
}

04/12/2015, 11h50
domiq44

Par curiosité, est-ce que cette solution correspond à un design pattern, de près ou de loin ?
Merci.
07/12/2015, 20h30
domiq44

Pas de réponse ? Tant pis.

En tout cas, merci :)
07/12/2015, 21h56
tchize_

ben j'ai pas de réponse :p
08/12/2015, 11h01
thelvin

Je suis pas sûr que l'héritage soit vraiment un patron de conception.

Plutôt la mécanique de base d'un langage de classes.