"sign" is in the eye of the beholder ...

What all primitive types (byte, short, int, long) first of all do is to
store a bunch of bits (8, 16, 32, 64 bits in Java). One of this bits in
a data type, the sign bit, is interpreted special during several
operations. For example, if you ask Java to print out the value, or do
some multiplication, Java - like many other languages - looks at the
sign bit to decide if the number should be treated as negative.

All you have to do when trying to work with unsigned numbers is to
either avoid running into these special interpretations, or to
compensate for them. Typically, for example, you mask with 0xFF to avoid
 the sign extension when a byte is implicitly or explicitly converted
to int. And voila, your bytes appear as unsigned in the integer number.

Getting this right just requires to understand how integer numbers in
computers work in general. And in detail, what the two's-complement of a
number is, its relation to the one's-complement, and what sign-extension
is and when it happens. Nothing which one can't look up in 15 minutes.

/Thomas

All that are in a byte are bits.  The signedness is how the high bit
is sometimes treated in a byte.

One way it is treated is to be propagated when promoted to int.  So
you have to be vigilant and do an & 0xff to chop it back off.

in adding, signed and unsigned are treated identically, so it does not
matter.

See http://mindprod.com/jgloss/unsigned.html