Ho una struttura dati con unità di dati contenenti diversi tipi di dati. Ho spostato i dati in oggetti "Field" in modo che ogni campo sia in grado di analizzare in modo indipendente l'input dell'utente in un modo desiderato.
public abstract class<T> AField {
protected T value = null;
public T getValue() {
return this.value;
}
// This is the main reason I'm using a custom Field class
public abstract void parse(String data) throws ParseException;
}
public class IntegerField extends AField<Integer>{
public void parse(String data) {
super.value = data.trim();
}
}
public class StringField extends AField<String> {
...
}
// Note this has the same type as StringField but different parse implementation
public class PhoneNumberField extends AField<String> {
....
}
public class DataUnit {
private AField[] fields;
private IntegerField number = new IntegerField();
private StringField name = new StringField();
public DataUnit() {
this.fields = new Field {
this.number,
this.name
}
}
public void parseAll(String... data) throws ParseException {
for (int i = 0; i < this.fields.length; i++) {
fields[i].parse(data[i]);
}
}
// Now the troublesome methods
public Integer getNumber() {
return this.number.getValue(),
}
public void parseNumber(String data) throws ParseException {
this.number.parse(data);
}
public String getName() {
...
}
public void parseName(String data) throws ParseException {
...
}
}
Puoi vedere come il numero di metodi salirà rapidamente quando aggiungo altri tipi di campi alla classe DataUnit o più metodi alla classe AField. DataUnit deve passare tutti i metodi di tutte le classi Field in avanti perché preferirei non esporre gli oggetti Field direttamente ad altre classi. Qual è il modo migliore per risolvere questo problema? Esistono modelli migliori per raggiungere questo obiettivo?