Not that I'm aware of. But it would be simple to implement a class
that has this behavior:

public class limitedInt
{
  int x;
  int high;
  int low;

  public limitedInt(int high, int low)
  {
     this.high = high;
     this.low = low;
  }

  public void setInt(newval)
  {
      if (newval >= low && newval <== high)
          x = newval;
      else
          /* throw an exception?? */
   }

  public int getInt()
  {
     return x;
  }
}

It wouldn't give a compile time error, which is what you talked about,
but it would prevent you from assigning a too-high or too-low value at
run time.

marcwentink@hotmail.com wrote On 06/07/07 11:51,:

   You can't do this with Java primitives: Their ranges
are part of the language definition and can't be changed,
and there's no way to create a "derivative" primitive
with special behavior.

   You could, though, create a class encapsulating a
range-limited mutable integer, something like

    class RestrictedInt {
       private final int min, max;
       private int value;

       RestrictedInt(int min, int max) {
           if (min > max)
               throw new IllegalArgumentError(...);
           this.min = min;
           this.max = max;
       }

       void setValue(int value) {
           if (value < min || value > max)
               throw new IllegalArgumentError(...);
           this.value = value;
       }

       int getValue() {
           return value;
       }
    }

   That won't give you a compile-time error, but will
enforce the range at run time.  (Compile-time errors aren't
always possible even in your original scenario; consider
`myInt = object.someMethod();'.)

   If the reason for restricting the range is that you're
using the values to label a smallish set of things or
conditions, consider using an enum instead of a number.
That is, instead of saying "There are four types of Taste,
numbered one through four," say "The four Taste types are
Taste.SWEET, Taste.SOUR, Taste.SALT, and Taste.BITTER."

Perhaps you're thinking of Pascal, which called these "range types".
(http://www.pascal-central.com/ppl/chapter3.html uses "sub-range types", but
I recall otherwise.)