Pessoal,
Imagine que eu tenho uma classe abstrata (não sei se é essa a sintáxe, mas espero que dê para ter uma idéia):
abstract class Field<T> {
public <T> getValue() {
}
public void setValue(<T> value) {
}
}
abstract class TextField extends Field<String> {
public <T> getValue() {
// Implementação específica para TextField (String)
}
public void setValue(<T> value) {
// Implementação específica para TextField (String)
}
}
abstract class NumericField extends Field<Integer> {
public <T> getValue() {
// Implementação específica para NumericField (Integer)
}
public void setValue(<T> value) {
// Implementação específica para NumericField (Integer)
}
}
abstract class CheckBox extends Field<Boolean> {
public <T> getValue() {
// Implementação específica para CheckBox (Boolean)
}
public void setValue(<T> value) {
// Implementação específica para CheckBox (Boolean)
}
}
abstract class MoneyField extends Field<Money> {
public <T> getValue() {
// Implementação específica para MoneyField (Money)
}
public void setValue(<T> value) {
// Implementação específica para MoneyField (Money)
}
}
Money é um tiny type criado pela gente (por exemplo).
Consigo ter isso e ao utilizar o getValue() do NumericField obter um Integer sem precisar ficar fazendo cast por todo lado?
Não sei se isso é possível, pois não entendo como o compilador poderia fazer as garantias de tipos, mas não entendo nada de Generics mesmo...rs!
O único caso que consigo imaginar onde eu poderia precisar usar o polimorfismo seria algo do tipo:
for (Field field : getAllFields())
System.out.println("Value:" + field.getValue());
Nos demais casos eu usuário a própria classe filha, pelo menos até onde eu consigo imaginar (para o que eu preciso resolver).
Se algo do tipo for simples e funcionar, queria saber ainda se isso pode causar problemas ou limitações na vida do software caso precise evoluir essa solução.
Obrigado