1

我正在尝试创建一个计数器，该计数器在达到预设上限时会翻转，并在达到所述上限时重置回其底值。我已经实现了这个类，它工作得很好。但是，在寻找解决方案的过程中，我想尝试使用 Java 泛型。我想尝试扩展我的计数器，使其不仅使用整数，而且可以使用任何类型的数字。我知道计数器通常只需要使用整数，但我想看看是否可以这样做。

我认为代码将类似于下面。但是，java.lang.Number 没有获取/设置其值的“通用”方式。我需要创建自己的号码类来启用它吗？另外，我知道如果我确实让这个工作，我需要改变我的等号检查，以便它们对浮点值有一个错误阈值，这或多或少是我的 int 计数器的修改版本，我认为它适用于仿制药。

编辑： 有人建议我采用映射方法，存储一个整数计数器并保持一个增量值，这样当我想吐出一个数字时，我只需将当前计数乘以增量值。但是，我不相信这会满足我的确切需求，因为我不想每次都增加相同的数量。这个计数器的主要焦点更多地是一种具有固定范围数字的方法，当添加或减去该数字时，它知道如何处理回绕。

我想描述它的最佳方式（尽管可能不正确）就像Integer自动处理上溢/下溢。

package com.math;

public class GenericRolloverCounter<T extends Number> {

   private T value;
   private T lowValue;
   private T highValue;

   public GenericRolloverCounter(T l_startValue, T l_highValue) {
      this.lowValue = l_startValue;
      this.highValue = l_highValue;
      this.value = l_startValue;
   }

   public T getValue() {
      return value;
   }

   public void setValue(T value) {
      this.value = value;
   }

   public void increment(T valToIncrementBy) {
      this.value += valToIncrementBy;
      if (this.value > this.highValue) {
         this.value = (this.lowValue + (this.value - (this.highValue + 1)));
      }
   }

   public void increment() {
      this.increment(1);
   }

   public void decrement(T valToDecrementBy) {
      this.value -= valToDecrementBy;
      if (this.value < this.lowValue) {
         this.value = ((this.value + this.highValue + 1) - this.lowValue);
      }
   }

   public void decrement() {
      this.decrement(1);
   }

   @Override
   public String toString() {
      return Integer.toString(this.value);
   }
}
4

1 回答 1

0

您可能还想指定计数的数量。默认值为1.

您可以通过使用该Number方法.doubleValue()并进行双重算术来解决其中的一些问题。

这是转换为使用此想法的方法之一。

public void decrement(double valToDecrementBy) {
  double work = this.value.doubleValue();
  work -= valToDecrementBy;
  // should use some value related to incrementing amount
  if ((this.value.doubleValue() - this.lowValue.doubleValue()) < 0.1D) {
     work = ((this.value.doubleValue() + this.highValue.doubleValue() + 1) - this.lowValue.doubleValue());
  }
  // ... no way to put it back
}

但是，仍然没有办法恢复干净和容易的价值。由于“数字”只有几个常用的非抽象子类，因此您可以做一些丑陋instanceof的事情来将值存储回来。它看起来像这样：

if (theValue instanceof Double) { // depends on it having a non-null value prior
    theValue = (T)(new Double(work));
}

或者您可以将起始值转换为开始double时的值，然后只使用双打。

private double value;
private double lowValue;
private double highValue;

public GenericRolloverCounter(T l_startValue, T l_highValue) {
    this.lowValue = l_startValue.doubleValue();
    this.highValue = l_highValue.doubleValue();
    this.value = l_startValue.doubleValue();
}

这确实引入了增加浮点值的问题以及那里的舍入/评估问题。

哦......你toString()应该是：

return value.toString();

在类上使用本机toString()方法T。

@Crusher 的评论提出了另一种方法。将所有内容映射到“int”并保留一个乘数。这是一些代码来说明我的意思。（感谢破碎机）

private int value;
private int lowValue;
private int highValue;
private double incr;

public GenericRolloverCounter(T l_startValue, T l_highValue, T incrementAmount) {
    double incr = incrementAmount.doubleValue();
    this.lowValue = Math.round(l_startValue.doubleValue() / incr);
    this.highValue = Math.round(l_highValue.doubleValue() / incr);
    this.value = Math.round(l_startValue.doubleValue() / incr);
}

public void increment(int valToIncrementBy) {
  this.value += valToIncrementBy;
  if (this.value > this.highValue) {
     this.value = (this.lowValue + (this.value - (this.highValue + 1)));
  }
}

@Override
public String toString() {
  return String.valueOf(incr * this.value);
}
于 2013-10-10T17:53:41.800 回答