java - 拒绝超出 DoubleProperty 范围的更改

Question

我最近试图将我的双重属性的范围限制为 (0.0 - 1.0)。超出此范围的更改不应有任何影响，或引发错误。

目前我有两种方式:

• 只读，并且只允许在访问器上进行更改:

  private ReadOnlyDoubleWrapper numProperty = new ReadOnlyDoubleWrapper(0);
  
  public final double getNum() {
      return numProperty().get();
  }
  
  public final void setNum(double num) {
      if(num < 0)
          num = 0;
      if(num > 1)
          num = 1;
      numProperty.set(num);
  }
  
  public ReadOnlyDoubleProperty numProperty() {
      return numProperty.getReadOnlyProperty();
  }
  

• 设置监听器以重置值:

  private DoubleProperty numProperty = new SimpleDoubleProperty(0);
  numProperty.addListener(new BoundRangeListener(numProperty, 0.0, 1.0));
  
  
  class BoundRangeListener implements ChangeListener<Number> {
  
      Property<Number> prop;
      double min, max;
  
      BoundRangeListener(Property<? extends Number> prop, double min, double max) {
          this.prop = prop;
          this.min = min;
          this.max = max;
      }
  
      public void changed(ObservableValue<? extends Number> o,
                                           Number oldValue, Number newValue) {
          if(newValue.doubleValue() < min)
              prop.set(min);
          if(newValue.doubleValue() > max)
              prop.set(max);
  
          // Optional: throw exception
      }
  
  }
  

不过，我对这两种解决方案都不满意。第一个不允许我的用户绑定(bind)属性；没有充分的理由，这不是我想要的。第二个会向其他听众触发 2 个事件；不好。

所以我的问题是:是否有任何开箱即用的方法来拒绝更改或将数字属性绑定(bind)到一个范围？

Answer 1

考虑继承 SimpleDoubleProperty 并覆盖 set 和 setValue 方法:

import javafx.beans.property.DoubleProperty;
import javafx.beans.property.SimpleDoubleProperty;

public class ClampedDoublePropertyTest {

    private DoubleProperty numProperty = new SimpleDoubleProperty(0) {

        @Override
        public void set(double value) {

            System.out.println("set("+value+")");
            if (value < 0) {
                value = 0 ;
            }
            if (value > 1) {
                value = 1 ;
            }
            super.set(value);
        }

        @Override
        public void setValue(Number value) {
            System.out.println("setValue("+value+")");
            if (value == null) {
                // depending on requirements, throw exception, set to default value, etc.
            } else {
                if (value.doubleValue() < 0) {
                    value = new Double(0);
                }
                if (value.doubleValue() > 1) {
                    value = new Double(1);
                }
                super.setValue(value);
            }
        }

    };

    public DoubleProperty numProperty() {
        return numProperty;
    }

    public final double getNum() {
        return numProperty().get();
    }

    public final void setNum(double num) {
        numProperty().set(num);
    }

    public static void main(String[] args) {
        ClampedDoublePropertyTest test = new ClampedDoublePropertyTest();
        test.numProperty().addListener((obs, oldValue, newValue) -> System.out.println(oldValue +" -> "+newValue));

        DoubleProperty value = new SimpleDoubleProperty();
        test.numProperty().bind(value);
        value.set(0.5);
        value.set(2);
        value.set(-5);
    }
}

这将允许客户端代码以通常的方式绑定(bind)属性:

myInstance.numProperty().bind(...);

但请注意，这将违反通常的绑定(bind)契约(Contract)，就好像它所绑定(bind)的可观察值超出范围一样，这两个值将不相等。

顺便说一句，FWIW Oracle recommend (幻灯片 29)监听器方法，尽管我同意你的看法，我不喜欢它(特别是因为它允许观察者观察到“无效值”)。