Génériques et abstraction
Bonjour,
j'ai trois classes : une classe Type, une classe Column et une classe Row.
Un Type est bah... un type. Il doit gérer en interne un Comparable et pouvoir faire des comparaisons entre deux de ses extensions (qui peuvent être aussi bien des Type<String> que des Type<Integer> et des Type<Date>, etc).
Une Column doit avoir un type (donc non null), mais celui-ci peut changer en cours d'exécution.
Une Row est typiquement un mapping entre une Column typée et une valeur correspondant au type de la colonne. La valeur sera toujours bien typée, puisque lorsque le type d'une colonne change, les valeurs sont converties.
Mon problème est que ma classe Row ne compile pas à cause des erreurs de Generics dans la méthode compareTo. Cependant, conceptuellement, les comparaisons internes faites sont toujours sur un même type (on ne comparera pas de String avec des Integer, par exemple).
Merci à qui pourra m'aider.
J'ai coupé mon code pour que vous puissiez voir plus précisément l'erreur.
Code:
1
2
3
4
5
6
7
8
9
| import java.util.Comparator;
public class Type<T extends Comparable<T>>
implements Comparator<T> {
@Override
public int compare (T o1, T o2) {
return o1 != null ? (o2 != null ? o1.compareTo(o2) : 1)
: (o2 != null ? -1 : 0);
}
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class Column {
private Type<?> type;
public Column (Type<?> type) {
this.setType(type);
}
public void setType (Type<?> type) {
if (type == null)
throw new IllegalArgumentException("type is null");
this.type = type;
}
public Type<?> getType () {
assert type != null : "type is null";
return this.type;
}
} |
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
| public class Row
extends HashMap<Column, ? extends Comparable>
implements Comparable<Row> {
public Set<Column> getColumns() {
Set<Column> set = new HashSet<Column>();
set.put(new Column(new Type<Integer>()));
set.put(new Column(new Type<Float>()));
set.put(new Column(new Type<BigDecimal>()));
return set;
}
@Override
public int compareTo (Row that) {
if (that != null) {
int cmp;
for (Column column : this.getColumns()) {
Type<?> t = column.getType();
cmp = t.compare((Comparable) this.get(column),
(Comparable) that.get(column));
if (cmp != 0) return cmp;
}
}
return 0;
}
} |
