This week's giveaway is in the Android forum.
We're giving away four copies of Android Security Essentials Live Lessons and have Godfrey Nolan on-line!
See this thread for details.
The moose likes Programmer Certification (SCJP/OCPJP) and the fly likes complement in byte if range exceeds Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login


Win a copy of Android Security Essentials Live Lessons this week in the Android forum!
JavaRanch » Java Forums » Certification » Programmer Certification (SCJP/OCPJP)
Bookmark "complement in byte if range exceeds" Watch "complement in byte if range exceeds" New topic
Author

complement in byte if range exceeds

amit taneja
Ranch Hand

Joined: Mar 14, 2003
Posts: 810
i have extracted the following para from K&B

byte a = (byte) 128;
But then what�s the result? When you narrow a primitive, Java simply truncates the
higher-order bits that won�t fit. In other words, it loses all the bits to the left of the
bits you�re narrowing to.
Let�s take a look at what happens in the preceding code. There, 128 is the bit
pattern 10000000. It takes a full 8 bits to represent 128. But because the literal
128 is an int, we actually get 32 bits, with the 128 living in the right-most
(lower-order) 8 bits. So a literal 128 is actually
00000000000000000000000010000000
Take our word for it; there are 32 bits there.
To narrow the 32 bits representing 128, Java simply lops off the leftmost
(higher-order) 24 bits. We�re left with just the 10000000. But remember that a
byte is signed, with the leftmost bit representing the sign (and not part of the value
of the variable). So we end up with a negative number (the 1 that used to represent
128 now represents the negative sign bit). Remember, to find out the value of a
negative number using two�s complement notation, you flip all of the bits and then
add 1. Flipping the 8 zeroes give us: 01111111, and adding 1 to that gives us
10000000, or back to 128! And when we apply the sign bit, we end up with -128.




I don't understand fully the above paragraph...i read it many times....
how 10000000 it is -128 ... is because 0 is only positive but if its then how we can say that it is negative -128... so it means.. that leftmost bit one is also included while counting number as well as sign bit ???

then how the one question has such answer like

Q ..Question 8
class Magenta {
static byte a = (byte)127, b = (byte)128, c = (byte)255, d = (byte)256;
public static void main(String args[]) {
System.out.print(a + " " + b + " " + c + " " + d);
}}

What is the result of attempting to compile and run the program?

a. Prints: 127 128 255 256
b. Prints: 127 128 255 0
c. Prints: 127 -1 -127 0
d. Prints: 127 -128 -1 0
e. Run-time error
f. Compile-time error
g. None of the above


its answer is "d"
with explanation like....
Bytes are stored as 8 bit two's complement signed integers. When an int primitive is cast to a byte, the three most significant bytes are discarded and only the least significant byte remains. The most significant bit of the remaining byte becomes the new sign bit. byte a = (byte)127; // 01111111. byte b = (byte)128; // 10000000. byte c = (byte)255; // 11111111. byte d = (byte)256; // 00000000.

but how in above... 11111111 is -1 00000000 is 0

please explain me



so in one question of dann examm


Thanks and Regards, Amit Taneja
Anu Kalra
Greenhorn

Joined: Dec 08, 2004
Posts: 8
Hello Amit,
Let me find an easy way to find a solution to your query.
size of byte = 8 bits
range of byte = -128 to 127
Since byte is a signed primitive, the MSB is the signed bit, which means that if the MSB is '1', then the number being represented is a negative number.
So, only 7 bits are required to represent the complete range of byte and MSB is used for indicating, if the number is positive or negative.
So far so good, now lets handle your question:

lets represent 128 in binary format : 10000000
As, i have explained earlier, that in byte if the MSB is '1', then it is a negative number.
now to represent 10000000 in decimal, we have to flip all the bits and add 1 to it (As it is a negative number) 01111111+1 = 10000000 = -128

Lets now solve your question:

Question 8
class Magenta {
static byte a = (byte)127, b = (byte)128, c = (byte)255, d = (byte)256;
public static void main(String args[]) {
System.out.print(a + " " + b + " " + c + " " + d);
}}

What is the result of attempting to compile and run the program?

a. Prints: 127 128 255 256
b. Prints: 127 128 255 0
c. Prints: 127 -1 -127 0
d. Prints: 127 -128 -1 0
e. Run-time error
f. Compile-time error
g. None of the above

a = byte(127) = 127, as this number is in range of byte.
b = byte(126) = -128, as explained above
c = byte(255) = 011111111 (byte representation). Now as byte can hold only 8 bits, we chop off the MSBs. So the resulting representation is 1111111. Now, since the MSB is '1', it is a negative number, so we flip all the bits and add 1 ==> 00000000 + 1 = 00000001. So, as it was a negative number, we get the answer as -1.
d = byte(256) = 100000000 (Byte representation).Now as byte can hold only 8 bits, we chop off the MSBs. So the resulting representation is 00000000. So, the answer is 0. Hence, the result is 0

Therefore 'd' is the correct answer.

I hope that new i am able to solve your query.

-Anu
 
I agree. Here's the link: http://aspose.com/file-tools
 
subject: complement in byte if range exceeds
 
Similar Threads
Byte Primitive type
-97 is the total length of each record ???
lang fund Ques from dan mock exam
Conversion
signed bits...