Java Tutorials: Why no 'unsigned'?

In the java programming language, we dont have the concept of 'unsigned' integers. Once question that arises in the minds of most beginners is this - Why no 'unsigned' integers in Java.

In languages like C, C++, might have used the unsigned integers extensively for declaring variables like 'age' which can never be negative. The programmers prefer ths same style of declaring the non-negative values as unsigned. But Java doesnt allow that.

Before answering why unsigned is not supported in Java, let us see the problems that can happen because of 'unsigned' type.

Let us say we store the age of a person.

unsigned int age;

Now, we have a problem, what if the age of the person is not known? we are comming up with a great plan of using a value '-1', which means 'not known'.

The requirement is, only if the users age is above 18 they should be allowed to perform some action. If they didnt specify the age, he should be blocked. Let us see, how to write the code...


if(age<18){>
printf("You should be above 18 years to access this feature");
return;
}


On seeing the code, it is common to assume that '-1' is less than '18' if the user didnt specify the age, so he will automatically blocked.

But if you check the C specifications, you can find out that any 'signed' variables will be converted to 'unsigned' automatically if both appear in the same expression.

It means, the value '-1' will be converted into its unsigned counter part i.e. 0xFFFF. This is definitly more greater that '18' thus allowing the user to continue the blocked activity.

This is just a trivial example, but this will make it very difficult to trace the problem in the real life projects. To avoid such potential problems, java removed the 'unsigned' keyword.

This reason may look weird, but there is not much to achieve introducing 'unsigned' when compared to the drawbacks. The omission of unsigned data types is controversial. There are reasons where unsigned could help. Example, having unsigned will increase the maximum limit for the data type. All other reasons revolve around this reason. But this could be solved by using a bigger numeral. Example, instead of unsigned int, we can use long. similarly for unsigned short, we can use 'int'. Still, 'long' doesnt have any alternative other than 'BigInteger' wrapper classes.

There are lots of 'Request For Enhancements (RFE)' to add unsigned. Here is one http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4504839. They have listed a lots of reasons for having an unsigned integers, but almost all the reasons revolve around the 'size'.

Let us look at, whether it is possible to add the new feature without the drawback that we mentioned.

It looks possible for adding the new keyword without losing the type safety of Java - without losing the title 'stongly typed language'. Use the same level of type checking. Make it stict to use explicit casts to convert between unsigned and signed.

Let us say for 'unsigned int', java adds the keyword 'uint'. Then,


uint a = 10;
int b = 20;

uint c = a + b // should throw compilation error.


We should instead use,


uint a = 10;
int b = 20;

uint c = a + (uint)b // should work


This will guarantee the strong type checking nature of Java and satisfying the needs of the programmers - A win-win situation for both the Java architects and for the Java Programmers.