1. คุณสมบัติใหม่ของ Java JDK1.5
1. ทั่วไป:
รายการ <String> strs = new ArrayList <String> (); // ระบุประเภทที่เก็บข้อมูลสำหรับการรวบรวม เมื่อจัดเก็บข้อมูลในคอลเลกชันข้างต้นข้อมูลของสตริงจะต้องเก็บไว้มิฉะนั้นคอมไพเลอร์จะรายงานข้อผิดพลาด
2. สำหรับการสอบ
ตัวอย่างเช่นเราสามารถสำรวจคอลเลกชันด้านบนผ่านสำหรับการเข้าชมซึ่งทำให้ง่ายขึ้นและชัดเจนขึ้น
สำหรับ (String s: strs) {system.out.println (s);}หมายเหตุ: เมื่อใช้สำหรับการสอบเพื่อสำรวจคอลเลกชันคอลเลกชันเพื่อสำรวจจะต้องใช้อินเทอร์เฟซตัววนซ้ำ
3. ฟังก์ชั่นการแกะกล่องและบรรจุภัณฑ์อัตโนมัติ
การคัดลอกรหัสมีดังนี้:
หมายความว่าอย่างไร?
JDK1.5 กำหนดคลาส encapsulation สำหรับแต่ละประเภทข้อมูลพื้นฐาน ทำให้ประเภทข้อมูลพื้นฐานใน Java มีวัตถุของตัวเองเช่น: int -> จำนวนเต็ม
สองเท่า -> สองเท่า
ยาว -> ยาว
Char -> ตัวละคร
ลอย -> ลอย
บูลีน -> บูลีน
สั้น -> สั้น
ไบต์ -> ไบต์
บรรจุภัณฑ์อัตโนมัติ: แปลงประเภทพื้นฐานเป็นวัตถุตัวอย่างเช่น: int -> จำนวนเต็ม
การเปิดกล่องอัตโนมัติ: แปลงวัตถุเป็นชนิดข้อมูลพื้นฐานตัวอย่างเช่น: จำนวนเต็ม -> int
ปัญหาที่คอลเลกชันไม่สามารถจัดเก็บชนิดข้อมูลพื้นฐานก่อนที่ JDK1.5 จะสามารถแก้ไขได้
4. การแจงนับ:
การแจงนับเป็นคุณสมบัติเปรียบเทียบที่แนะนำโดย JDK1.5 คำหลักคือ enum
ตัวอย่างเช่น: กำหนดการแจงนับที่แสดงถึงสัญญาณไฟจราจร
public enum myenum {สีแดง, เขียว, เหลือง}5. พารามิเตอร์ตัวแปร
หมายความว่าอย่างไร? ให้ฉันยกตัวอย่างให้คุณ: ก่อน JDK1.5 เมื่อเราต้องการผ่านพารามิเตอร์หลายประเภทของประเภทเดียวกันกับวิธีการเรามีสองวิธีในการแก้ปัญหา 1. ผ่านอาร์เรย์โดยตรง 2. ผ่านพารามิเตอร์มากเท่าที่มี
ตัวอย่างเช่น:
Public Void PrintColor (สตริงสีแดง, สตริงสีเขียว, สตริงสีเหลือง) {} หรือ
Public Void PrintColor (String [] สี) {} แม้ว่าพารามิเตอร์วิธีการเขียนด้วยวิธีนี้สามารถบรรลุผลที่เราต้องการ แต่นี่ไม่ใช่ปัญหาเล็กน้อยหรือ นอกจากนี้เราควรทำอย่างไรหากจำนวนพารามิเตอร์ไม่แน่นอน? พารามิเตอร์ตัวแปรที่จัดทำโดย Java JDK1.5 สามารถแก้ปัญหานี้ได้อย่างสมบูรณ์แบบตัวอย่างเช่น:
Public Void PrintColor (สตริง ... สี) {}
มันสามารถกำหนดได้เช่นนี้มันหมายความว่าอย่างไร? หากพารามิเตอร์เป็นประเภทเดียวกันคุณสามารถใช้แบบฟอร์ม "Type + Three Points ตามด้วยชื่อพารามิเตอร์" ข้อดีของสิ่งนี้คือตราบใดที่ประเภทพารามิเตอร์เหมือนกันไม่มีการ จำกัด จำนวนพารามิเตอร์ที่ส่งผ่าน: พารามิเตอร์ตัวแปรจะต้องเป็นรายการสุดท้ายในรายการพารามิเตอร์ (คุณสมบัตินี้ใช้กับทั้งวัตถุและชนิดข้อมูลพื้นฐาน)
6. การนำเข้าแบบคงที่
ข้อดี: การใช้การนำเข้าแบบคงที่สามารถสร้างตัวแปรคงที่ทั้งหมดและวิธีการคงที่ของคลาสที่นำเข้าปรากฏโดยตรงในคลาสปัจจุบัน การใช้สมาชิกคงที่เหล่านี้ไม่จำเป็นต้องให้ชื่อชั้นเรียน
ข้อเสีย: การใช้มากเกินไปจะลดความสามารถในการอ่านรหัส
7. เธรดพร้อมกันไลบรารี
เธรดพร้อมกันไลบรารีเป็นคุณสมบัติขั้นสูงของมัลติเธรดที่เสนอโดย Java 1.5 มันอยู่ในแพ็คเกจ: java.util.concurrent
รวม
1. เธรด Mutex Tool Class คำอธิบาย: Lock, RedwriteLock
2. คำอธิบายการสื่อสารเธรด: เงื่อนไข
3. พูลเธรด
ผู้บริหาร
3. ซิงโครไนซ์คิว
arrayblockingqueue
4. ซิงโครไนซ์คอลเลกชัน
พร้อมกัน
5. เครื่องมือซิงโครไนซ์เธรด
สัญญาณ
ยังมีเนื้อหา (สำคัญมาก) มากมายเกี่ยวกับไลบรารีพร้อมกันของเธรดดังนั้นฉันจะไม่แสดงรายการทีละรายการ เพื่อนที่สนใจสามารถตรวจสอบเอกสารความช่วยเหลือ
2. คุณสมบัติใหม่ของ JDK1.6
1. คลาสคลาสและคลาส SystemTray
อดีตสามารถใช้เพื่อเปิดเบราว์เซอร์เริ่มต้นของระบบเพื่อเรียกดู URL ที่ระบุเปิดไคลเอนต์อีเมลเริ่มต้นของระบบเพื่อส่งอีเมลไปยังที่อยู่อีเมลที่ระบุใช้แอปพลิเคชันเริ่มต้นเพื่อเปิดหรือแก้ไขไฟล์ (ตัวอย่างเช่นใช้ Notepad เพื่อเปิดไฟล์ที่มี TXT เป็นคำต่อท้าย) และใช้เครื่องพิมพ์เริ่มต้นของระบบ หลังสามารถใช้เพื่อสร้างโปรแกรมถาดในพื้นที่ถาดระบบ
2. ใช้ JAXB2 เพื่อใช้การแมประหว่างวัตถุและ XML
JAXB เป็นตัวย่อของสถาปัตยกรรม Java สำหรับการเชื่อม XML ซึ่งสามารถแปลงวัตถุ Java เป็นรูปแบบ XML และในทางกลับกัน
เราเรียกการแมประหว่างวัตถุและฐานข้อมูลเชิงสัมพันธ์ ORM และในความเป็นจริงการแมประหว่างวัตถุและ XML สามารถเรียกได้ว่า OXM (การแมป Object XML) ปรากฎว่า Jaxb เป็นส่วนหนึ่งของ Java EE ใน JDK1.6 ซันวางไว้ใน Java SE ซึ่งเป็นแนวปฏิบัติตามปกติของดวงอาทิตย์ เวอร์ชัน JAXB ที่มาพร้อมกับ JDK1.6 คือ 2.0 เมื่อเทียบกับ 1.0 (JSR 31), JAXB2 (JSR 222) ใช้คำอธิบายประกอบคุณสมบัติ JDK5 ใหม่เพื่อระบุคลาสและคุณลักษณะที่จะถูกผูกไว้ซึ่งทำให้ภาระงานของการพัฒนาง่ายขึ้นอย่างมาก ในความเป็นจริงใน Java EE 5.0, EJB และบริการเว็บยังทำให้การพัฒนาง่ายขึ้นผ่านคำอธิบายประกอบ นอกจากนี้ JAXB2 ใช้ Stax (JSR 173) เพื่อประมวลผลเอกสาร XML ที่ด้านล่าง
นอกเหนือจาก JAXB แล้วเรายังสามารถบรรลุฟังก์ชั่นเดียวกันผ่าน XMLBEANS และ CASTOR ฯลฯ
3. เข้าใจ Stax
Stax (JSR 173) เป็นอีก API สำหรับการประมวลผลเอกสาร XML ใน JDK1.6.0 นอกเหนือจาก DOM และ SAX
ต้นกำเนิดของ Stax: มีสองวิธีในการประมวลผลเอกสาร XML ใน JAXP1.3 (JSR 206): DOM (โมเดลวัตถุเอกสาร) และ SAX (Simple API สำหรับ XML)
ตั้งแต่ JAXB2 (JSR 222) และ JAX-WS 2.0 (JSR 224) ใน JDK1.6.0 ใช้ Stax, Sun จึงตัดสินใจเพิ่ม Stax ให้กับตระกูล JAXP และอัพเกรด JAXP เวอร์ชันเป็น 1.4 (JAXP1.4 เป็นเวอร์ชันการบำรุงรักษาของ JAXP1.3) เวอร์ชัน JAXP ใน JDK1.6 คือ 1.4 Stax เป็นสตรีมมิ่ง API สำหรับตัวย่อของ XML ซึ่งเป็น API ที่ใช้เอกสาร XML แบบดึงแบบดึง Stax จัดเตรียม API ตามตัววนซ้ำเหตุการณ์เพื่อให้โปรแกรมเมอร์ควบคุมกระบวนการแยกวิเคราะห์ของเอกสาร XML โปรแกรมจะสำรวจเหตุการณ์นี้เพื่อประมวลผลเหตุการณ์การแยกวิเคราะห์แต่ละครั้ง เหตุการณ์การแยกวิเคราะห์สามารถถือได้ว่าถูกดึงออกมาโดยโปรแกรมนั่นคือโปรแกรมแจ้งให้ตัวแยกวิเคราะห์สร้างเหตุการณ์การแยกวิเคราะห์จากนั้นจัดการกับเหตุการณ์จากนั้นทำให้ตัวแยกวิเคราะห์สร้างเหตุการณ์การแยกวิเคราะห์ครั้งต่อไป ลูปนี้จนกว่าจะพบอักขระที่ลงท้ายด้วยเอกสาร SAX ยังประมวลผลเอกสาร XML ตามเหตุการณ์ แต่ใช้โหมดพุชเพื่อแยกวิเคราะห์ หลังจากแยกวิเคราะห์เอกสาร XML ที่สมบูรณ์จะสร้างเหตุการณ์การแยกวิเคราะห์เท่านั้นจากนั้นผลักพวกเขาไปยังโปรแกรมเพื่อประมวลผลเหตุการณ์เหล่านี้ DOM ใช้วิธีการในการแมปเอกสาร XML ทั้งหมดกับแผนผังความจำเพื่อให้ข้อมูลของโหนดพาเรนต์โหนดเด็กและโหนดพี่ชายสามารถรับได้ง่าย แต่ถ้าเอกสารมีขนาดใหญ่มันจะส่งผลกระทบอย่างรุนแรงต่อประสิทธิภาพ
4. ใช้คอมไพเลอร์ API
ตอนนี้เราสามารถใช้คอมไพเลอร์ API ของ JDK1.6 (JSR 199) เพื่อรวบรวมไฟล์ต้นฉบับ Java แบบไดนามิก คอมไพเลอร์ API รวมฟังก์ชั่นการสะท้อนเพื่อให้ได้การสร้างรหัส Java แบบไดนามิกและรวบรวมและเรียกใช้รหัสเหล่านี้ซึ่งเป็นคุณสมบัติภาษาแบบไดนามิก
คุณลักษณะนี้มีประโยชน์มากสำหรับบางแอปพลิเคชันที่ต้องการการรวบรวมแบบไดนามิกเช่น JSP Web Server เมื่อเราแก้ไข JSP ด้วยตนเองเราไม่ต้องการรีสตาร์ทเว็บเซิร์ฟเวอร์เพื่อดูเอฟเฟกต์ ในเวลานี้เราสามารถใช้คอมไพเลอร์ API เพื่อใช้การรวบรวมไดนามิกของไฟล์ JSP แน่นอนเว็บเซิร์ฟเวอร์ JSP ปัจจุบันยังรองรับการปรับใช้ JSP Hot JSP Web Server ปัจจุบันเรียก Javac ผ่าน runtime.exec หรือ processbuilder เพื่อรวบรวมรหัสระหว่างการทำงาน วิธีนี้ต้องการให้เราสร้างกระบวนการอื่นในการรวบรวมซึ่งไม่สง่างามพอและง่ายต่อการสร้างรหัสขึ้นอยู่กับระบบปฏิบัติการเฉพาะ คอมไพเลอร์ API ให้วิธีที่ดียิ่งขึ้นในการรวบรวมแบบไดนามิกผ่านชุด APIs มาตรฐานที่ใช้งานง่ายและเป็นข้ามแพลตฟอร์ม
5. เซิร์ฟเวอร์ HTTP ที่มีน้ำหนักเบา API
JDK1.6 ให้ API เซิร์ฟเวอร์ HTTP อย่างง่าย จากนี้เราสามารถสร้างเซิร์ฟเวอร์ HTTP แบบฝังตัวของเราเองซึ่งรองรับโปรโตคอล HTTP และ HTTPS และเป็นส่วนหนึ่งของการใช้งาน HTTP1.1 ส่วนที่ไม่ได้ใช้งานสามารถนำไปใช้งานได้โดยการขยาย HTTP Server API ที่มีอยู่ โปรแกรมเมอร์จะต้องใช้อินเทอร์เฟซ HttPhandler ด้วยตนเอง httpserver จะเรียกวิธีการโทรกลับของคลาสการใช้งาน HttPhandler เพื่อจัดการคำขอไคลเอนต์ ที่นี่เราเรียกร้องขอ HTTP และการตอบสนองต่อการแลกเปลี่ยนซึ่งถูกห่อไว้ในคลาส httpexchange Httpserver รับผิดชอบในการส่ง HttpExchange ไปยังวิธีการโทรกลับของคลาสการใช้งาน HttPhandler
6. API การประมวลผลคำอธิบายประกอบที่สามารถทำได้ (API การประมวลผลคำอธิบายประกอบที่สามารถทำได้)
API การประมวลผลคำอธิบายประกอบปลั๊กอิน (JSR 269) ให้ API มาตรฐานเพื่อจัดการคำอธิบายประกอบ (JSR 175)
ในความเป็นจริง JSR 269 ไม่เพียง แต่ใช้ในการจัดการกับคำอธิบายประกอบเท่านั้น ฉันคิดว่าฟังก์ชั่นที่ทรงพลังกว่าคือมันสร้างแบบจำลองของภาษาชวาเอง มันแมปองค์ประกอบภาษา Java เช่นวิธี, แพ็คเกจ, ตัวสร้าง, ประเภท, ตัวแปร, enum, คำอธิบายประกอบเป็นประเภทและองค์ประกอบ (ความแตกต่างระหว่างทั้งสองคืออะไร) ดังนั้นการทำแผนที่ความหมายของภาษา Java เป็นวัตถุ เราสามารถดูคลาสเหล่านี้ได้ภายใต้แพ็คเกจ javax.lang.model ดังนั้นเราจึงสามารถใช้ API ที่จัดทำโดย JSR 269 เพื่อสร้างสภาพแวดล้อม metaprogramming ที่อุดมไปด้วยคุณสมบัติ JSR 269 ใช้โปรเซสเซอร์คำอธิบายประกอบเพื่อประมวลผลคำอธิบายประกอบระหว่างการรวบรวมมากกว่าในระหว่างการดำเนินการ ตัวประมวลผลคำอธิบายประกอบเท่ากับปลั๊กอินของคอมไพเลอร์ดังนั้นจึงเรียกว่าการประมวลผลคำอธิบายประกอบการแทรก หากรหัส Java ใหม่ถูกสร้างขึ้นเมื่อตัวประมวลผลคำอธิบายประกอบประมวลผลคำอธิบายประกอบ (ดำเนินการวิธีกระบวนการ) คอมไพเลอร์จะเรียกโปรเซสเซอร์คำอธิบายประกอบอีกครั้ง หากรหัสใหม่ถูกสร้างขึ้นสำหรับการประมวลผลครั้งที่สองจะเรียกโปรเซสเซอร์คำอธิบายประกอบจนกว่าจะไม่มีการสร้างรหัสใหม่ ทุกครั้งที่วิธีการกระบวนการ () ถูกดำเนินการจะเรียกว่า "รอบ" เพื่อให้กระบวนการประมวลผลคำอธิบายประกอบทั้งหมดถือได้ว่าเป็นลำดับรอบ
JSR 269 ส่วนใหญ่ได้รับการออกแบบเป็น API สำหรับเครื่องมือหรือภาชนะบรรจุ ตัวอย่างเช่นเราต้องการสร้างกรอบการทดสอบหน่วยที่ใช้คำอธิบายประกอบ (เช่น testNG) เพื่อใช้คำอธิบายประกอบเพื่อระบุวิธีการทดสอบที่ต้องดำเนินการในระหว่างการทดสอบ
7. ใช้คอนโซลเพื่อพัฒนาโปรแกรมคอนโซล
JDK1.6 จัดเตรียมคลาส java.io.console ที่ใช้โดยเฉพาะในการเข้าถึงอุปกรณ์คอนโซลที่ใช้อักขระ หากโปรแกรมของคุณต้องการโต้ตอบกับ CMD ภายใต้ Windows หรือ Terminal ภายใต้ Linux คุณสามารถใช้คลาสคอนโซลเพื่อทำ แต่เราไม่ได้รับคอนโซลที่มีอยู่เสมอไม่ว่าจะเป็นคอนโซลที่มีอยู่หรือไม่นั้นขึ้นอยู่กับแพลตฟอร์มพื้นฐานและวิธีการเรียก JVM หาก JVM เริ่มต้นในบรรทัดคำสั่งแบบโต้ตอบ (เช่น Windows CMD) และอินพุตและเอาต์พุตจะไม่ถูกเปลี่ยนเส้นทางที่อื่นคุณจะได้รับอินสแตนซ์คอนโซลที่มีอยู่
8. สนับสนุนภาษาสคริปต์
เช่น: Ruby, Groovy, JavaScript
9. คำอธิบายประกอบแบบคอมมอน
คำอธิบายประกอบทั่วไปเป็นส่วนหนึ่งของข้อกำหนด Java EE 5.0 (JSR 244) และตอนนี้ Sun ได้เป็นส่วนหนึ่งของมันใน Java SE 6.0
ด้วยการเพิ่มฟังก์ชั่นข้อมูลเมตาคำอธิบายประกอบ (JSR 175) ไปยัง Java SE 5.0 เทคโนโลยี Java จำนวนมาก (เช่น EJB และบริการเว็บ) จะใช้ส่วนคำอธิบายประกอบเพื่อแทนที่ไฟล์ XML เพื่อกำหนดค่าพารามิเตอร์ที่กำลังทำงานอยู่ หากเทคโนโลยีเหล่านี้กำหนด otations ของตนเองแยกต่างหากเพื่อวัตถุประสงค์ทั่วไปก็เห็นได้ชัดว่าเป็นการก่อสร้างที่ซ้ำกันเล็กน้อย ดังนั้นจึงมีค่าที่จะกำหนดชุดคำอธิบายประกอบสาธารณะสำหรับเทคโนโลยี Java อื่น ๆ ที่เกี่ยวข้อง มันสามารถหลีกเลี่ยงการก่อสร้างที่ซ้ำกันในขณะเดียวกันก็มั่นใจได้ถึงความสอดคล้องของเทคโนโลยีต่าง ๆ ของ Java SE และ Java EE
รายการต่อไปนี้ 10 คำอธิบายประกอบคำอธิบายประกอบคำอธิบายประกอบคำอธิบายประกอบคำอธิบายประกอบคำอธิบายเป้าหมายคำอธิบายเป้าหมายที่สร้าง sourceannotation_type, ตัวสร้าง, ฟิลด์, local_variable, วิธี, แพ็คเกจ, พารามิเตอร์, ประเภท ซอร์สโค้ดที่สร้างขึ้นโดยคำอธิบายประกอบใช้เพื่อติดฉลากทรัพยากรที่สร้างขึ้น คอนเทนเนอร์ฉีดทรัพยากรภายนอกตามนี้ มีสองวิธี: การฉีดตามสนามและการฉีดตาม setter รันไทม์ทรัพยากร พิมพ์ป้ายกำกับการพึ่งพาภายนอกหลาย ๆ ครั้งในเวลาเดียวกัน คอนเทนเนอร์จะฉีดการพึ่งพาภายนอกทั้งหมดเหล่านี้ลงในวิธีการ postconstructruntime วิธีการทำงานหลังจากที่คอนเทนเนอร์ฉีดพึ่งพาทั้งหมดเพื่อดำเนินการเริ่มต้นงานหลังจากการฉีดขึ้นอยู่กับการพึ่งพา วิธีเดียวเท่านั้นที่สามารถติดป้ายได้วิธีการรันไทม์ postconstruct predestroy ก่อนที่อินสแตนซ์ของวัตถุกำลังจะถูกลบออกจากคอนเทนเนอร์วิธีการเรียกกลับที่จะดำเนินการจะต้องติดป้ายว่าเป็นประเภทรันไทม์ predestroy runas จะใช้เพื่อระบุว่าบทบาทความปลอดภัยในการดำเนินการวิธีการของคลาสที่มีป้ายกำกับ บทบาทความปลอดภัยนี้จะต้องสอดคล้องกับบทบาทความปลอดภัยของคอนเทนเนอร์ Rolesallowed Runtime Type วิธีการใช้ในการติดฉลากบทบาทความปลอดภัยที่อนุญาตให้ดำเนินการคลาสหรือวิธีการที่ติดฉลาก บทบาทความปลอดภัยนี้จะต้องสอดคล้องกับบทบาทความปลอดภัยของคอนเทนเนอร์ วิธีการอนุญาตให้บทบาททั้งหมดดำเนินการคลาสหรือวิธีการที่มีป้ายกำกับ DENYALL ประเภทรันไทม์ วิธีการไม่อนุญาตให้มีบทบาทใด ๆ ในการดำเนินการคลาสหรือวิธีการที่มีป้ายกำกับซึ่งบ่งชี้ว่าคลาสหรือวิธีการไม่สามารถทำงานในคอนเทนเนอร์ Java EE ได้ ประเภทรันไทม์ Declareroles ใช้เพื่อกำหนดบทบาทความปลอดภัยที่สามารถทดสอบได้โดยแอปพลิเคชัน มันมักจะใช้ในการใช้ isuserinrole เพื่อตรวจสอบบทบาทความปลอดภัย
สังเกต:
1. Rolesallowed, Permitall และ Denyall ไม่สามารถนำไปใช้กับชั้นเรียนหรือวิธีการของวิธีการ, permitall, และ denyall ที่ติดป้ายกำกับในชั้นเรียนจะเขียนทับบทบาท, permitall, denyallrunas, annotlowed, permitall, denyall, denyall Java SE6.0 มีคลาสนิยามของคำอธิบายประกอบห้าครั้งแรกในตารางด้านบนเท่านั้นและไม่มีเครื่องยนต์สำหรับการจัดการคำอธิบายประกอบเหล่านี้ งานนี้สามารถทำได้โดย API การประมวลผลคำอธิบายประกอบที่สามารถทำได้ (JSR 269)
เมื่อเทียบกับคุณสมบัติใหม่ของ 1.6 คุณสมบัติใหม่ของ 1.7 ทำให้เราตื่นเต้นมากขึ้นเพราะเป็นสิ่งที่เรารอคอยและมองเห็นได้และจับต้องได้
3. คุณสมบัติใหม่ของ JDK1.7
1. ค่าใบหน้าไบนารี
ใน Java7 ค่าของประเภทของการสร้าง (ไบต์, สั้น, int, ยาว) สามารถแสดงด้วยประเภทไบนารี เมื่อใช้ค่าไบนารี OB หรือ OB จะต้องเพิ่มไว้ข้างหน้าตัวอย่างเช่น:
int a = 0B01111_00000_11111_00000_10101_01010_10; สั้น b = (สั้น) 0B01100_00000_11111_0; ไบต์ C = (ไบต์) 0B00000_0001;
2. การสนับสนุนตัวแปรดิจิตอลสำหรับเส้นเลื่อน
JDK1.7 สามารถเพิ่มบรรทัดสไลด์ลงในตัวแปรประเภทตัวเลข
แต่มีบางแห่งที่ไม่สามารถเพิ่มได้
1. จุดเริ่มต้นและจุดสิ้นสุดของจำนวน
2. ก่อนและหลังจุดทศนิยม
3. ก่อน f หรือ l ตัวอย่างเช่น:
int num = 1234_5678_9;
float num2 = 222_33f;
Long num3 = 123_000_111L;
3. การรองรับสตริงของสวิตช์
คุณเคยมีเครื่องหมายคำถามมาก่อนหรือไม่? ทำไม C# จึงมีอยู่ใน Java แต่ไม่? ฮ่า แต่ Java ก็โอเคหลังจาก JDK1.7 เช่น:
สถานะสตริง = "orderstate"; สวิตช์ (สถานะ) {case "ordercancel": system.out.println ("การยกเลิกคำสั่งซื้อ"); หยุดพัก; กรณี "orderuccess": system.out.println ("การสมัครสมาชิกสำเร็จ"); หยุดพัก; ค่าเริ่มต้น: System.out.println ("ไม่ทราบสถานะ"); -4.Try-with-resource
Try-with-sources เป็นการประกาศลองที่กำหนดทรัพยากรอย่างน้อยหนึ่งแหล่ง ทรัพยากรนี้หมายถึงวัตถุที่โปรแกรมต้องปิดหลังจากประมวลผลแล้ว ลองใช้ทรัพยากรด้วยทรัพยากรทุกทรายจะปิดหลังจากการประมวลผลเสร็จสมบูรณ์
ทรัพยากรที่สามารถใช้ทรัพยากรได้ด้วยการทดลองคือ:
วัตถุใด ๆ ที่ใช้ Java.lang.autocloseable Interface Java.io.Closeable Interface
ตัวอย่างเช่น:
สตริงคงที่สาธารณะ readfirstlineFromFile (เส้นทางสตริง) พ่น IOException {ลอง (bufferedReader br = bufferedReader ใหม่ (filereader ใหม่ (พา ธ ))) {return br.readline (); -
ใน Java 7 และรุ่นใหม่กว่า BufferedReader ใช้อินเตอร์เฟส java.lang.autocloseable
เนื่องจาก BufferedReader ถูกกำหนดไว้ในการประกาศทรัพยากรลอง-ทรัพยากรจึงจะถูกปิดโดยอัตโนมัติโดยไม่คำนึงว่าคำสั่งลองเป็นเรื่องปกติหรือผิดปกติ ก่อน Java7 คุณต้องใช้บล็อกในที่สุดเพื่อปิดวัตถุนี้
5. จับข้อยกเว้นหลายข้อแล้วโยนข้อยกเว้นอีกครั้งด้วยการตรวจสอบประเภทที่ดีขึ้น
ตัวอย่างเช่น:
โมฆะคงที่สาธารณะก่อน () {ลอง {bufferedReader reader = ใหม่ bufferedReader (ใหม่ filereader ("")); การเชื่อมต่อ con = null; คำสั่ง stmt = con.createstatement (); } catch (iOexception | sqlexception e) {// จับข้อยกเว้นหลายข้อ E คือประเภทสุดท้าย E.PrintStackTrace (); -ข้อดี: การใช้การจับหนึ่งครั้งเพื่อจัดการกับข้อยกเว้นหลายข้อมีขนาดเล็กและมีประสิทธิภาพมากกว่าการใช้การจับหลายครั้งเพื่อจัดการข้อยกเว้นหนึ่งข้อกับไบต์ที่สร้างขึ้นโดยการประมวลผลข้อยกเว้นหนึ่งข้อ
6. พิมพ์การอนุมานเมื่อสร้างยาสามัญ
ตราบใดที่คอมไพเลอร์สามารถอนุมานพารามิเตอร์ประเภทจากบริบทคุณสามารถแทนที่พารามิเตอร์ทั่วไปด้วยวงเล็บมุมเปล่าคู่ <> วงเล็บคู่นี้เรียกว่าเพชรส่วนตัว ก่อน Java SE 7 คุณควรทำสิ่งนี้เมื่อประกาศวัตถุทั่วไป
รายการ <string> list = new ArrayList <String> ();
และหลังจาก Java SE7 คุณสามารถทำได้
รายการ <String> list = new ArrayList <> ();
เนื่องจากคอมไพเลอร์สามารถอนุมานพารามิเตอร์ประเภทจากก่อนหน้า (รายการ) คุณจึงไม่สามารถเขียนพารามิเตอร์ทั่วไปได้อีกต่อไปหลังจาก ArrayList ที่ตามมาเพียงแค่ใช้วงเล็บมุมเปล่าคู่หนึ่ง แน่นอนคุณต้องพก "เพชร" <> มิฉะนั้นจะมีคำเตือน
Java SE7 รองรับการอนุมานประเภทที่ จำกัด เท่านั้น: คุณสามารถใช้การอนุมานประเภทได้เฉพาะในกรณีที่ประเภทพารามิเตอร์ของตัวสร้างจะประกาศอย่างมีนัยสำคัญในบริบทมิฉะนั้นจะไม่ทำงาน
รายการ <String> list = new ArrayList <> (); list.add ("A"); // สิ่งนี้ไม่ทำงานรายการ ADDALL (arrayList ใหม่ <> ()); // นี่อาจเป็นรายการ <? ขยายสตริง> list2 = arraylist ใหม่ <> (); list.addall (list2);
7. (ไม่มี)
8. เพิ่มเครื่องมือและวิธีการใหม่ ๆ เพื่อรับข้อมูลด้านสิ่งแวดล้อม
ตัวอย่างเช่น:
File System.getUserHomedir () // ไดเรกทอรีผู้ใช้ปัจจุบันระบบไฟล์ System.getUserDir () // ไดเรกทอรีที่คุณอยู่เมื่อเริ่มต้นกระบวนการ Java Process 5 File System.getJavaiotempdir () // io ระบบไฟล์โฟลเดอร์ชั่วคราว
9. การเพิ่มอย่างปลอดภัยการลบการคูณและการหาร
ตัวอย่างเช่น:
int math.safetoint (ค่ายาว) int math.safenegate (ค่า int) ยาว math.safesubtract (ค่ายาว 1, ค่า int 2) Math.safesubtract (ค่ายาว 1, ค่ายาว 2) int math.safemultiply (intuite 1, ค่านาน 2) คณิตศาสตร์ยาว math.safenegate (ค่ายาว) int math.safeadd (ค่า int 1, ค่า int 2) Long Math.safeadd (ค่ายาว 1, ค่า int 2) Math.safeadd ยาว (ค่ายาว 1, ค่ายาว 2) int math.safesubtract (ค่า int 1, ค่า int 2)
ดีมากได้รับการจัดเรียงจนถึงตอนนี้ ฉันจะเพิ่มในภายหลัง
ควรสังเกตว่าหากคุณไม่แน่ใจเกี่ยวกับเวอร์ชัน JDK ก่อนหน้าของคุณอย่าใช้คุณสมบัติใหม่ไม่เช่นนั้นอาจมีปัญหาเรื่องนี้หรือ