การหล่อประเภทดั้งเดิม ส่ง int ให้เป็นแบบสั้นและไบต์

เพราะเหตุใดถ้าคุณโยนค่าบางประเภทintเพื่อพิมพ์shortหรือbyteผลลัพธ์ที่ไม่คาดคิด? มาหาคำตอบกัน!

int i = 450;
byte b = (byte)i;
System.out.println(b);

ผลลัพธ์บนหน้าจอ:

-62

มีคำอธิบายที่สมเหตุสมผลโดยไม่คาดคิดนอกจากนี้การกระทำนี้สามารถทำได้ด้วยมือของคุณเอง ในการทำเช่นนี้ เราจำเป็นต้องแปลง 450 จากทศนิยมเป็นไบนารี่:

450/2.    0
225/2.    1
112/2.    0
56/2.     0
28/2.     0
14/2.     0
7/2.      1
3/2.      1
1/2.      1

ในคอลัมน์ด้านขวาของตัวเลข เราเขียนเศษที่เหลือเมื่อหารด้วย 2 และใต้ตัวเลขนั้นเอง เราจะเขียนผลลัพธ์ของการหารจำนวนด้วยสอง ถ้าเศษเหลือเป็น 0 ถ้าเศษเหลือ 1 เราก็เขียนด้านล่างนี้ ส่วนจำนวนเต็มจากการหารด้วยสอง ( เครื่องคิดเลขออนไลน์พร้อมคำอธิบายการคำนวณ ) ด้วยเหตุนี้ เราจึงได้สิ่งนั้นในระบบเลขฐานสอง 450 11100 0010= หมายเลขประเภทใดๆintจะใช้พื้นที่ 4 ไบต์หรือ 32 บิต โดยแต่ละบิตเป็น 0 หรือ 1 ในกรณีของเรา มีเพียง 9 บิตเท่านั้นที่ถูกครอบครอง และโดยหลักการแล้วของเราint i = 450ในระบบไบนารี่จะมีลักษณะดังนี้:

0000_0000_0000_0000_0000_0001_1100_0010

เราต้องการเขียนตัวแปรของเราลงในตัวแปรประเภทbyteแต่หมายเลขประเภทbyteใช้เวลา 1 ไบต์ (ตามมาจากชื่อประเภทนี้) หรือ 8 บิต ดังนั้นบิตพิเศษทางด้านซ้ายจะถูกละทิ้ง และในที่สุดเราก็จะได้:

1100 0010

พิมพ์ช่วงค่าbyte: -128 ถึง 127 แต่ละหมายเลขใช้พื้นที่ 8 บิต และบิตซ้ายสุดของแต่ละหมายเลขคือบิตเครื่องหมาย สำหรับจำนวนบวกทั้งหมดจะเท่ากับ 0 สำหรับจำนวนลบทั้งหมดจะเท่ากับ 1 ไม่จำเป็นต้องรีบเร่งในการแปลงผลลัพธ์ที่ได้รับข้างต้นเป็นระบบที่ 10 เพราะ เราได้รับรหัสเพิ่มเติมสำหรับหมายเลขที่ต้องการ ไม่ใช่รหัสโดยตรง บิตซ้ายสุดกลายเป็น 1 ดังนั้นจำนวนของเราจึงเป็นลบ และสำหรับตัวเลขลบ รหัสตรงและย้อนกลับจะไม่ตรงกัน ต่างจากรหัสบวก หากบิตเครื่องหมายเท่ากับ 0 เราก็สามารถแปลงตัวเลขเป็นระบบเลขฐานสิบได้ทันทีและรับ: 66 แต่บิตเครื่องหมายนั้นเป็นลบ ดังนั้นก่อนอื่นเราจำเป็นต้องแปลงโค้ดเพิ่มเติมให้เป็นโค้ดโดยตรงและเพิ่มเครื่องหมายลบ ลงชื่อเข้าใช้คำตอบ เพื่อความชัดเจนและการฝึกหัด ขั้นแรกให้ลองรับโค้ดเพิ่มเติมของตัวเลขบางตัว เช่น -15 ในการทำเช่นนี้ในโค้ดโดยตรงของการแทนค่าเชิงบวก (หมายเลข 15) คุณต้องเปลี่ยน 0 ทั้งหมดเป็น 1 และในทางกลับกัน (รับโค้ดย้อนกลับหรือที่เรียกว่าผกผัน) จากนั้นจึงเพิ่มโค้ดหนึ่งลงในผลลัพธ์ ในระบบทศนิยม 15 = 0000 1111; รหัสย้อนกลับ (เปลี่ยน 0 ทั้งหมดเป็น 1 และในทางกลับกัน) = 1111 0000; รหัสเพิ่มเติม (เพิ่มหนึ่งรายการ):

1 1 1 1 0 0 0 0
0 0 0 0 0 0 0 1
1 1 1 1 0 0 0 1

รหัสเพิ่มเติมสำหรับหมายเลข -15: 1111 0001; 1100 0010เยี่ยมเลย ตอนนี้ โดยการเปรียบเทียบกับ ตัวอย่าง ด้านบน เราจำเป็นต้องแปลงโค้ดเพิ่มเติมของเราให้เป็นโค้ดโดยตรง ฉันขอเตือนคุณว่ามันเท่ากับ

1. ลบหนึ่งและรับรหัสย้อนกลับ การทำเช่นนี้สะดวก เขียนโค้ดเพิ่มเติมลงในคำตอบ และดูสิ่งที่คุณต้องเพิ่มโค้ดเพื่อรับโค้ดเพิ่มเติมดังกล่าว เราเริ่มต้นด้วยหลักขวาสุดแล้วดูว่า เราต้องบวก 1 อะไรเพื่อให้ได้ 0? ถึง 1 เราได้ 10, 0 ตอบกลับ และ 1 ไปที่หลักถัดไป ถัดไป สิ่งที่ต้องเพิ่มเป็น 0 เพื่อให้ได้มา หนึ่ง แต่เนื่องจากเรามีหนึ่งจากหลักก่อนหน้า เราจึงเขียน 0 เพื่อตอบสนอง ต่อไปเพื่อให้ได้ 0 เราควรบวกอะไรกับ 0? แน่นอน 0 ดังนั้นอีก 4 ครั้ง และเหลือเลขท้าย 2 หลัก ซึ่งคุณต้องบวกบางอย่างเข้ากับ 0 เพื่อให้ได้ 1 แน่นอนว่าในทั้งสองกรณีคุณต้องบวก 1 รวมทั้งหมด:

   
   1 1 0 0 0 0 0 1
   0 0 0 0 0 0 0 1
   1 1 0 0 0 0 1 0

2. ส่วนที่ยากที่สุดจบลงแล้ว! เราได้รับโค้ดผกผัน (ย้อนกลับ) และสิ่งที่เราต้องทำคือรับโค้ดโดยตรง เรากลับค่า 0 ทั้งหมดเป็น 1 และในทางกลับกัน:

   1100 0001- รหัสผกผัน;

   0011 1110 - รหัสโดยตรงของหมายเลขของเราหรือเป็นตัวแทนเชิงบวก

3. แปลงเป็นระบบเลขทศนิยม ( เครื่องคิดเลขออนไลน์พร้อมคำอธิบายการคำนวณ ):

   0011 1110 = 0∙2^7+0∙2^6+1∙2^5+1∙2^4+1∙2^3+1∙2^2+1∙2^1+0∙2^0 = 0+0+32+16+8+4+2+0 = 62;

   สิ่งที่เหลืออยู่คือการบวกลบเข้ากับตัวเลขและคำตอบของเรา:-62.

ในทำนองเดียวกัน หมายเลขประเภทจะถูกแปลงshortเป็นประเภทint:

int i = 10_000_000;
short s = (short)i;
System.out.println(s); // -27008

1. 10,000,000 ในระบบเลข 10 = 0000 0000 1001 1000 1001 0110 1000 0000ในระบบเลข 2

   ใน Java หมายเลขประเภทintใช้เวลา 4 ไบต์ และshortหมายเลขประเภทใช้เวลา 2 ไบต์หรือ 16 บิต ดังนั้นเราจึงตัดด้านซ้ายเหลือ 16 หลัก:

1001 0110 1000 0000. บิตซ้ายสุด (บิตที่สำคัญที่สุดหรือที่เรียกว่าบิตเครื่องหมาย) กลายเป็น 1 ซึ่งหมายความว่าเรามีโค้ดเพิ่มเติมสำหรับจำนวนลบ ดังนั้นเราจึงไปยังจุดถัดไป

2. ลองแปลเป็นโค้ดย้อนกลับ:

   
   1 0 0 1 0 1 1 0 0 1 1 1 1 1 1 1
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
   1 0 0 1 0 1 1 0 1 0 0 0 0 0 0 0

   รหัสส่งคืน: 1001 0110 0111 1111;

3. เรากลับด้านและรับโค้ดโดยตรง: 0110 1001 1000 0000.

4. เราแปลงเป็นระบบเลขฐานสองและได้รับการแสดงจำนวนที่เป็นบวก:

   1∙2^14+1∙2^13+1∙2^11+1∙2^8+1∙2^7 = 16384+8192+2048+256+128 = 27008.

5. เพิ่มเครื่องหมายลบและรับคำตอบ:-27008

ลิงก์ไปยังเครื่องคำนวณออนไลน์ของรหัสไปข้างหน้า ย้อนกลับ และรหัสเสริม นอกจากนี้ในไซต์นี้ภายใต้เครื่องคิดเลขยังมีทฤษฎีเล็กน้อยเกี่ยวกับโค้ดผกผันและโค้ดเสริม