ใน Java การแปลงประเภทมักจะพบได้จากคำจำกัดความของตัวแปรไปจนถึงการคัดลอกการคำนวณตัวแปรตัวเลขไปจนถึงการถ่ายโอนพารามิเตอร์ของวิธีการสร้างแบบจำลองระหว่างคลาสฐานและคลาสที่ได้รับ ฯลฯ การแปลงประเภทสามารถมองเห็นได้ทุกที่ พิมพ์การแปลงใน Java มีบทบาทสำคัญในการเข้ารหัส Java
มีหลายประเด็นที่ต้องใส่ใจเมื่อกำหนดตัวแปร หากคุณไม่ระวังคุณจะสูญเสียความแม่นยำหรือประเภทที่เข้ากันไม่ได้
ตัวอย่างเช่น:
1. เมื่อกำหนดข้อมูลจำนวนเต็มยาวต้องเพิ่มคำต่อท้าย l หรือ l
Long L = 123456789012345L
2. เมื่อกำหนดประเภทความแม่นยำเดียว (หลักสำคัญ 7-8 บิต) ต้องเพิ่มคำต่อท้าย f หรือ F
ลอย f = 12.5f
3. ประเภทบูลีนไม่สามารถแปลงเป็นประเภทข้อมูลอื่น ๆ ได้
ในหมู่พวกเขามักจะพบปัญหาการแปลงชนิดข้อมูล สิ่งที่พบบ่อยที่สุดคือการแปลงโดยนัยและการแปลง มาวิเคราะห์กันเถอะ
การแปลงโดยนัย
คุณสมบัติ:
จากขนาดเล็กถึงขนาดใหญ่สามารถแปลงได้โดยปริยายและชนิดข้อมูลจะได้รับการปรับปรุงโดยอัตโนมัติ
ไบต์, สั้น, ถ่าน -> int -> ยาว -> ลอย -> สองเท่า
หมายเหตุ: ยาว 8 ไบต์และลอยคือ 4 ไบต์
Long เป็นจำนวนเต็มลอยเป็นประเภทจุดลอยตัว กฎการจัดเก็บข้อมูลสำหรับจำนวนเต็มและหมายเลขจุดลอยตัวนั้นแตกต่างกัน โปรดจำไว้ว่าช่วงของความยาวนั้นเล็กกว่าลอย
ตัวอย่าง:
ไบต์ a = 10;
int b = a;
เมื่อ INTB = A รวบรวม A จะถูกแปลงเป็นประเภท INT โดยปริยาย
คดี
คุณสมบัติ:
จากขนาดใหญ่ถึงขนาดเล็ก (ถ้าคุณรู้อย่างชัดเจนว่าข้อมูลสามารถแสดงได้ด้วยประเภทข้อมูลนี้คุณสามารถใช้การหล่อได้)
รูปแบบ:
(ประเภทข้อมูลที่แปลง) ตัวแปรหรือค่า
หมายเหตุ: โดยทั่วไปไม่แนะนำให้ทำการคัดเลือกนักแสดงเลย
ตัวอย่างที่ 1:
int a = 10; byte b = (ไบต์) a;
เมื่อ Byte B = (ไบต์) A รวบรวม A จะถูกส่งไปยังประเภทไบต์
ตัวอย่างที่ 2:
Class Qiangzhidemo {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {byte b = (byte) 130; System.out.println (b); // พิมพ์ผลลัพธ์ -126}}การวิเคราะห์:
ข้อมูล 130 ค่าเริ่มต้นเป็นข้อมูลทศนิยมประเภท int
ขั้นตอนที่ 1: แปลงทศนิยม 130 เป็นข้อมูลไบนารี
10000010
ขั้นตอนที่ 2: การเป็นตัวแทนของ 130 ในหน่วยความจำมีดังนี้
รหัสต้นฉบับ: 000000000000000000000 00000000 10000010
ขั้นตอนที่ 3: ค้นหารหัสส่วนประกอบของ INT130
เนื่องจาก 130 เป็นจำนวนบวกรหัสผกผันและรหัสเสริมจึงสอดคล้องกับรหัสต้นฉบับ
รหัสเสริม: 00000000000000000000000 00000000 100000010
ขั้นตอนที่ 4: สกัดกั้นรหัสส่วนประกอบเหลือเพียง 8 หลักสุดท้าย
(BYTE) รหัสเสริมของ 130 คือ: 10000010
ขั้นตอนที่ 5: แปลงส่วนประกอบนี้เป็นรหัสต้นฉบับ
เนื่องจากบิตลงชื่อ (บิตแรก) คือ 1 จำนวนจึงเป็นจำนวนลบ
รหัสผกผัน: 10000001 (รหัสเสริม -1)
รหัสต้นฉบับ: 111111110 (บิตสัญลักษณ์ยังคงไม่เปลี่ยนแปลงบิตข้อมูลจะกลับด้าน)
แปลงเป็นทศนิยมเป็น -126 ดังนั้นในที่สุดก็พิมพ์ -126
ตัวอย่างที่ 3:
กางเกงขาสั้น = 1; s = s +1;
และ
กางเกงขาสั้น = 1; s+= 1;
มีปัญหาหรือไม่? ทำไม
การวิเคราะห์:
โปรแกรมแรกจะรายงานข้อผิดพลาด: ข้อผิดพลาด: ประเภทที่เข้ากันไม่ได้: อาจมีการสูญเสียเมื่อแปลงจาก int เป็นสั้น
สาเหตุ: S = S+1; S+1 จะถูกแปลงโดยปริยายเป็นประเภท int เมื่อประเภท int ถูกกำหนดให้กับประเภทสั้นอาจหายไป
โปรแกรมที่สองสามารถรวบรวมและเรียกใช้
เหตุผล: S+= 1 แม้ว่ามันจะถือได้ว่าเป็น S = S+1 แต่ก็ยังมีความแตกต่าง มีการหล่อใน S+= 1 นั่นคือ S = (สั้น) (S+1) ซึ่งจะบังคับค่า S+1 ถึงประเภทสั้นดังนั้นจะไม่มีข้อผิดพลาด
สรุป:
หากปัญหาของการแปลงประเภทข้อมูลเกิดขึ้นในบางโปรแกรม MINI เราอาจจะเห็นได้อย่างรวดเร็ว อย่างไรก็ตามเมื่อเขียนระบบขนาดใหญ่และมีข้อมูลจำนวนมากปัญหาเล็ก ๆ เหล่านี้อาจทำให้เกิดข้อผิดพลาดของระบบหรือแม้กระทั่งการล่มดังนั้นเราจึงต้องเข้าใจความเข้มงวดของการเขียนโค้ดก่อน
เนื้อหาข้างต้นแนะนำการแปลงโดยปริยายของ Java Basic Vs Cast Conversion ฉันหวังว่าคุณจะชอบ