Para sincronizar con algunos píctes de hardware, he creado un DataModel que contiene un campo de datos de clase genérico para almacenar diferentes tipos de objetos en un hashmap. Hashmap Mydictionary.

Ahora descubrió que si almacene, un campo de datos en un campo de datos, es posible guardar una cadena dentro del campo de datos. ¿Hay alguna manera de evitar que esto suceda?

Aquí está mi código:

public class DataField<T> implements IDataField<T> {
    //region Fields
    private T _value;
    private boolean _hasChanged;
    private ChildObserable<T> _hasChangedObserverable;
    //endregion

    //region Methodes
    public DataField(T val) throws IllegalValueException {
        if(val.getClass() != _value.getClass()) throw new IllegalValueException();
        _value =val;
        _hasChanged=false;
        _hasChangedObserverable=new ChildObserable<>();
    }
    public DataField(T val,Observer observer){
        _value =val;
        _hasChanged=false;
        _hasChangedObserverable=new ChildObserable<>();
        addChangeObserver(observer);
    }
    //region getters
    @Override
    public T getValue() {
        return _value;
    }

    @Override
    public boolean hasBeChanged() {
        return _hasChanged;
    }
    //endregion
    //region setters
    @Override
    public void setValue(T value) throws IllegalValueException {
        if(value.getClass()!= _value.getClass()) throw new IllegalValueException();
        if(value!=_value) {
            _value = value;
            _hasChanged=true;
            _hasChangedObserverable.sendValue(_value);
        }
    }

    @Override
    public void clearChangedState() {
        _hasChanged=false;
    }
//endregion
    //region observers
    @Override
    public void addChangeObserver(Observer observer) {
        _hasChangedObserverable.addObserver(observer);
    }

    @Override
    public void removeChangeObserver(Observer observer) {
        _hasChangedObserverable.deleteObserver(observer);
    }
    //endregion
    //endregion
}

Y aquí hay una muestra de código lo que quiero decir:

DataField dataField = new DataField<Integer>(5);
dataField.setValue(true); // This can be prevented because of checking Class

DataField dataField = new DataField<String>(null);
dataField.setValue(5); // This can not be prevented because of NullPointer Exception

Encontré algunas soluciones como esta Cómo mantenerse genérico Tipo de genéricos anidados con tokens de clase Pero no me gusta superar a la clase dos veces. Otra idea de la mía era usar una función predeterminada (t) como C # al valor predefinido a un tipo específico.

Gracias por la ayuda

1
Franzi 29 jun. 2019 a las 20:16

1 respuesta

La mejor respuesta

Lo resolví utilizando un segundo constructor y un campo de clase.

public DataField(T val) throws IllegalValueException {
        if(val==null) throw  new IllegalArgumentException("Class type couldn't be resolved from null");
        _value =val;
        _class=val.getClass();
        _hasChanged=false;
        _hasChangedObserverable=new ChildObserable<>();
    }
    public DataField(T val,Class<T> classType) throws IllegalValueException {
        if(val!=null &&  val.getClass()!=classType) throw  new IllegalArgumentException("Type of val and classType are Different");
        _class=classType;
        _value=val;
        _hasChanged=false;
        _hasChangedObserverable=new ChildObserable<>();
    }


@Override
    public void setValue(T value) throws IllegalValueException {
        if(_class!= value.getClass()) throw new IllegalValueException();
        if(value!=_value) {
            _value = value;
            _hasChanged=true;
            _hasChangedObserverable.sendValue(_value);
        }
    }

Gracias por la ayuda

0
Franzi 2 jul. 2019 a las 13:26