Java: การสร้างวัตถุและกระบวนการเริ่มต้น
1. ประเภทข้อมูลใน Java
มี 3 ประเภทข้อมูลใน Java: ประเภทข้อมูลพื้นฐาน (ใน Java, Boolean, Byte, Short, Int, Long, Char, Float และ Double เป็นประเภทข้อมูลพื้นฐาน) ประเภทอ้างอิงและประเภท Null ในหมู่พวกเขาประเภทการอ้างอิงประกอบด้วยประเภทคลาส (รวมถึงอาร์เรย์) และประเภทอินเตอร์เฟส
คำสั่งต่อไปนี้ประกาศตัวแปรบางอย่าง:
int k; a; // a คือชื่อตัวแปรวัตถุของประเภทข้อมูล B B1, B2, …, B10000; // สมมติว่า B เป็นคลาสนามธรรมหรืออินเทอร์เฟซ สตริง s;
หมายเหตุ: จากมุมมองของชนิดข้อมูลและตัวแปรตัวแปรชนิดข้อมูลพื้นฐาน K, ตัวแปรประเภทคลาส A และ S, คลาสนามธรรมหรือตัวแปรประเภทอินเตอร์เฟส B (10,000) เป็นตัวแปรทั้งหมด (ตัวระบุ)
2. เกี่ยวกับมือจับ
เพื่อแยกความแตกต่างระหว่างตัวระบุตัวแปรของประเภทการอ้างอิงและตัวระบุตัวแปรของชนิดข้อมูลพื้นฐานเราใช้ด้ามจับเพื่อระบุชื่อตัวแปรตัวแปรของประเภทอ้างอิงเป็นพิเศษ ในตัวอย่างข้างต้น B1 ถึง B10000, A และ S ล้วนมีการจัดการ ด้ามจับดูที่มือจับและที่จับอย่างสังหรณ์ใจ เราใช้การแปลภาษาจีนที่ใช้กันทั่วไปของ "ด้ามจับ" ในโลกคอมพิวเตอร์
2.1 [ในการเขียนโปรแกรม Windows] ความหมายของมือจับเป็นจำนวนเต็มที่ไม่ซ้ำกันที่ใช้โดย Wondows เพื่อระบุวัตถุที่สร้างหรือใช้โดยแอปพลิเคชัน Windows ใช้มือจับต่าง ๆ เพื่อระบุเช่นอินสแตนซ์แอปพลิเคชัน, Windows, Controls, Bitmaps, GDI Objects ฯลฯ Windows Handle เป็นเหมือนไฟล์ที่จับในภาษา C
จากคำจำกัดความด้านบนเราจะเห็นว่าที่จับเป็นตัวระบุที่ใช้ในการระบุวัตถุหรือโครงการ มันเหมือนชื่อของเรา ทุกคนจะมี คนที่แตกต่างกันมีชื่อที่แตกต่างกัน แต่อาจมีคนที่มีชื่อเดียวกับคุณ จากชนิดข้อมูลมันเป็นเพียงจำนวนเต็ม 16 บิตที่ไม่ได้ลงชื่อ แอปพลิเคชันมักจะได้รับการจัดการโดยการเรียกใช้ฟังก์ชัน Windows ซึ่งสามารถใช้งานได้โดยฟังก์ชั่น Windows อื่น ๆ เพื่ออ้างอิงวัตถุที่เกี่ยวข้อง
หากคุณต้องการทราบว่าจัดการได้อย่างละเอียดยิ่งขึ้นฉันสามารถบอกคุณได้ว่ามือจับเป็นพอยน์เตอร์ถึงพอยน์เตอร์ เรารู้ว่าตัวชี้ที่เรียกว่าเป็นที่อยู่หน่วยความจำ หลังจากที่แอปพลิเคชันเริ่มต้นขึ้นวัตถุที่ทำขึ้นโปรแกรมจะอยู่ในหน่วยความจำ หากเราเข้าใจง่ายดูเหมือนว่าตราบใดที่เรารู้ที่อยู่แรกของหน่วยความจำนี้เราสามารถใช้ที่อยู่นี้เพื่อเข้าถึงวัตถุได้ตลอดเวลา แต่ถ้าคุณคิดอย่างนั้นจริง ๆ คุณคิดผิดมาก เรารู้ว่า Windows เป็นระบบปฏิบัติการที่ใช้หน่วยความจำเสมือนจริง ในสภาพแวดล้อมระบบนี้ตัวจัดการหน่วยความจำ Windows มักจะย้ายวัตถุไปมาในหน่วยความจำเพื่อตอบสนองความต้องการหน่วยความจำของแอปพลิเคชันต่างๆ วัตถุถูกย้ายหมายความว่าที่อยู่มีการเปลี่ยนแปลง หากที่อยู่เปลี่ยนแปลงเช่นนี้เสมอเราควรหาวัตถุที่ไหน
ในการแก้ปัญหานี้ระบบปฏิบัติการ Windows จะช่วยเพิ่มที่อยู่ที่เก็บข้อมูลภายในสำหรับแต่ละแอปพลิเคชันเพื่อลงทะเบียนการเปลี่ยนแปลงที่อยู่ของแต่ละวัตถุแอปพลิเคชันในหน่วยความจำโดยเฉพาะและที่อยู่นี้ (ที่ตั้งของหน่วยเก็บข้อมูล) ยังคงไม่เปลี่ยนแปลง หลังจากย้ายตำแหน่งของวัตถุในหน่วยความจำ Windows Memory Manager จะบอกที่อยู่ใหม่ของวัตถุเพื่อบันทึก ด้วยวิธีนี้เราเพียงแค่ต้องจำที่อยู่ที่จับนี้เพื่อให้รู้ว่าวัตถุอยู่ที่ไหนในหน่วยความจำ ที่อยู่นี้ถูกกำหนดโดยระบบเมื่อมีการโหลดวัตถุ (โหลด) และถูกปล่อยออกสู่ระบบเมื่อระบบถูกขนถ่าย
จัดการที่อยู่ (เสถียร) →บันทึกที่อยู่ของวัตถุในหน่วยความจำmemory────ที่อยู่ของวัตถุในหน่วยความจำ (ไม่เสถียร) →วัตถุจริง
2.2 ความหมายของมือจับในชวามีความเข้าใจอย่างลึกซึ้งเกี่ยวกับความหมายของมือจับ [ในการเขียนโปรแกรม Windows] เราสามารถพูดได้ว่าการจัดการเป็นคำที่เราต้องการมากเมื่อเรียนรู้ Java ความหมายของมันคือการแยกความแตกต่าง "วัตถุ" จากตัวแปรวัตถุ (หรือความเข้มงวด: ตัวระบุตัวแปรของชนิดข้อมูลที่วัตถุเป็นของ)
2.3 กลับไปที่การประกาศตัวแปรใน 1:
ตอนนี้คุณควรมีมุมมองที่ชัดเจนของความคิดเห็นด้านล่าง
int k, j; // k เก็บหมายเลขจำนวนเต็ม a; // ที่อยู่จะถูกเก็บไว้ใน B B1, B2, …, B10000; // B1, …, B10000 เก็บที่อยู่ภายใน สตริง s; // s เก็บที่อยู่
3. เกี่ยวกับการอ้างอิง
"การอ้างอิง" คืออะไร? “ ตัวระบุที่คุณจัดการนั้นเป็น 'การอ้างอิง' กับวัตถุ” (คิดใน Java 2E)
การแปลคือ: ตัวระบุที่คุณจัดการนั้นเป็น "การอ้างอิง" กับวัตถุ หรือเพื่อให้แม่นยำยิ่งขึ้นแปลเป็น: ตัวระบุที่คุณใช้งานจริง ๆ แล้วเป็น "การอ้างอิง" กับวัตถุ เห็นได้ชัดว่าการอ้างอิงในข้อความต้นฉบับเป็นสิ่งที่มีทิศทาง
กลับไปที่ Java และอ้างถึงหมายเลข ID ของวัตถุ ID ของวัตถุหรือหมายเลขโทรศัพท์มือถือของวัตถุ แน่นอนว่าคำพูดเพิ่มเติมคือการอ้างอิงคือหมายเลขห้องที่วัตถุอาศัยอยู่ในความทรงจำ การพูดอย่างสังหรณ์ใจการอ้างอิงถึงวัตถุคือค่าส่งคืนเมื่อสร้างวัตถุ! การอ้างอิงคือค่าส่งคืนของนิพจน์ใหม่
ใหม่ A (); นี่คือวัตถุ แต่เราไม่ได้ใช้ด้ามจับที่จะถือ (ค้างไว้, บันทึก, บันทึก) การอ้างอิง จากมุมมองด้วยกล้องจุลทรรศน์นิพจน์ใหม่จะเสร็จสิ้นงานของการเริ่มต้นวัตถุ (สามขั้นตอนการวิเคราะห์โดยละเอียดด้านล่าง) และโดยรวมแล้วจะส่งคืนการอ้างอิง
กลับไปที่การประกาศตัวแปรใน 1 อีกครั้งและดูความคิดเห็นด้านล่าง
a; // ประกาศจัดการ A แต่ไม่ได้เริ่มต้นดังนั้นค่าภายในคือ NULL B B1, B2, …, B10000; // ประกาศจัดการ B1, …, B10000 แต่ไม่ได้เริ่มต้นดังนั้นค่าภายในคือ NULL สตริง s; // ประกาศที่จับ s แต่ไม่ได้เริ่มต้นดังนั้นค่าภายในเป็นโมฆะ
4. ความสัมพันธ์ระหว่างด้ามจับและการอ้างอิง
a a; // ประกาศจัดการ a ค่าคือ nulla = new a (); // การเริ่มต้นของด้ามจับ (handle = referent; นั่นคือกำหนดการอ้างอิงไปยังที่จับ)
ใบเสนอราคา: ค่าของใหม่ A () การอ้างอิงสามารถถือได้ว่าเป็นที่อยู่ที่วัตถุมีพื้นที่หน่วยความจำ ผ่านการอ้างอิงถึงวัตถุพวกเขาสามารถแยกแยะได้อย่างสะดวกจากวัตถุอื่น ๆ และการอ้างอิงเป็นตัวตนที่ไม่ซ้ำกันของวัตถุ
หลังจากเริ่มต้นที่จับคุณสามารถใช้ที่จับเพื่อควบคุมวัตถุจากระยะไกล
แน่นอนว่านี่เป็นเพียงการอธิบายการสร้างและการเริ่มต้นของวัตถุจากด้านหนึ่ง หลังจากทำความเข้าใจความสัมพันธ์ระหว่างมือจับและการอ้างอิงกระบวนการทั้งหมดของการเริ่มต้นวัตถุจะถูกวิเคราะห์ด้านล่าง มาเตรียมการต่อไปนี้ก่อนพูดคุยเกี่ยวกับสแต็คและสแต็ก
5. สแต็คและกองในชวา
ใน Java หน่วยความจำแบ่งออกเป็นสองประเภท: "สแต็ค" และ "heap" (สแต็กและกอง) ชนิดข้อมูลพื้นฐานจะถูกเก็บไว้ใน "สแต็ก" และประเภทการอ้างอิงวัตถุจะถูกเก็บไว้ใน "heap" และค่าที่อยู่ของหน่วยความจำอ้างอิงจะถูกเก็บไว้ในสแต็กเท่านั้น
โดยวิธีการพูดคุยเกี่ยวกับวิธีการ "==" และ "Equals ()" เพื่อช่วยให้เข้าใจแนวคิดของทั้งสอง (สแต็กและกอง)
เมื่อเปรียบเทียบตัวแปรกับ "==" ใน Java ระบบจะใช้ค่าที่เก็บไว้ในตัวแปรในสแต็กเป็นพื้นฐานสำหรับการเปรียบเทียบ ค่าที่เก็บไว้ในประเภทข้อมูลพื้นฐานในสแต็กคือค่าการกักเก็บและค่าที่เก็บไว้ในประเภทการอ้างอิงในสแต็กคือค่าที่อยู่ของวัตถุเองชี้ไปที่ คลาสวัตถุในแพ็คเกจ java.lang มีวิธีบูลีนสาธารณะเท่ากับวิธี (Object OBJ) มันเปรียบเทียบว่าวัตถุสองชิ้นมีค่าเท่ากันหรือไม่ วิธี Equals () ของวัตถุส่งคืนจริงเฉพาะในกรณีที่การอ้างอิงทั้งสองถูกเปรียบเทียบชี้ไปที่วัตถุเดียวกัน (ที่จับเท่ากัน) (สำหรับวิธี Equals () ของคลาสสตริงมันจะแทนที่วิธี Equals () และไม่ได้กล่าวถึงในบทความนี้)
6. การสร้างวัตถุและกระบวนการเริ่มต้น
ในวัตถุ Java เป็นตัวอย่างของคลาส โดยทั่วไปเมื่อการสร้างอินสแตนซ์ของคลาสสมาชิกทั้งหมดของคลาสดังกล่าวรวมถึงตัวแปรและวิธีการจะถูกคัดลอกไปยังอินสแตนซ์ใหม่ของประเภทข้อมูลนี้ วิเคราะห์สองรหัสต่อไปนี้
6.1 ยานพาหนะยานพาหนะ 1 = ยานพาหนะใหม่ ();
คำสั่งข้างต้นทำดังต่อไปนี้:
① "ยานพาหนะใหม่" ทางด้านขวาใช้คลาสยานพาหนะเป็นเทมเพลตเพื่อสร้างวัตถุคลาสยานพาหนะ (เรียกว่าวัตถุยานพาหนะ) ในพื้นที่ฮีป
end จุดสิ้นสุดของ () หมายความว่าหลังจากสร้างวัตถุตัวสร้างของคลาสยานพาหนะจะถูกเรียกทันทีเพื่อเริ่มต้นวัตถุที่สร้างขึ้นใหม่ จะต้องมีตัวสร้าง หากไม่ได้สร้าง Java จะเพิ่มตัวสร้างเริ่มต้น
③ "ยานพาหนะยานพาหนะ" ทางด้านซ้ายสร้างตัวแปรอ้างอิงคลาสยานพาหนะ
④ตัวดำเนินการ "=" ทำให้จุดอ้างอิงวัตถุไปยังวัตถุยานพาหนะที่เพิ่งสร้างขึ้น (มือจับเรียกคืนและการอ้างอิง)
แบ่งคำสั่งข้างต้นออกเป็นสองขั้นตอน:
ยานพาหนะยานพาหนะ 1; ยานพาหนะ = ยานพาหนะใหม่ ();
มันชัดเจนกว่าที่จะเขียนด้วยวิธีนี้ มีสองเอนทิตี: หนึ่งคือตัวแปรอ้างอิงวัตถุและอีกหน่วยหนึ่งเป็นวัตถุเอง เอนทิตีที่สร้างขึ้นในพื้นที่ฮีปนั้นแตกต่างจากที่สร้างขึ้นในพื้นที่สแต็ก แม้ว่าพวกเขาจะเป็นเอนทิตีที่มีอยู่ แต่ก็ดูเหมือนจะยากที่จะ "จับ" ได้อย่างถูกต้อง มาศึกษาประโยคที่สองอย่างรอบคอบและค้นหาว่าชื่อของวัตถุที่คุณเพิ่งสร้างขึ้นมาคืออะไร? บางคนบอกว่ามันเรียกว่า "ยานพาหนะ" ไม่ "ยานพาหนะ" เป็นชื่อของคลาส (เทมเพลตการสร้างสำหรับวัตถุ) คลาสยานพาหนะสามารถสร้างวัตถุนับไม่ถ้วนตามสิ่งนี้และวัตถุเหล่านี้ไม่สามารถเรียกได้ว่า "ยานพาหนะ" วัตถุไม่มีชื่อดังนั้นจึงไม่สามารถเข้าถึงได้โดยตรง เราสามารถเข้าถึงวัตถุทางอ้อมผ่านการอ้างอิงวัตถุ
6.2 ยานพาหนะยานพาหนะ 2;
Veh2 = Veh1;
เนื่องจาก Veh1 และ Veh2 เป็นเพียงการอ้างอิงถึงวัตถุสิ่งที่บรรทัดที่สองทำคือการกำหนดข้อมูลอ้างอิง (ที่อยู่) ของ VEH1 ถึง Veh2 ดังนั้น Veh1 และ Veh2 จึงชี้ไปที่วัตถุยานพาหนะที่ไม่ซ้ำกันในเวลาเดียวกัน
6.3 ยานพาหนะ = ยานพาหนะใหม่ ();
ตัวแปรอ้างอิง VEH2 ชี้ไปที่วัตถุที่สองแทน
อนุมานได้จากคำสั่งข้างต้นเราสามารถวาดข้อสรุปต่อไปนี้: ①การอ้างอิงวัตถุสามารถชี้ไปที่วัตถุ 0 หรือ 1; ②วัตถุสามารถมีการอ้างอิง n เพื่อชี้ไปที่มัน
Java: การแปลงชนิดข้อมูล
1. Java ประเภทง่าย ๆ และคลาส encapsulator ของพวกเขา
1.1 คลาส Java ง่าย ๆ และคลาส encapsulation เรารู้ว่าภาษา Java เป็นภาษาการเขียนโปรแกรมเชิงวัตถุโดยทั่วไป แต่เมื่อพิจารณาถึงข้อดีของประเภทข้อมูลพื้นฐานบางอย่างที่ง่ายในโครงสร้างหน่วยความจำขนาดเล็กและความเร็วในการเข้าถึงที่รวดเร็ว Java ยังคงให้การสนับสนุนสำหรับประเภทข้อมูลที่ง่าย ๆ แน่นอนเมื่อ Java มีคลาสอื่น ๆ จำนวนมากมันยังมีคลาสที่ห่อหุ้มด้วยประเภทข้อมูลอย่างง่าย ดังนั้น Java จึงมีประเภทข้อมูลที่แตกต่างกันเช่น Int และ Integer (ลอยและลอยตัวสองและสอง ... )
มีสองประเภทข้อมูลที่สำคัญของประเภทข้อมูลในภาษา Java: หนึ่งเป็นประเภทง่าย ๆ หรือที่เรียกว่าประเภทหลัก (ดั้งเดิม) และอีกประเภทหนึ่งเป็นประเภทอ้างอิง (อ้างอิง) ตัวแปรประเภทง่าย ๆ จะเก็บค่าเฉพาะในขณะที่ตัวแปรประเภทอ้างอิงเก็บข้อมูลอ้างอิงไปยังวัตถุ
Java กำหนดขนาดของแต่ละประเภทง่าย ๆ ขนาดเหล่านี้ไม่เปลี่ยนแปลงตามการเปลี่ยนแปลงในโครงสร้างของเครื่อง ขนาดนี้ไม่แปรเปลี่ยนซึ่งเป็นหนึ่งในเหตุผลที่โปรแกรม Java มีความสามารถในการพกพาที่แข็งแกร่ง
ตารางต่อไปนี้แสดงรายการประเภทง่าย ๆ การเข้าพักของบิตไบนารีและคลาส encapsulator ที่สอดคล้องกันที่กำหนดไว้ใน Java
ประเภทง่าย ๆ ในตาราง Java
1.2 ทำไมต้องใช้คลาส encapsulation ใช้ตัวอย่าง int และจำนวนเต็มเป็นตัวอย่าง แม้ว่าพวกเขาจะเป็นตัวแทนจำนวนเต็ม 32 บิต แต่ก็เป็นประเภทข้อมูลที่แตกต่างกัน ในความเป็นจริงจำนวนเต็มที่ใช้โดยตรงใน Java นั้นเป็น int (เท่าที่ int และจำนวนเต็มเกี่ยวข้อง) เฉพาะเมื่อข้อมูลต้องปรากฏเป็นตัวตนของวัตถุค่าจำนวนเต็มจะต้องถูกห่อหุ้มลงในวัตถุที่มี encapsulator intege, int ที่สอดคล้องกัน
ตัวอย่างเช่น: ในการเพิ่มจำนวนเต็มลงในเวกเตอร์ในแพ็คเกจ java.util ค่าจำนวนเต็มจะต้องถูกห่อหุ้มในอินสแตนซ์จำนวนเต็มดังนี้:
เวกเตอร์ v = เวกเตอร์ใหม่ (); int k = 121; v.addelemt (จำนวนเต็มใหม่ (k));
นอกจากนี้จำนวนเต็มซึ่งเป็นคลาส encapsulator ที่สอดคล้องกับ Int ให้วิธีการมากมายเช่นวิธีการก่อสร้างจำนวนเต็มวิธีการแปลงจำนวนเต็มไปยังประเภทตัวเลขอื่น ๆ ฯลฯ ซึ่งไม่สามารถใช้ได้ในข้อมูลประเภท int
2. ค่าคงที่ในชวา
เราต้องให้ความสนใจกับค่าคงที่ประเภทต่อไปนี้
2.1 เมื่อค่าคงที่จำนวนเต็ม hexadecimal แสดงเป็นเลขฐานสิบหกพวกเขาจะต้องเริ่มต้นด้วย 0x หรือ 0x เช่น 0xff, 0x9a
2.2 Octal Integer Constant Octal ต้องเริ่มต้นด้วย 0 เช่น 0123, 034
2.3 ประเภทยาวประเภทยาวต้องจบลงด้วย L เช่น 9L, 342L
2.4 ค่าคงที่ลอยเนื่องจากประเภทเริ่มต้นของค่าคงที่ทศนิยมคือสองประเภท, f (f) ต้องเพิ่มหลังจากประเภทลอย ตัวแปรที่มีทศนิยมเป็นสองเท่าโดยค่าเริ่มต้น
ลอย F;
f = 1.3f; // f ต้องประกาศ
2.5 ค่าคงที่ตัวละครคงที่ตัวอักษรจะต้องถูกปิดล้อมในสองเครื่องหมายคำพูดเดียว (โปรดทราบว่าค่าคงที่สตริงจะถูกล้อมรอบในสองคำพูดสองเท่า) อักขระในบัญชี Java สำหรับสองไบต์
บางตัวอักษรหลบหนีที่ใช้กันทั่วไป
①/r หมายถึงการรับอินพุตแป้นพิมพ์ซึ่งเทียบเท่ากับการกดปุ่ม ENTER;
②/n หมายถึงบรรทัดใหม่
③/t หมายถึงอักขระแท็บซึ่งเทียบเท่ากับคีย์ตาราง
④/b หมายถึงคีย์ backspace ซึ่งเทียบเท่ากับคีย์พื้นที่ด้านหลัง
⑤/'หมายถึงคำพูดเดี่ยว;
⑥/'' หมายถึงคำพูดสองเท่า
⑦ // หมายถึง Slash/
3. การแปลงระหว่างประเภทข้อมูลอย่างง่าย
มีสองวิธีในการแปลงระหว่างประเภทข้อมูลง่าย ๆ : การแปลงอัตโนมัติและการแปลงแบบหล่อซึ่งมักจะเกิดขึ้นเมื่อพารามิเตอร์ของนิพจน์หรือวิธีการผ่าน
3.1 การแปลงอัตโนมัติโดยเฉพาะเมื่อคำนวณข้อมูล "เล็ก" พร้อมกับข้อมูล "ขนาดใหญ่" ระบบจะแปลงข้อมูล "เล็ก" เป็นข้อมูล "ขนาดใหญ่" โดยอัตโนมัติจากนั้นทำการคำนวณ เมื่อเรียกใช้วิธีการพารามิเตอร์จริงคือ "เล็ก" และข้อมูลพารามิเตอร์ที่เป็นทางการของวิธีการที่เรียกว่า "ใหญ่" (ถ้ามีการจับคู่แน่นอนวิธีการจับคู่จะถูกเรียกโดยตรง) ระบบจะแปลงข้อมูล "เล็ก" เป็นข้อมูล "ใหญ่" โดยอัตโนมัติแล้วเรียกวิธีการ โดยธรรมชาติสำหรับวิธีการโอเวอร์โหลดหลายครั้งที่มีชื่อเดียวกันมันจะถูกแปลงเป็นข้อมูล "ปิด" "ใหญ่" และเรียกว่า
ประเภทเหล่านี้จาก "เล็ก" ถึง "ใหญ่" คือ (ไบต์, สั้น, ถ่าน)-int-long-float-double สิ่งที่เรากำลังพูดถึงที่นี่ไม่ได้อ้างถึงจำนวนไบต์ที่ครอบครอง แต่ตามขนาดของช่วงที่แสดงถึงค่า
โปรดดูตัวอย่างต่อไปนี้:
①ข้อความต่อไปนี้สามารถส่งโดยตรงใน Java:
ไบต์ b; int i = b; ยาว l = b; float f = b; double d = b;
②หากประเภทระดับต่ำเป็นประเภทถ่านมันจะถูกแปลงเป็นค่ารหัส ASCII ที่สอดคล้องกันเมื่อแปลงเป็นประเภทระดับสูง (ประเภทอินทิกรัล) ตัวอย่างเช่น
ถ่าน c = 'c'; int i = c; System.out.println ("เอาต์พุต:"+i);
เอาท์พุท:
เอาท์พุท: 99;
③สำหรับสามประเภทของไบต์สั้นและถ่านพวกเขาเป็นแนวนอนดังนั้นพวกเขาจึงไม่สามารถแปลงซึ่งกันและกันโดยอัตโนมัติ สามารถใช้การแปลงประเภทการหล่อต่อไปนี้ได้
สั้น i = 99; char c = (char) i; system.out.println ("เอาต์พุต:"+c);เอาท์พุท:
เอาท์พุท: C;
④หากมีวิธีการในวัตถุ polymorphism:
f (byte x) {…}; f (สั้น x) {…}; f (int x) {…}; f (ยาว x) {…}; f (float x) {…}; f (double x) {…}; f (double x) {…}; นอกจากนี้ยังมี: char y = 'a'; ดังนั้นคำสั่งใดจะเรียกว่า f (y) คำตอบคือ: f (int x) {... } วิธีการเนื่องจากพารามิเตอร์อ้างอิงอย่างเป็นทางการคือ "ใหญ่" และเป็น "ใกล้เคียงที่สุด"
และสำหรับวิธีการ:
f (float x) {…}; f (double x) {…}; นอกจากนี้ยังมี: ยาว y = 123l; จากนั้นวิธีที่เรียกโดยคำสั่ง f (y) คือ f (float x) {…}
3.2 การหล่อเมื่อแปลงข้อมูล "ขนาดใหญ่" เป็นข้อมูล "เล็ก" คุณสามารถใช้การหล่อ นั่นคือคุณต้องใช้รูปแบบคำสั่งต่อไปนี้:
int n = (int) 3.14159/2;
อย่างที่คุณสามารถจินตนาการได้การแปลงนี้อาจนำไปสู่การล้นหรือลดความแม่นยำ
3.3 ปรับปรุงประเภทข้อมูลโดยอัตโนมัติ เกี่ยวกับการปรับปรุงประเภทอัตโนมัติให้ความสนใจกับกฎต่อไปนี้
①ค่าทั้งหมดของประเภทไบต์สั้นและถ่านจะได้รับการส่งเสริมเป็นประเภท int;
②หากมีตัวถูกดำเนินการที่ยาวผลการคำนวณมีความยาว
③หากมีตัวถูกดำเนินการที่เป็นประเภทลอยผลการคำนวณเป็นประเภทลอย
④หากมีตัวถูกดำเนินการที่เป็นสองประเภทผลการคำนวณเป็นสองประเภท;
ตัวอย่าง,
ไบต์ B; b = 3; B = (ไบต์) (B*3); // ไบต์จะต้องประกาศ
3.4 การแปลงประเภทการเปลี่ยนแปลงสำหรับคลาสบรรจุภัณฑ์โดยทั่วไปเราจะประกาศตัวแปรก่อนจากนั้นสร้างคลาสบรรจุภัณฑ์ที่สอดคล้องกันและเราสามารถใช้วิธีการต่าง ๆ ของคลาสบรรจุภัณฑ์เพื่อทำการแปลงประเภท ตัวอย่างเช่น:
①เมื่อคุณต้องการแปลงลอยเป็นสองเท่า:
ลอย F1 = 100.00F; Float F1 = Float ใหม่ (F1); double d1 = f1.doublevalue (); // f1.doublevalue () เป็นวิธีการส่งคืนประเภทค่าสองเท่าของคลาส float
②เมื่อคุณต้องการแปลงประเภทคู่เป็นประเภท int:
double d1 = 100.00; double d1 = new double (d1); int i1 = d1.intvalue ();
แปลงตัวแปรของประเภทง่าย ๆ เป็นคลาส wrapper ที่สอดคล้องกันและตัวสร้างของคลาส wrapper สามารถใช้ นั่นคือ: บูลีน (ค่าบูลีน), อักขระ (ค่าถ่าน), จำนวนเต็ม (ค่า int), ยาว (ค่ายาว), ลอย (ค่าลอย), สองเท่า (ค่าคู่)
ในแต่ละคลาสบรรจุภัณฑ์จะมีวิธีการ×× value () เสมอเพื่อให้ได้ข้อมูลประเภทง่าย ๆ ที่สอดคล้องกัน การใช้วิธีนี้การแปลงระหว่างตัวแปรตัวเลขที่แตกต่างกันสามารถรับรู้ได้ ตัวอย่างเช่นสำหรับคลาสเรียลที่มีความแม่นยำสองเท่า intvalue () สามารถรับตัวแปรจำนวนเต็มที่สอดคล้องกันและ doublevalue () สามารถรับตัวแปรประเภทจริงสองเท่าที่สอดคล้องกันได้
4. การแปลงระหว่างสตริงและประเภทอื่น ๆ
4.1 การแปลงประเภทอื่นเป็นสตริง①เรียกวิธีการแปลงสตริงของคลาส: x.toString ();
การแปลงแบบอัตโนมัติ: x+";
③วิธีการใช้สตริง: string.volueof (x);
4.2 แปลงสตริงเป็นประเภทอื่นเป็นค่า①ก่อนแปลงเป็นอินสแตนซ์ wrapper ที่สอดคล้องกันก่อนจากนั้นเรียกใช้วิธีการที่สอดคล้องกันเพื่อแปลงเป็นประเภทอื่น ตัวอย่างเช่นรูปแบบของการแปลงค่าประเภทสองเท่าของ "32.1" ในตัวละครคือ: ใหม่ลอย ("32.1"). doublevalue () นอกจากนี้คุณยังสามารถใช้: double.valueof ("32.1"). doublevalue ()
②วิธีการ parsexxx แบบคงที่
String s = "1"; byte b = byte.parseByte (s); short t = short.parseshort (s); int i = integer.parseint (s); long l = long.parselong (s); float f = float.parsefloat (s); double d = double.parsedouble (s);
③วิธี getNumericValue (Char Ch) ของตัวละครสามารถพบได้ใน API
5. การแปลงคลาสวันที่และประเภทข้อมูลอื่น ๆ
ไม่มีการติดต่อโดยตรงระหว่างจำนวนเต็มและคลาสวันที่ แต่คุณสามารถใช้ประเภท INT เพื่อเป็นตัวแทนของปีเดือนวันชั่วโมงนาทีและวินาทีตามลำดับเพื่อให้มีการจัดสรรการติดต่อระหว่างทั้งสอง เมื่อทำการแปลงนี้คุณสามารถใช้สามรูปแบบของตัวสร้างคลาสวันที่:
①date (int ปี, เดือน int, วันที่ int): ประเภท int แสดงถึงปีเดือนและวัน②date (int ปี, เดือน int, วันที่ int, int hrs, int min): ประเภท int หมายถึงปี, เดือน, ชั่วโมงชั่วโมงและนาที③date (int ปี, เดือน, วันที่ int, int ชั้นเรียนนั่นคือเวลาแสดงเป็นจำนวนมิลลิวินาทีตั้งแต่ 0:00:00 น. GMT เมื่อวันที่ 1 มกราคม 1970 สำหรับการติดต่อนี้คลาสวันที่ยังมีตัวสร้างที่สอดคล้องกัน: วันที่ (วันที่ยาว)
รับปีเดือนวันชั่วโมงนาทีที่สองและสัปดาห์ในชั้นเรียนวันที่ คุณสามารถใช้ getYear (), getMonth (), getDate (), getHours (), getMinutes (), getSeconds (), getDay () และคุณสามารถเข้าใจได้ว่าเป็นการแปลงคลาสวันที่เป็น int
วิธี getTime () ของคลาสวันที่สามารถรับหมายเลขจำนวนเต็มยาวที่สอดคล้องกับเวลาที่เรากล่าวถึงก่อนหน้านี้ เช่นเดียวกับคลาส wrapper คลาสวันที่ยังมีวิธี toString () ที่สามารถแปลงเป็นคลาสสตริง
บางครั้งเราต้องการรับรูปแบบเฉพาะวันที่เช่น 20020324 เราสามารถใช้วิธีการต่อไปนี้ก่อนแนะนำก่อนที่จุดเริ่มต้นของไฟล์
นำเข้า java.text.simpledateFormat; นำเข้า java.util.*; java.util.date วันที่ = ใหม่ java.util.date (); // หากคุณต้องการได้รูปแบบของ yyyymmdd simpledateFormat sy1 = new SimpledateFormat ("yyyymmdd"); String dateformat = sy1.format (วันที่); // หากคุณต้องการได้รับปีเดือนวัน SimpledateFormat SY = ใหม่ SimpledateFormat ("yyyyy"); SimpledateFormat SM = new SimpledateFormat ("MM"); SimpledateFormat SD = new SimpledateFormat ("dd"); String syear = sy.format (วันที่); String smon = sm.format (วันที่); string sday = sd.format (วันที่);