## Description

This assignment asks you to write a Java class called SmallInt (similar to a wrapper class). It also asks you to create a

testing class called TestSmallInt. You will need to turn in both for your submission.

EDIT: SEE BELOW FOR OPTIONAL EXTRA CREDIT

Design and Implementation

SmallInt contains the following:

• A private instance variable of type int named value, which is the value of an integer stored by the class constructor.

• A public static constant named MAXVALUE. MAXVALUE should be used as an upper limit for the values SmallInt

can represent. You should set MAXVALUE to 1000. However, keep in mind, the grader may change the value of

MAXVALUE when testing your program.

• A constructor that assigns an integer between 0 and MAXVALUE (inclusive) to value. That’s all the constructor has to

do, using the int parameter that is passed to it. However, the constructor must check to make sure the parameter

value is between 0 and MAXVALUE. If it is not, it should print an informative error message and store the

number 0 instead. (hint: using a method to check the value would be a good idea, because you might need to do a

similar check elsewhere!)

• An instance getter method getDec (returns a String, no parameters) which will return a String representation of the

decimal integer. The easiest way to create this String is to concatenate the int representation to an empty String.

• An instance setter method setDec (returns void, accepts one int parameter) which assigns an integer between 0 and

MAXVALUE to value. However, this setter must check to make sure the parameter value is between 0 and

MAXVALUE. If it is not, it should print an informative error message and store the number 0 instead.

• An instance getter method getBin (returns a String, takes no parameters) should take the number stored in the instance

variable value, generate the corresponding binary string and return that string. This method bears a little more

explanation, since it is one of the more substantial parts of the assignment. The generation of the “corresponding

binary string” is something that you must accomplish yourself, without using any convenient methods or classes

provided by Java’s main library or any external libraries written in Java. If you happen to be familiar with bit

shifting, that approach is OK but you must be sure that you can explain it in your own words (see the directions

about comments later).

There is a nice algorithm for determining the binary representation of an integer. Let’s remember that all integers

can be expressed as powers of two:

7 = 2^0 + 2^1 + 2^2 = 1 + 2 + 4 = 7 —> 111

83 = 2^0 + 2^1 + 2^4 + 2^6 = 1 + 2 + 16 + 64 = 83 —> 1010011

But how will we know which powers of two to use? You can figure this out manually by seeing how many times

you can divide by two (i.e., repeated division). It’s simple and a little naive, but it works. The implementation of

this algorithm is left to you. It is highly recommended that you work out a few examples on paper before you

begin to code. As a hint, remember what pieces of information mod can give you and integer division can give

you. Also, note that there are zeroes in particular places. Where? In the places where the powers of 2 are not used.

We could re-write the expression of 83 in the following way (the new parts have been highlighted for you):

2^0 * 1 + 2^1 * 1 + 2^2 * 0 + 2^3 * 0 + 2^4 * 1 + 2^5 * 0 + 2^6 * 1

Note that the expression above can be simplified into the one presented before. Still, it is important to see the full

sequence since it tells us how to create the binary sequence for 83. Read the 0’s and 1’s from left to right to see

how. In your code, you will be expected to have a block of comments explaining how your algorithm works and

why it’s correct. You should provide a specific example of a number (try not to choose any of the numbers above

or any number that your classmates might have mentioned).

• An instance getter method getHex (returns a String, takes no parameters) should take the number stored in the instance

variable value, generate the corresponding hexadecimal string and return that string. Just like with getBin, your

implementation must consist of only your work.

Hexadecimal expresses values in terms of different powers of a number, which in this case is 16:

7 = 16^0 * 7 = 1 * 7 = 7 —> 0x7

83 = 16^0 * 3 + 16^1 * 5 = 83 —> 0x53

Here we want to note the values of the constants next to the powers of 16, since those constants give us the correct

hex values: 7 and 53, respectively.

We can use the same algorithm from before (i.e., repeated division with % and /) but choose 16 as the divisor this

time. The process should be exactly the same, except now you have to deal with remainder values that will not

just be 0 and 1. The values will range from 0-15, but note that this corresponds to the range of hex characters (0-9,

A-F, 16 in total).

If the remainder is less than 10, you can concatenate the remainder as it is to your hexadecimal string. But if the

remainder is more than 10, you need to convert the value to the corresponding hexadecimal symbol (A-F). You

could create a mapping of values 10-15 to A-F, but there’s a handy type cast that you might find even easier:

hexString = (char) (‘A’ + remainder – 10) + hexString;

//where hexString is the string to be returned by the method

As with getBin(), you will need to provide comments with an explanation of how your algorithm works with a

specific example.

• Finally, you need to write a second public class (that means you will need two .java files) called TestSmallInt.

TestSmallInt will have just one main() method. It will prompt the user (using Scanner) for a number in the range 0

– MAXVALUE (inclusive). You should get MAXVALUE from the SmallInt class. Remember that you can

access this variable from the class itself since it is static (e.g., SmallInt.MAXVALUE).

Then the main() method will simply instantiate a SmallInt object using SmallInt’s constructor and print the

decimal representation, the binary representation and the hexadecimal representation of the number entered by the

user. There is no need to loop until the user decides to quit.

****EXTRA CREDIT****

The following is an OPTIONAL addition to the assignment. You will not lost points if you do not implement this

method. At most, you can earn two (2) additional points by completing the following:

• A static method sameValue (returns a boolean, accepts two String parameters) should take a binary representation of an

int and a hexadecimal representation of an int, convert the bin to hex OR convert the hex to bin, then compare the

Strings to see if they are equal. The result of this comparison is returned. Some examples are provided below.

sameValue (“101”, “5”) would return true

sameValue (“101”, “6”) would return false

sameValue (“1101”, “D”) would return true

sameValue (“1101”, “5”) would return false

sameValue (“11010101”, “D5”) would return true

sameValue (“1011101”, “5D”) would return true

Note: In the first two and the last example you can add leading zeros to the binary String if it makes it easier for

you.

You must use the String equals( ) method to test string equality ( not == ). As an example:

binAsHex.equals(hex)

hexAsBin.equals(bin)

Grading Rubric

Points Criteria

3 Correctly creates the SmallInt class, such that SmallInt objects can be instantiated and

methods can be called on those objects successfully

3 Implements getBin() correctly, with an adequate explanation of how it works

3 Implements getHex() correctly, with an adequate explanation of how it works

1 Good style

(2) Implements sameValue() correctly [ NOT REQUIRED ]