java basics
1.0.0
คลิกถ้าคุณชอบโครงการ การมีส่วนร่วมของคุณได้รับการต้อนรับอย่างเต็มที่
มัลติเธรด
คอลเลกชัน
การเชื่อมต่อฐานข้อมูล Java (JDBC)
โปรแกรมจาวา
วิธีการสตริง Java
หน้าเซิร์ฟเวอร์จาการ์ตา (JSP)
เซิร์ฟเล็ต
คำถามแบบปรนัย Java
รูปแบบการออกแบบ Java
ไฮเบอร์เนต
ข้อมูลเบื้องต้นเกี่ยวกับ Spring Framework
การแนะนำ
สถาปัตยกรรมชวา
ชนิดข้อมูลจาวา
วิธีการจาวา
การเขียนโปรแกรมเชิงฟังก์ชัน Java
นิพจน์ Java Lambda
คลาสจาวา
ตัวสร้าง Java
อาร์เรย์จาวา
สตริงจาวา
การสะท้อนของชวา
สตรีม Java
นิพจน์ทั่วไปของ Java
การจัดการไฟล์จาวา
ข้อยกเว้นของจาวา
มรดกจาวา
การเอาชนะวิธีการ Java
Java Polymorphism
Java นามธรรม
อินเทอร์เฟซจาวา
การห่อหุ้ม Java
Java Generics
เบ็ดเตล็ด
วิธีการอินเทอร์เฟซตามค่าเริ่มต้น
นิพจน์แลมบ์ดา;
อินเทอร์เฟซการทำงาน
การอ้างอิงถึงวิธีการและตัวสร้าง
คำอธิบายประกอบที่ทำซ้ำได้
คำอธิบายประกอบเกี่ยวกับชนิดข้อมูล
การสะท้อนพารามิเตอร์ของวิธีการ
สตรีม API สำหรับการทำงานกับคอลเลกชัน
การเรียงลำดับอาร์เรย์แบบขนาน
API ใหม่สำหรับการทำงานกับวันที่และเวลา
JavaScript Nashorn Engine ใหม่;
เพิ่มคลาสใหม่หลายคลาสสำหรับการดำเนินการที่ปลอดภัยของเธรด
เพิ่ม API ใหม่สำหรับ Calendar และ Locale ;
เพิ่มการรองรับ Unicode 6.2.0 ;
เพิ่มคลาสมาตรฐานสำหรับการทำงานกับ Base64 ;
เพิ่มการรองรับเลขคณิตที่ไม่ได้ลงนาม
ปรับปรุงตัวสร้าง java.lang.String(byte[], *) และประสิทธิภาพของเมธอด java.lang.String.getBytes() ;
การใช้งานใหม่ AccessController.doPrivileged ที่ช่วยให้คุณสามารถตั้งค่าชุดย่อยของสิทธิ์โดยไม่ต้องตรวจสอบ * ระดับการเข้าถึงอื่น ๆ ทั้งหมด
อัลกอริธึมที่ใช้รหัสผ่านมีประสิทธิภาพมากขึ้น
เพิ่มการรองรับ SSL / TLS Server Name Indication (NSI) ใน JSSE Server
ปรับปรุงที่เก็บคีย์ (KeyStore);
เพิ่มอัลกอริทึม SHA-224;
ลบสะพาน JDBC - ODBC;
PermGen ถูกลบออก วิธีการจัดเก็บข้อมูลเมตาของคลาสมีการเปลี่ยนแปลง
ความสามารถในการสร้างโปรไฟล์สำหรับแพลตฟอร์ม Java SE ซึ่งรวมถึงไม่ใช่ทั้งแพลตฟอร์ม แต่เป็นบางส่วนเท่านั้น
เครื่องมือ
เพิ่มยูทิลิตี้ jjs สำหรับการใช้ JavaScript Nashorn;
คำสั่ง java สามารถรันแอปพลิเคชัน JavaFX ได้
เพิ่มยูทิลิตี้ jdeps สำหรับการวิเคราะห์ไฟล์ .class
↥ กลับไปด้านบน
Nashorn เป็นเอ็นจิ้น JavaScript ที่พัฒนาขึ้นใน Java โดย Oracle ออกแบบมาเพื่อมอบความสามารถในการฝังโค้ด JavaScript ในแอปพลิเคชัน Java เมื่อเปรียบเทียบกับ Rhino ซึ่งได้รับการสนับสนุนโดย Mozilla Foundation แล้ว Nashorn มอบประสิทธิภาพที่ดีกว่า 2 ถึง 10 เท่า เนื่องจากมันจะคอมไพล์โค้ดและถ่ายโอนไบต์โค้ดไปยังเครื่องเสมือน Java ในหน่วยความจำโดยตรง Nashorn สามารถคอมไพล์โค้ด JavaScript และสร้างคลาส Java ที่โหลดด้วยตัวโหลดพิเศษ นอกจากนี้ยังสามารถเรียกโค้ด Java ได้โดยตรงจาก JavaScript
↥ กลับไปด้านบน
jjs - นี่คือยูทิลิตี้บรรทัดคำสั่งที่ให้คุณรันโปรแกรม JavaScript ได้โดยตรงในคอนโซล
↥ กลับไปด้านบน
ใน Java มีสามวิธีที่แตกต่างกันในการอ่านอินพุตจากผู้ใช้ในสภาพแวดล้อมบรรทัดคำสั่ง ( console )
1. การใช้คลาส Buffered Reader:
วิธีการนี้ใช้โดยการห่อ System.in ( สตรีมอินพุตมาตรฐาน ) ใน InputStreamReader ซึ่งห่อไว้ใน BufferedReader เราสามารถอ่านอินพุตจากผู้ใช้ในบรรทัดคำสั่งได้
/** * Buffered Reader Class */import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class Test { public static void main(String[] args) พ่น IOException { // Enter ข้อมูลโดยใช้ BufferReader BufferedReader reader = new BufferedReader (new InputStreamReader (System.in)); // อ่านข้อมูลโดยใช้ readLine String name = reader.readLine(); // พิมพ์บรรทัดอ่าน System.out.println(name);
-
-2. การใช้คลาสสแกนเนอร์:
วัตถุประสงค์หลักของคลาส Scanner คือเพื่อแยกวิเคราะห์ประเภทและสตริงดั้งเดิมโดยใช้นิพจน์ทั่วไป อย่างไรก็ตาม ยังสามารถใช้เพื่ออ่านอินพุตจากผู้ใช้ในบรรทัดคำสั่งได้ด้วย
/** * Scanner Class */import java.util.Scanner;class GetInputFromUser { public static void main(String args[]) { // การใช้ Scanner เพื่อรับอินพุตจาก User Scanner ใน = new Scanner(System.in); สตริง s = in.nextLine(); System.out.println("คุณป้อนสตริง " + s); int a = in.nextInt(); System.out.println("คุณป้อนจำนวนเต็ม " + a); float b = in.nextFloat(); System.out.println("คุณเข้าสู่ float " + b);
-
-3. การใช้คลาสคอนโซล:
มันกลายเป็นวิธีที่นิยมใช้ในการอ่านอินพุตของผู้ใช้จากบรรทัดคำสั่ง นอกจากนี้ยังสามารถใช้เพื่ออ่านอินพุตที่เหมือนกับรหัสผ่านโดยไม่ต้องสะท้อนอักขระที่ผู้ใช้ป้อน สามารถใช้ไวยากรณ์สตริงรูปแบบได้ ( เช่น System.out.printf() )
/** * Console Class */public class ตัวอย่าง { public static void main(String[] args) { // การใช้ Console เพื่อป้อนข้อมูลจากผู้ใช้ String name = System.console().readLine(); System.out.println (ชื่อ);
-
-↥ กลับไปด้านบน
คำสั่ง javap แสดงข้อมูลเกี่ยวกับฟิลด์ ตัวสร้าง และเมธอดที่มีอยู่ในไฟล์คลาส คำสั่ง javap (หรือที่รู้จักในชื่อ Java Disassembler) จะแยกไฟล์คลาสตั้งแต่หนึ่งไฟล์ขึ้นไป
/** * Java Disassembler */class Simple { โมฆะคงที่สาธารณะ main (String args []) { System.out.println ("Hello World");
-
-cmd> javap Simple.class
เอาท์พุต
เรียบเรียงจากคลาส ".java" Simple {
เรียบง่าย();
โมฆะคงสาธารณะ main(java.lang.String[]);
-↥ กลับไปด้านบน
System.out::println ? นิพจน์ที่ระบุแสดงให้เห็นการส่งผ่านการอ้างอิงไปยังวิธีการคงที่ของคลาส println() System.out
↥ กลับไปด้านบน
สตรีมสามารถเรียงลำดับและขนานได้ การดำเนินการบนสตรีมตามลำดับจะดำเนินการในเธรดตัวประมวลผลเดียวบนสตรีมแบบขนาน - โดยใช้เธรดตัวประมวลผลหลายตัว กระแสข้อมูลแบบขนานใช้กระแสที่ใช้ร่วมกัน ForkJoinPool ผ่านวิธีการ ForkJoinPool.commonPool() แบบคงที่ ในกรณีนี้ หากสภาพแวดล้อมไม่ใช่แบบมัลติคอร์ สตรีมจะดำเนินการตามลำดับ ในความเป็นจริงการใช้สตรีมแบบขนานลดลงเนื่องจากข้อมูลในสตรีมจะถูกแบ่งออกเป็นส่วน ๆ แต่ละส่วนจะถูกประมวลผลบนคอร์โปรเซสเซอร์ที่แยกจากกันและในท้ายที่สุดส่วนเหล่านี้จะเชื่อมต่อกันและการดำเนินการขั้นสุดท้ายจะดำเนินการใน พวกเขา.
คุณยังสามารถใช้วิธีอินเทอร์เฟซ parallelStream() เพื่อสร้างสตรีมแบบขนานจาก Collection เลกชัน Collection
หากต้องการสร้างกระแสต่อเนื่องแบบขนาน คุณต้องเรียกใช้เมธอด Stream บนวัตถุ parallel() เมธอด isParallel() ช่วยให้คุณทราบว่าสตรีมเป็นแบบขนานหรือไม่
การใช้เมธอด parallel() และ sequential() เป็นไปได้ที่จะกำหนดว่าการดำเนินการใดสามารถเป็นแบบขนานได้ และการดำเนินการใดเป็นลำดับเท่านั้น คุณยังสามารถสร้างสตรีมแบบขนานจากสตรีมแบบต่อเนื่องใดๆ และในทางกลับกัน:
ของสะสม .ลำธาร () .peek ( ... ) // การดำเนินการเป็นไปตามลำดับ .ขนาน () .map ( ... ) // การดำเนินการสามารถดำเนินการแบบขนานได้ .ลำดับ () .reduce ( ... ) // การดำเนินการเป็นลำดับอีกครั้ง
ตามกฎแล้ว องค์ประกอบต่างๆ จะถูกถ่ายโอนไปยังสตรีมตามลำดับเดียวกับที่กำหนดไว้ในแหล่งข้อมูล เมื่อทำงานกับสตรีมแบบขนาน ระบบจะรักษาลำดับขององค์ประกอบไว้ ข้อยกเว้นคือเมธอด forEach() ที่สามารถส่งออกองค์ประกอบตามลำดับแบบสุ่ม และเพื่อรักษาลำดับ จำเป็นต้องใช้เมธอด forEachOrdered()
เกณฑ์ที่อาจส่งผลต่อประสิทธิภาพในการสตรีมแบบขนาน:
ขนาดข้อมูล - ยิ่งมีข้อมูลมากเท่าไร การแยกข้อมูลก่อนแล้วจึงรวมข้อมูลเข้าด้วยกันก็จะยิ่งยากขึ้นเท่านั้น
จำนวนแกนประมวลผล ตามทฤษฎีแล้ว ยิ่งมีแกนประมวลผลในคอมพิวเตอร์มากเท่าใด โปรแกรมก็จะทำงานเร็วขึ้นเท่านั้น หากเครื่องมีแกนเดียวก็ไม่สมเหตุสมผลที่จะใช้เธรดแบบขนาน
ยิ่งสตรีมใช้โครงสร้างข้อมูลที่ง่ายกว่า การดำเนินการก็จะเร็วขึ้นเท่านั้น ตัวอย่างเช่น ข้อมูลจาก ArrayList ใช้งานง่าย เนื่องจากโครงสร้างของคอลเลกชันนี้ถือว่าลำดับของข้อมูลที่ไม่เกี่ยวข้องกัน แต่คอลเลกชันประเภท LinkedList ไม่ใช่ตัวเลือกที่ดีที่สุด เนื่องจากในรายการตามลำดับองค์ประกอบทั้งหมดจะเชื่อมต่อกับก่อนหน้า / ถัดไป และข้อมูลดังกล่าวก็ยากที่จะขนานกัน
การดำเนินการกับประเภทดั้งเดิมจะเร็วกว่ากับคลาสอ็อบเจ็กต์
ขอแนะนำอย่างยิ่งว่าคุณอย่าใช้สตรีมแบบขนานสำหรับการดำเนินการที่ยาวนานใดๆ (เช่น การเชื่อมต่อเครือข่าย) เนื่องจากสตรีมแบบขนานทั้งหมดทำงานกับ ForkJoinPool เดียว การดำเนินการแบบยาวดังกล่าวสามารถหยุดสตรีมแบบขนานทั้งหมดใน JVM ได้เนื่องจากไม่มีเธรดที่พร้อมใช้งาน ในสระน้ำ ฯลฯ e. ควรใช้สตรีมแบบขนานสำหรับการดำเนินการระยะสั้นโดยนับได้เป็นมิลลิวินาที แต่ไม่ใช่สำหรับการดำเนินการที่นับได้เป็นวินาทีและนาที
การบันทึกลำดับในสตรีมแบบขนานจะเพิ่มต้นทุนการดำเนินการ และหากลำดับไม่สำคัญ คุณสามารถปิดการใช้งานการบันทึกและเพิ่มประสิทธิภาพการทำงานโดยใช้การดำเนินการระดับกลาง unordered() :
คอลเลกชัน.parallelStream ()
.เรียงลำดับ ()
.ไม่เรียงลำดับ ()
.collect ( นักสะสม . toList ());↥ กลับไปด้านบน
Java Virtual Machine (JVM) เป็นข้อกำหนดที่ให้สภาพแวดล้อมรันไทม์ซึ่งสามารถดำเนินการ java bytecode(.class files) ได้ JVM เป็นแพลตฟอร์ม JVM ทำหน้าที่เป็นเครื่องหรือโปรเซสเซอร์ "เสมือน" ความเป็นอิสระของแพลตฟอร์มของ Java ส่วนใหญ่ประกอบด้วย Java Virtual Machine (JVM) JVM ทำให้สิ่งนี้เป็นไปได้เนื่องจากทราบถึงความยาวคำสั่งเฉพาะและลักษณะเฉพาะอื่น ๆ ของแพลตฟอร์ม (ระบบปฏิบัติการ)
JVM ไม่ขึ้นอยู่กับแพลตฟอร์ม Java Virtual Machine (JVM) จัดเตรียมสภาพแวดล้อมเพื่อเรียกใช้งานไฟล์ java (. Class file) ดังนั้นท้ายที่สุดแล้วมันขึ้นอยู่กับเคอร์เนลและเคอร์เนลนั้นแตกต่างจาก OS (ระบบปฏิบัติการ) ถึง OS JVM ใช้เพื่อแปลรหัสไบต์เป็นภาษาเครื่องสำหรับคอมพิวเตอร์เครื่องใดเครื่องหนึ่งและดำเนินการตามคำสั่งภาษาเครื่องที่เกี่ยวข้องเช่นกัน
↥ กลับไปด้านบน
คอมไพเลอร์ Just-In-Time (JIT) เป็นส่วนประกอบของสภาพแวดล้อมรันไทม์ที่ปรับปรุงประสิทธิภาพของแอปพลิเคชัน Java โดยการคอมไพล์รหัสไบต์เป็นรหัสเครื่องเนทีฟ ณ รันไทม์
โปรแกรม Java ประกอบด้วยคลาสซึ่งมีไบต์โค้ดที่เป็นกลางตามแพลตฟอร์มซึ่งสามารถตีความได้โดย JVM บนสถาปัตยกรรมคอมพิวเตอร์ที่แตกต่างกันจำนวนมาก ณ รันไทม์ JVM จะโหลดไฟล์คลาส กำหนดซีแมนทิกส์ของแต่ละโค้ดไบต์ และดำเนินการคำนวณที่เหมาะสม การใช้โปรเซสเซอร์และหน่วยความจำเพิ่มเติมในระหว่างการตีความหมายความว่าแอปพลิเคชัน Java ทำงานช้ากว่าแอปพลิเคชันดั้งเดิม คอมไพเลอร์ JIT ช่วยปรับปรุงประสิทธิภาพของโปรแกรม Java โดยการคอมไพล์รหัสไบต์เป็นรหัสเครื่องเนทีฟ ณ รันไทม์ คอมไพเลอร์ JIT ถูกเปิดใช้งานตามค่าเริ่มต้น เมื่อคอมไพล์เมธอดแล้ว JVM จะเรียกโค้ดที่คอมไพล์ของเมธอดนั้นโดยตรงแทนที่จะตีความ
↥ กลับไปด้านบน
Java ClassLoader เป็นส่วนหนึ่งของ Java Runtime Environment ที่โหลดคลาส Java ลงใน Java Virtual Machine แบบไดนามิก โค้ด Java ถูกคอมไพล์เป็นไฟล์คลาสโดยคอมไพเลอร์ javac และ JVM รันโปรแกรม Java โดยการรันโค้ดไบต์ที่เขียนในไฟล์คลาส ClassLoader มีหน้าที่โหลดไฟล์คลาสจากระบบไฟล์ เครือข่าย หรือแหล่งอื่นใด
ประเภทของ ClassLoader:
1. ตัวโหลดคลาส Bootstrap :
โหลดไฟล์คลาส JDK มาตรฐานจาก rt.jar และคลาสหลักอื่นๆ มันโหลดไฟล์คลาสจาก jre/lib/rt.jar ตัวอย่างเช่น คลาสแพ็กเกจ java.lang
2. ตัวโหลดคลาสส่วนขยาย :
โดยจะโหลดคลาสจากส่วนขยาย JDK โดยตรง โดยปกติจะเป็นไดเร็กทอรี JAVA_HOME/lib/ext หรือไดเร็กทอรีอื่น ๆ เป็น java.ext.dirs
3. ตัวโหลดคลาสระบบ :
โหลดคลาสเฉพาะแอปพลิเคชันจากตัวแปรสภาพแวดล้อม CLASSPATH สามารถตั้งค่าได้ขณะเรียกใช้โปรแกรมโดยใช้ตัวเลือกบรรทัดคำสั่ง -cp หรือ classpath
↥ กลับไปด้านบน
1. เจดีเค :
Java Development Kit เป็นองค์ประกอบหลักของ Java Environment และมีเครื่องมือ ไฟล์ปฏิบัติการ และไบนารีทั้งหมดที่จำเป็นในการคอมไพล์ ดีบัก และรันโปรแกรม Java
2. เจวีเอ็ม :
JVM รับผิดชอบในการแปลงโค้ด Byte เป็นโค้ดเฉพาะเครื่อง JVM ยังขึ้นอยู่กับแพลตฟอร์มและมีฟังก์ชัน Java หลัก เช่น การจัดการหน่วยความจำ การรวบรวมขยะ ความปลอดภัย ฯลฯ JVM สามารถปรับแต่งได้ และเราสามารถใช้ตัวเลือก Java เพื่อปรับแต่งได้ เช่น การจัดสรรหน่วยความจำขั้นต่ำและสูงสุดให้กับ JVM JVM ถูกเรียกว่าเสมือนเนื่องจากมีอินเทอร์เฟซที่ไม่ขึ้นอยู่กับระบบปฏิบัติการและฮาร์ดแวร์เครื่องพื้นฐาน
2. เจอาร์อี :
Java Runtime Environment เป็นแพลตฟอร์มสำหรับรันโปรแกรมจาวา JRE ประกอบด้วยไบนารี JVM และ Java และคลาสอื่นๆ เพื่อให้สามารถรันโปรแกรมใดๆ ได้สำเร็จ
↥ กลับไปด้านบน
1. พื้นที่ฮีป Java:
Java Heap space ถูกใช้โดยรันไทม์ Java เพื่อจัดสรรหน่วยความจำให้กับ คลาส Objects และ JRE เมื่อใดก็ตามที่เราสร้างวัตถุใด ๆ มันจะถูกสร้างขึ้นในพื้นที่ฮีปเสมอ
Garbage Collection ทำงานบนหน่วยความจำฮีปเพื่อเพิ่มหน่วยความจำที่ใช้โดยอ็อบเจ็กต์ที่ไม่มีการอ้างอิงใดๆ อ็อบเจ็กต์ใดๆ ที่สร้างขึ้นในพื้นที่ฮีปจะสามารถเข้าถึงแบบโกลบอลและสามารถอ้างอิงได้จากทุกที่ของแอปพลิเคชัน
2. หน่วยความจำ Java Stack:
Stack ใน java เป็นส่วนหนึ่งของหน่วยความจำซึ่งประกอบด้วย วิธี การ ตัวแปรท้องถิ่น และ ตัวแปรอ้างอิง ตัวแปรท้องถิ่นจะถูกสร้างขึ้นในสแต็ก
หน่วยความจำสแต็กจะถูกอ้างอิงตามลำดับ LIFO ( Last-In-First-Out ) เสมอ เมื่อใดก็ตามที่เรียกใช้เมธอด บล็อกใหม่จะถูกสร้างขึ้นในหน่วยความจำสแต็กสำหรับวิธีการเก็บค่าดั้งเดิมในเครื่องและอ้างอิงถึงอ็อบเจ็กต์อื่นๆ ในเมธอด
ทันทีที่วิธีการสิ้นสุดลง บล็อกจะไม่ได้ใช้งานและพร้อมใช้งานสำหรับวิธีถัดไป ขนาดหน่วยความจำสแต็กนั้นน้อยกว่ามากเมื่อเทียบกับหน่วยความจำฮีป
ความแตกต่าง:
| พารามิเตอร์ | หน่วยความจำสแต็ค | พื้นที่ฮีป |
|---|---|---|
| แอปพลิเคชัน | สแต็กถูกใช้เป็นส่วนๆ ครั้งละหนึ่งรายการระหว่างการดำเนินการเธรด | แอปพลิเคชันทั้งหมดใช้พื้นที่ฮีประหว่างรันไทม์ |
| ขนาด | Stack มีการจำกัดขนาดขึ้นอยู่กับ OS และมักจะเล็กกว่า Heap | ไม่มีการจำกัดขนาดบนฮีป |
| พื้นที่จัดเก็บ | เก็บเฉพาะตัวแปรดั้งเดิมและการอ้างอิงไปยังอ็อบเจ็กต์ที่สร้างขึ้นใน Heap Space | วัตถุที่สร้างขึ้นใหม่ทั้งหมดจะถูกเก็บไว้ที่นี่ |
| คำสั่ง | เข้าถึงได้โดยใช้ระบบจัดสรรหน่วยความจำ Last-in First-out (LIFO) | หน่วยความจำนี้เข้าถึงได้ผ่านเทคนิคการจัดการหน่วยความจำที่ซับซ้อนซึ่งรวมถึงคนรุ่นใหม่ รุ่นเก่าหรือรุ่นถาวร และรุ่นถาวร |
| ชีวิต | หน่วยความจำสแต็กมีอยู่ตราบเท่าที่วิธีการปัจจุบันกำลังทำงานอยู่เท่านั้น | พื้นที่ฮีปมีอยู่ตราบใดที่แอปพลิเคชันทำงาน |
| ประสิทธิภาพ | ค่อนข้างเร็วกว่ามากในการจัดสรรเมื่อเปรียบเทียบกับฮีป | จัดสรรได้ช้ากว่าเมื่อเปรียบเทียบกับสแต็ก |
| การจัดสรร/การจัดสรรคืน | หน่วยความจำนี้จะถูกจัดสรรและจัดสรรคืนโดยอัตโนมัติเมื่อมีการเรียกและส่งคืนเมธอดตามลำดับ | พื้นที่ฮีปจะถูกจัดสรรเมื่อมีการสร้างออบเจ็กต์ใหม่และจัดสรรคืนโดย Gargabe Collector เมื่อไม่ได้อ้างอิงอีกต่อไป |
↥ กลับไปด้านบน
JVM เป็นโปรแกรมที่ใช้ Java bytecode และแปลงโค้ดไบต์ (ทีละบรรทัด) ให้เป็นโค้ดที่เครื่องเข้าใจได้ JVM ดำเนินการบางประเภทโดยเฉพาะ:
กำลังโหลดโค้ด
การตรวจสอบรหัส
การดำเนินการรหัส
มันจัดเตรียมสภาพแวดล้อมรันไทม์ให้กับผู้ใช้
ประเภทของพื้นที่หน่วยความจำที่จัดสรรโดย JVM:
1. Classloader : Classloader เป็นระบบย่อยของ JVM ที่ใช้ในการโหลดไฟล์คลาส
2. Class(Method) Area : Class(Method) Area เก็บโครงสร้างต่อคลาส เช่น พูลคงที่รันไทม์ ข้อมูลฟิลด์และเมธอด รหัสสำหรับเมธอด
3. ฮีป : เป็นพื้นที่ข้อมูลรันไทม์ที่มีการจัดสรรออบเจ็กต์
4. Stack : Java Stack จัดเก็บเฟรม โดยเก็บตัวแปรในตัวเครื่องและผลลัพธ์บางส่วน และมีส่วนร่วมในการเรียกใช้และส่งคืนเมธอด แต่ละเธรดมีสแต็ก JVM ส่วนตัว ซึ่งสร้างขึ้นพร้อมกันกับเธรด
5. โปรแกรมเคาน์เตอร์ลงทะเบียน : PC (โปรแกรมเคาน์เตอร์) ลงทะเบียน ประกอบด้วยที่อยู่ของคำสั่งเครื่องเสมือน Java ที่กำลังดำเนินการอยู่
6. Native Method Stack : มันมีวิธีการดั้งเดิมทั้งหมดที่ใช้ในแอปพลิเคชัน
↥ กลับไปด้านบน
การแปลงประเภทข้อมูลดั้งเดิมเป็นประเภท Wrapper ที่เทียบเท่าโดยอัตโนมัติเรียกว่า Boxing และการดำเนินการตรงกันข้ามเรียกว่า Unboxing
ตัวอย่าง: ออโต้บ็อกซ์
/** * Autoboxing */class BoxingExample { โมฆะคงที่สาธารณะ main (String args []) { int a = 50; จำนวนเต็ม a2 = จำนวนเต็มใหม่ (a); // จำนวนเต็มมวย a3 = 5; // Boxing System.out.println(a2 + " " + a3);
-
-ตัวอย่าง: การแกะกล่อง
/** * Unboxing */class UnboxingExample { โมฆะคงที่สาธารณะ main (String args []) { จำนวนเต็ม i = จำนวนเต็มใหม่ (50); int = ฉัน; System.out.println(ก);
-
-↥ กลับไปด้านบน
1. ชั่วคราว:
โมดิฟายเออร์ชั่วคราวจะบอกระบบย่อยการทำให้เป็นอนุกรมของอ็อบเจ็กต์ Java ให้ยกเว้นฟิลด์เมื่อทำให้เป็นอนุกรมอินสแตนซ์ของคลาส เมื่อวัตถุถูกดีซีเรียลไลซ์แล้ว ฟิลด์จะถูกเตรียมใช้งานเป็นค่าเริ่มต้น เช่น null สำหรับประเภทการอ้างอิง และศูนย์หรือเท็จสำหรับประเภทดั้งเดิม
ตัวอย่าง:
/** * ชั่วคราว */จำกัด int ชั่วคราวสาธารณะ = 55; // จะไม่คงอยู่สาธารณะ int b; //จะยังคงอยู่
2. ระเหย:
โมดิฟายเออร์ที่ระเหยได้จะบอก JVM ว่าการเขียนลงในฟิลด์ควรถูกฟลัชไปยังหน่วยความจำแบบซิงโครนัสเสมอ และการอ่านฟิลด์ควรอ่านจากหน่วยความจำเสมอ ซึ่งหมายความว่าฟิลด์ที่ทำเครื่องหมายว่าระเหยได้จะสามารถเข้าถึงและอัปเดตได้อย่างปลอดภัยในแอปพลิเคชันแบบมัลติเธรดโดยไม่ต้องใช้การซิงโครไนซ์แบบเนทีฟหรือแบบมาตรฐาน
ตัวอย่าง:
/** * ระเหยได้ */คลาสสาธารณะ MyRunnable ใช้งาน Runnable { บูลีนระเหยส่วนตัวใช้งานอยู่; โมฆะสาธารณะวิ่ง () { ใช้งานอยู่ = จริง; ในขณะที่ (ใช้งานอยู่) {
-
} โมฆะสาธารณะหยุด () { ใช้งานอยู่ = เท็จ;
-
-↥ กลับไปด้านบน
การยืนยันช่วยให้สามารถทดสอบความถูกต้องของสมมติฐานใดๆ ที่เกิดขึ้นในโปรแกรมได้ การยืนยันทำได้โดยใช้คำสั่ง assert ใน Java
ขณะที่ดำเนินการยืนยันก็เชื่อว่าเป็นความจริง หากล้มเหลว JVM จะส่งข้อผิดพลาดชื่อ AssertionError ส่วนใหญ่จะใช้เพื่อการทดสอบระหว่างการพัฒนา
คำสั่ง assert ใช้กับนิพจน์บูลีนและสามารถเขียนได้สองวิธี
// วิธีแรกยืนยันนิพจน์// วิธีที่สองยืนยัน expression1 : expression2;
ตัวอย่าง:
/** * การยืนยัน */ ตัวอย่างคลาสสาธารณะ { โมฆะคงที่สาธารณะ main (String [] args) { อายุ int = 14; ยืนยันอายุ <= 18 : "ไม่สามารถลงคะแนนเสียงได้"; System.out.println("อายุของผู้มีสิทธิเลือกตั้งคือ " + อายุ);
-
-↥ กลับไปด้านบน
1. ตัวแปรสุดท้าย:
ตัวแปรสุดท้ายไม่มีอะไรนอกจากค่าคงที่ เราไม่สามารถเปลี่ยนค่าของตัวแปรสุดท้ายได้เมื่อเริ่มต้นแล้ว
ตัวอย่าง:
/** * ตัวแปรสุดท้าย */คลาสสาธิต { สุดท้าย int MAX_VALUE = 99; เป็นโมฆะ myMethod () { MAX_VALUE = 101;
} โมฆะสาธารณะคงที่ main (String args []) { Demo obj = new Demo (); obj.myMethod();
-
-เอาท์พุต
ข้อยกเว้นในเธรด "main" java.lang.Error: ปัญหาการคอมไพล์ที่ไม่ได้รับการแก้ไข: ไม่สามารถกำหนดฟิลด์สุดท้าย Demo.MAX_VALUE ได้ที่ Beginnersbook.com.Demo.myMethod(Details.java:6)ที่ Beginnersbook.com.Demo.main(Details.java:10)
2. ตัวแปรสุดท้ายที่ว่างเปล่า:
ตัวแปรสุดท้ายที่ไม่ได้เตรียมใช้งานในขณะที่ประกาศเรียกว่าตัวแปรสุดท้ายเปล่า เราต้องเริ่มต้นตัวแปรสุดท้ายที่ว่างเปล่าในตัวสร้างของคลาส มิฉะนั้นจะทำให้เกิดข้อผิดพลาดในการคอมไพล์ (ข้อผิดพลาด: variable MAX_VALUE might not have been initialized )
ตัวอย่าง:
/** * ตัวแปรสุดท้ายว่าง */คลาสสาธิต { // ตัวแปรสุดท้ายว่าง สุดท้าย int MAX_VALUE; Demo() { // จะต้องเริ่มต้นในตัวสร้าง MAX_VALUE = 100;
} เป็นโมฆะ myMethod() { System.out.println(MAX_VALUE);
} โมฆะสาธารณะคงที่ main (String args []) { Demo obj = new Demo (); obj.myMethod();
-
-เอาท์พุต
100
3. วิธีการสุดท้าย:
วิธีสุดท้ายไม่สามารถแทนที่ได้ ซึ่งหมายความว่าแม้ว่าคลาสย่อยจะสามารถเรียกใช้เมธอดสุดท้ายของคลาสพาเรนต์ได้โดยไม่มีปัญหาใดๆ แต่ก็ไม่สามารถแทนที่ได้
ตัวอย่าง:
/** * วิธีการสุดท้าย */คลาส XYZ { การสาธิตโมฆะขั้นสุดท้าย () { System.out.println ("วิธีคลาส XYZ");
-
} คลาส ABC ขยาย XYZ { void demo() { System.out.println("ABC Class Method");
} โมฆะสาธารณะคงที่ main (String args []) { ABC obj = ABC ใหม่ (); obj.สาธิต();
-
-↥ กลับไปด้านบน
ถ้าชนิดดั้งเดิมหรือสตริงถูกกำหนดให้เป็นค่าคงที่และทราบค่า ณ เวลาคอมไพล์ คอมไพเลอร์จะแทนที่ชื่อค่าคงที่ทุกที่ในโค้ดด้วยค่าของมัน สิ่งนี้เรียกว่าค่าคงที่เวลาคอมไพล์
ค่าคงที่เวลาคอมไพล์ต้องเป็น:
ประกาศเป็นที่สิ้นสุด
ดั้งเดิมหรือสตริง
เริ่มต้นภายในการประกาศ
เริ่มต้นด้วยการแสดงออกคงที่
พวกเขาจะถูกแทนที่ด้วยค่าจริงในเวลาคอมไพล์เนื่องจากคอมไพเลอร์รู้ค่าของมันล่วงหน้าและยังรู้ว่าไม่สามารถเปลี่ยนแปลงได้ในระหว่างรันไทม์
int สุดท้ายส่วนตัว x = 10;
↥ กลับไปด้านบน
ตัวระบุ/ตัวแก้ไขการเข้าถึงช่วยจำกัดขอบเขตของคลาส ตัวสร้าง ตัวแปร เมธอด หรือสมาชิกข้อมูล
มีตัวดัดแปลงการเข้าถึงสี่ประเภทที่มีอยู่ใน java:
default – ไม่ต้องใช้คีย์เวิร์ด เมื่อมีการประกาศคลาส ตัวสร้าง ตัวแปร วิธีการ หรือสมาชิกข้อมูลโดยไม่มีตัวระบุการเข้าถึง แสดงว่าจะมีขอบเขตการเข้าถึงเริ่มต้น กล่าวคือ สามารถเข้าถึงได้ภายในแพ็คเกจเดียวกันเท่านั้น
private - เมื่อประกาศเป็นส่วนตัว ขอบเขตการเข้าถึงจะถูกจำกัดภายในคลาสที่ปิดล้อม
protected - เมื่อประกาศเป็น protocted ขอบเขตการเข้าถึงจะถูกจำกัดเฉพาะคลาสที่ล้อมรอบ คลาสย่อยจากแพ็คเกจเดียวกัน รวมถึงแพ็คเกจอื่น ๆ
public - เมื่อประกาศเป็นสาธารณะ สามารถเข้าถึงได้ทุกที่ในโปรแกรม
... /* ตัวแปรสมาชิกข้อมูล */ String firstName="Pradeep"; /* ขอบเขตเริ่มต้น */ ป้องกัน isValid=true; /* ขอบเขตที่ได้รับการป้องกัน */ สตริงส่วนตัว otp = "AB0392"; /* ขอบเขตส่วนตัว */ public int id = 12334; /* ขอบเขตสาธารณะ */
-
... /* ฟังก์ชั่นสมาชิกข้อมูล */ String getFirstName(){ return this.firstName; } /* ขอบเขตเริ่มต้น */ ป้องกันบูลีน getStatus(){this.isValid;} /* ขอบเขตที่ได้รับการป้องกัน */ โมฆะส่วนตัว GenerateOtp(){ /* ขอบเขตส่วนตัว */ this.otp = this.hashCode() << 16;
-
สาธารณะ int getId(){ กลับ this.id; } /* ขอบเขตสาธารณะ */
-
.../* คลาสภายใน */ คลาส A{} /* ขอบเขตเริ่มต้น */ คลาสที่ได้รับการป้องกัน B{} /* ขอบเขตที่ได้รับการป้องกัน */ คลาสส่วนตัว C{} /* ขอบเขตส่วนตัว */ คลาสสาธารณะ D{} /* ขอบเขตสาธารณะ */
-↥ กลับไปด้านบน
ใน Java วิธีการที่ไม่คงที่ทั้งหมดจะเป็น ฟังก์ชันเสมือน เริ่มต้น เฉพาะวิธีการที่ทำเครื่องหมายด้วยคีย์เวิร์ด final ซึ่งไม่สามารถเขียนทับได้ รวมถึง private methods ซึ่งไม่ได้รับการสืบทอดมาเท่านั้นจึงจะไม่ใช่แบบเสมือน
ตัวอย่าง: ฟังก์ชันเสมือนพร้อมอินเทอร์เฟซ
/** * ฟังก์ชัน ApplyBrakes() เป็นแบบเสมือนเนื่องจาก * ฟังก์ชันในอินเทอร์เฟซได้รับการออกแบบให้เขียนทับได้ **/interface Bicycle { เป็นโมฆะ ApplyBrakes ();
}คลาส ACMEBicycle ใช้จักรยาน { โมฆะสาธารณะ ApplyBrakes() { // ที่นี่เราใช้ ApplyBrakes() System.out.println("ใช้เบรก"); // การทำงาน
-
-↥ กลับไปด้านบน
วิธีการเนทิฟคือวิธี Java (ไม่ว่าจะเป็นวิธีอินสแตนซ์หรือวิธีคลาส) ซึ่งการนำไปใช้งานนั้นเขียนด้วยภาษาโปรแกรมอื่นเช่น C/C++ นอกจากนี้ วิธีการที่ทำเครื่องหมายเป็นเนทีฟไม่สามารถมีเนื้อหาได้ และควรลงท้ายด้วยเครื่องหมายอัฒภาค:
Main.java:
คลาสสาธารณะ Main { สาธารณะ int intMethod (int i); โมฆะคงสาธารณะ main (String [] args) { System.loadLibrary ("Main"); System.out.println(หลักใหม่().intMethod(2));
-
-Main.c:
#include <jni.h>#include "Main.h"JNIEXPORT jint JNICALL Java_Main_intMethod( JNIEnv *env, jobject obj, jint i) { return i * i;
-คอมไพล์และรัน:
javac Main.javajavah -jni Maingcc -shared -fpic -o libMain.so -I${JAVA_HOME}/รวม
-I${JAVA_HOME}/include/linux Main.cjava -Djava.library.path= หลักเอาท์พุต
4
↥ กลับไปด้านบน
ถ้าเมธอดถูกประกาศเป็นแบบคงที่ แสดงว่ามันเป็นสมาชิกของคลาสแทนที่จะเป็นของอ็อบเจ็กต์ของคลาส สามารถเรียกได้โดยไม่ต้องสร้างวัตถุของชั้นเรียน วิธีการแบบคงที่ยังมีอำนาจในการเข้าถึงสมาชิกข้อมูลแบบคงที่ของชั้นเรียน
มีข้อจำกัดบางประการในวิธีการแบบคงที่
วิธีการแบบคงที่ไม่สามารถใช้สมาชิกข้อมูลที่ไม่คงที่หรือเรียกใช้วิธีการที่ไม่คงที่โดยตรง
this และ super ไม่สามารถใช้ในบริบทคงที่ได้
วิธีการคงที่สามารถเข้าถึงเฉพาะข้อมูลประเภทคงที่ ( ตัวแปรอินสแตนซ์ประเภทคงที่ )
ไม่จำเป็นต้องสร้างวัตถุของคลาสเพื่อเรียกใช้เมธอดแบบคงที่
วิธีการคงที่ไม่สามารถแทนที่ในคลาสย่อยได้
ตัวอย่าง:
/** * วิธีการคงที่ */class Parent { การแสดงโมฆะแบบคงที่ () { System.out.println ("ซูเปอร์คลาส");
-
} ตัวอย่างคลาสสาธารณะขยายพาเรนต์ { void display() // พยายามแทนที่ display() { System.out.println("Sub class");
-
โมฆะคงที่สาธารณะ main (String [] args) {
ผู้ปกครอง obj = ตัวอย่างใหม่ ();
obj.display();
-
-สิ่งนี้สร้างข้อผิดพลาดเวลาคอมไพล์ ผลลัพธ์จะเป็นดังนี้ -
ตัวอย่าง.java:10: ข้อผิดพลาด: display() ในตัวอย่างไม่สามารถแทนที่ display() ใน Parentvoid display() // พยายามแทนที่ display()
^เมธอดที่ถูกแทนที่คือข้อผิดพลาด static1↥ กลับไปด้านบน
โครงสร้างและคุณสมบัติของการใช้นิพจน์แลมบ์ดาคืออะไร? lambda คือชุดคำสั่งที่สามารถแยกออกเป็นตัวแปรแยกกันได้ แล้วจึงเรียกใช้ซ้ำๆ ในที่ต่างๆ ของโปรแกรม
พื้นฐานของนิพจน์แลมบ์ดาคือ ตัวดำเนินการแลมบ์ดา ซึ่งแสดงถึงลูกศร -> โอเปอเรเตอร์นี้แบ่งนิพจน์ lambda ออกเป็นสองส่วน โดยด้านซ้ายประกอบด้วยรายการพารามิเตอร์นิพจน์ และด้านขวาแสดงถึงเนื้อความของนิพจน์ lambda ซึ่งเป็นที่ที่ดำเนินการทั้งหมด
นิพจน์แลมบ์ดาไม่ได้ถูกดำเนินการด้วยตัวเอง แต่เป็นการดำเนินการตามวิธีการที่กำหนดไว้ในส่วนต่อประสานการทำงาน สิ่งสำคัญคืออินเทอร์เฟซการทำงานควรมีเพียงวิธีเดียวเท่านั้นโดยไม่ต้องนำไปใช้
อินเตอร์เฟซที่ใช้งานได้ { int คำนวณ ( int x , int y );
} โมฆะสาธารณะคงหลัก (สตริง [] args) { การดำเนินการที่ดำเนินการได้ = (x, y) - > x + y;
ผลลัพธ์ int = การดำเนินการคำนวณ ( 10 , 20 ); System.out.println (ผลลัพธ์); // 30 }ในความเป็นจริง นิพจน์แลมบ์ดาเป็นรูปแบบชวเลขของคลาสที่ไม่ระบุชื่อภายในที่เคยใช้ใน Java
นิพจน์แลมบ์ดาการดำเนินการที่เลื่อนออกไป - ถูกกำหนดเพียงครั้งเดียวในที่เดียวของโปรแกรม จะถูกเรียกหากจำเป็น จำนวนครั้งเท่าใดก็ได้และในตำแหน่งใดก็ได้ของโปรแกรม
พารามิเตอร์ของนิพจน์แลมบ์ดา จะต้องสอดคล้องกับประเภทพารามิเตอร์ของวิธีอินเทอร์เฟซการทำงาน:
การดำเนินการ = ( int x, int y) - > x + y;// เมื่อเขียนนิพจน์แลมบ์ดาเองไม่อนุญาตให้ระบุประเภทพารามิเตอร์: (x, y) - > x + y;// หากวิธีการ ไม่ยอมรับพารามิเตอร์ใด ๆ จากนั้นเขียนวงเล็บว่างเช่น: () - > 30 + 20 ;// หากวิธีการยอมรับเพียงพารามิเตอร์เดียวก็สามารถละเว้นวงเล็บเหลี่ยมได้: n - > n * n;
นิพจน์แลมบ์ดาต่อท้ายไม่จำเป็นต้องส่งกลับค่าใดๆ
อินเตอร์เฟซที่พิมพ์ได้ { พิมพ์เป็นโมฆะ (สตริง s);
-
โมฆะคงสาธารณะหลัก (สตริง [] args) { เครื่องพิมพ์ที่พิมพ์ได้ = s -> System.out.println (s); printer.print("สวัสดีชาวโลก");
}// _ Block lambda - expressions_ ล้อมรอบด้วยเครื่องหมายปีกกา นิพจน์ lambda แบบโมดูลาร์สามารถใช้ภายในบล็อกที่ซ้อนกัน ลูป `ออกแบบคำสั่ง if ` ` switch ' สร้างตัวแปร และอื่นๆ ดี หากคุณบล็อกแลมบ์ดา - นิพจน์จะต้องส่งคืนค่า นิพจน์นั้นจะใช้ `คำสั่ง return คำสั่ง ' อย่างชัดเจน :Operationable operation = ( int x, int y) - > {
ถ้า (y == 0 ) { กลับ 0 ;
} อื่น { กลับ x / y;
-
-การส่งนิพจน์แลมบ์ดาเป็นพารามิเตอร์วิธีการ
สภาพอินเทอร์เฟซ { บูลีนเหมาะสม ( int n );
} ผลรวม int คงที่ส่วนตัว (ตัวเลข int [] เงื่อนไขเงื่อนไข) { ผลลัพธ์ int = 0 ; สำหรับ ( int i : ตัวเลข) { if (condition.isAppropriate(i)) { result + = i;
-
} ส่งคืนผลลัพธ์;
} โมฆะสาธารณะคงหลัก (สตริง [] args) { System.out.println (ผลรวม ( new int [] { 0 , 1 , 0 , 3 , 0 , 5 , 0 , 7 , 0 , 9 }, (n) - > n ! = 0 ));
-↥ กลับไปด้านบน
การเข้าถึงตัวแปรขอบเขตภายนอกจากนิพจน์แลมบ์ดานั้นคล้ายคลึงกับการเข้าถึงจากอ็อบเจ็กต์ที่ไม่ระบุชื่อมาก
ไม่เปลี่ยนรูป (ขั้นสุดท้ายอย่างมีประสิทธิภาพ - ไม่จำเป็นต้องทำเครื่องหมายว่าเป็นขั้นสุดท้าย) ตัวแปรท้องถิ่น
สาขาชั้นเรียน
ตัวแปรคงที่
วิธีการเริ่มต้นของอินเทอร์เฟซการทำงานที่นำมาใช้ไม่ได้รับอนุญาตให้เข้าถึงภายในนิพจน์แลมบ์ดา
↥ กลับไปด้านบน
หากวิธีการที่มีอยู่ในคลาสทำทุกอย่างที่จำเป็นแล้ว คุณสามารถใช้กลไกการอ้างอิงวิธีการ (การอ้างอิงวิธีการ) เพื่อส่งผ่านวิธีนี้โดยตรง ผลลัพธ์จะเหมือนกับในกรณีของการกำหนดนิพจน์แลมบ์ดาที่เรียกวิธีนี้ทุกประการ
ตัวอย่าง:
อินเทอร์เฟซส่วนตัวที่วัดได้ { ความยาว int สาธารณะ (สตริงสตริง);
} โมฆะสาธารณะคงหลัก (สตริง [] args) { วัดได้ = สตริง :: ความยาว; System.out.println(a.length("abc"));
-การอ้างอิงวิธีการอาจมีประสิทธิภาพมากกว่าการใช้นิพจน์แลมบ์ดา นอกจากนี้ ยังให้ข้อมูลประเภทที่ดีกว่าแก่คอมไพลเลอร์ และหากคุณสามารถเลือกระหว่างการใช้การอ้างอิงถึงวิธีการที่มีอยู่กับการใช้นิพจน์แลมบ์ดา คุณควรใช้การอ้างอิงวิธีการเสมอ
↥ กลับไปด้านบน
ด้วยวิธีคงที่
วิธีการต่ออินสแตนซ์;
ถึงผู้สร้าง
↥ กลับไปด้านบน
คลาสภายในที่ซ้อนกันสามารถเข้าถึงตัวแปรอินสแตนซ์ส่วนตัวของคลาสภายนอกได้ เช่นเดียวกับตัวแปรอินสแตนซ์อื่น ๆ เราสามารถมีตัวแก้ไขการเข้าถึงแบบส่วนตัว ได้รับการป้องกัน สาธารณะ และตัวแก้ไขเริ่มต้นได้
ตัวอย่าง:
/** * คลาสภายใน */คลาสภายนอก {
คลาสภายใน {
การแสดงโมฆะสาธารณะ () {
System.out.println("ในวิธีการเรียนแบบซ้อน");
-
-
-
คลาสหลัก {
โมฆะคงที่สาธารณะ main (String [] args) {
Outer.Inner ใน = ใหม่ Outer().new Inner();
ใน.show();
-
-คลาสย่อยคือคลาสที่สืบทอดวิธีการหรือวิธีการจากซูเปอร์คลาส
ตัวอย่าง:
/** * คลาสย่อย */คลาสรถยนต์ { //...}
คลาส HybridCar ขยายรถยนต์ { //...}↥ กลับไปด้านบน
1. การโหลดคลาสแบบคงที่:
การสร้างออบเจ็กต์และอินสแตนซ์โดยใช้คีย์เวิร์ด new เรียกว่าการโหลดคลาสแบบคงที่ การเรียกค้นคำจำกัดความของคลาสและการสร้างอินสแตนซ์ของอ็อบเจ็กต์เสร็จสิ้นในเวลาคอมไพล์
ตัวอย่าง:
/** * การโหลดคลาสแบบคงที่ */class TestClass { โมฆะคงที่สาธารณะ main (String args []) { TestClass tc = ใหม่ TestClass ();
-
-2. การโหลดคลาสแบบไดนามิก:
การโหลดคลาสใช้วิธี Class.forName() การโหลดคลาสแบบไดนามิกจะเสร็จสิ้นเมื่อไม่ทราบชื่อของคลาสในขณะคอมไพล์
ตัวอย่าง:
/** * กำลังโหลดคลาสแบบไดนามิก */Class.forName (ชื่อคลาสสตริง);
↥ กลับไปด้านบน
1. คลาสรันไทม์:
คลาส java.lang.Runtime เป็นคลาสย่อยของคลาส Object ซึ่งให้การเข้าถึงระบบรันไทม์ Java ข้อมูลรันไทม์ เช่น ความพร้อมใช้งานของหน่วยความจำ การเรียกใช้ตัวรวบรวมขยะ ฯลฯ
ตัวอย่าง:
/** * Runtime Class */public class RuntimeTest { ข้อความคลาสคงที่ขยายเธรด { public void run() { System.out.println(" Exit");
-
} โมฆะสาธารณะคงที่ main(String[] args) { ลอง { Runtime.getRuntime().addShutdownHook(ข้อความใหม่()); System.out.println(" โปรแกรมเริ่มต้น..."); System.out.println("รอ 5 วินาที..."); เธรด.สลีป(5000); System.out.println(" โปรแกรมสิ้นสุด...");
} catch (ข้อยกเว้น e) { e.printStackTrace();
-
-
-2. คลาสระบบ:
วัตถุประสงค์ของคลาสระบบคือการให้การเข้าถึงทรัพยากรระบบ มันมีการเข้าถึงข้อมูลอินพุตมาตรฐาน, เอาต์พุตแบบสแตนด์อร์, สตรีมเอาต์พุตข้อผิดพลาด, เวลาปัจจุบันเป็นมิลลิส, การยกเลิกแอปพลิเคชัน ฯลฯ
↥กลับไปด้านบน
1. การใช้คำหลักใหม่:
myObject object = new myObject ();
2. ใช้ class.forname ():
myObject object = (myObject) class.forName ("subin.rnd.myobject"). newInstance ();3. ใช้โคลน ():
myObject otherObject = new myObject (); myObject object = (myObject) otherObject.clone ();
4. การใช้วัตถุ deserialization:
ObjectInputStream Instream = ใหม่ ObjectInputStream (AninputStream); myObject object = (myObject) instream.readObject ();
↥กลับไปด้านบน
วัตถุที่ไม่เปลี่ยนรูปเป็นวัตถุที่ไม่เปลี่ยนแปลง วัตถุ Java ที่ไม่เปลี่ยนรูปต้องมีเขตข้อมูลทั้งหมดอยู่ภายในเขตข้อมูลสุดท้ายส่วนตัว จะต้องไม่ใช้ตัวตั้งตัวใด ๆ มันต้องการตัวสร้างที่ใช้ค่าสำหรับทุกฟิลด์
การสร้างวัตถุที่ไม่เปลี่ยนรูป:
อย่าเพิ่มวิธีการติดตั้งใด ๆ
ประกาศทั้งหมดฟิลด์สุดท้ายและภาคเอกชน
หากฟิลด์เป็นวัตถุที่ไม่แน่นอนสร้างสำเนาป้องกันของมันสำหรับวิธีการ getter
หากวัตถุที่ไม่แน่นอนส่งผ่านไปยังคอนสตรัคเตอร์จะต้องกำหนดให้กับฟิลด์สร้างสำเนาป้องกันของมัน
อย่าอนุญาตให้คลาสย่อยเพื่อแทนที่วิธีการ
/** * วัตถุที่ไม่เปลี่ยนรูป */คลาสสาธารณะ Datecontainer {วันที่สุดท้ายของเอกชนวันที่; Public DateContainer () {this.date = new Date ();
} วันที่สาธารณะ getDate () {ส่งคืนวันที่ใหม่ (date.getTime ());
-
-↥กลับไปด้านบน
คลาสที่ไม่เปลี่ยนรูปหมายความว่าเมื่อสร้างวัตถุเราไม่สามารถเปลี่ยนเนื้อหาได้ ใน Java คลาส wrapper ทั้งหมด (เช่น Integer, Boolean, Byte, Short) และ String Class นั้นไม่สามารถเปลี่ยนแปลงได้
กฎในการสร้างคลาสที่ไม่เปลี่ยนรูป:
ชั้นเรียนจะต้องประกาศเป็นขั้นสุดท้าย
สมาชิกข้อมูลในชั้นเรียนจะต้องประกาศเป็นขั้นสุดท้าย
ตัวสร้างพารามิเตอร์
วิธี getter สำหรับตัวแปรทั้งหมดในนั้น
ไม่มีตัวตั้ง
/** * คลาสที่ไม่เปลี่ยนรูป */พนักงานชั้นสุดท้ายสาธารณะ {สตริงสุดท้าย pancardnumber; พนักงานสาธารณะ (String PancardNumber) {this.pancardNumber = PancardNumber;
} สตริงสาธารณะ getPanCardNumber () {return pancardNumber;
-
-↥กลับไปด้านบน
Bootstrap classloader นั้นไม่สามารถใช้งานได้สำหรับการโหลดไฟล์คลาส JDK มาตรฐานจาก RT.JAR และเป็นพาเรนต์ของรถตักทั้งหมดใน Java คลาสโหลดในตัวใน Java มีสามประเภท:
1. bootstrap คลาสโหลดเดอร์: มันโหลดคลาสภายใน JDK โดยทั่วไปจะโหลด rt.jar และคลาสแกนอื่น ๆ เช่น java.lang.* คลาสแพ็คเกจ
2. ตัวโหลดคลาสส่วนขยาย: โหลดคลาสจากไดเรกทอรีส่วนขยาย JDK มักจะเป็น $ JAVA_HOME/LIB/EXT DIRECTORY
3. ระบบตัวโหลดคลาสของระบบ: โหลดคลาสจาก ClassPath ปัจจุบันที่สามารถตั้งค่าได้ในขณะที่เรียกใช้โปรแกรมโดยใช้ตัวเลือกบรรทัดคำสั่ง -CP หรือ -classPath
/** * classloader */นำเข้า java.util.logging.level; นำเข้า java.util.logging.logger; คลาสสาธารณะคลาสโหลดได้รับ {โมฆะสาธารณะคง .out.println ("classloader:" + classloaderTest.class.getClassLoader ()); // พยายามโหลดคลาสนี้อย่างชัดเจนอีกครั้งโดยใช้คลาส Extension class loader.forName ("คลาสโหลดอย่างชัดเจน", true, classloaderTest.class.getClassLoader (). getParent ());
} catch (classnotFoundException ex) {logger.getLogger (classloaderTest.class.getName ()). log (level.severe, null, ex);
-
-
-↥กลับไปด้านบน
วิธีต่าง ๆ ในการสร้างวัตถุใน Java
การใช้คำหลักใหม่:
คลาส ObjectCreationExample {เจ้าของสตริง;
} คลาสสาธารณะ MainClass {โมฆะสาธารณะคงที่หลัก (สตริง [] args) {// ที่นี่เรากำลังสร้างวัตถุของ JBT โดยใช้ keywordObjectCreationExample OBJ = ใหม่ ObjectCreationExample ();
-
-ใช้อินสแตนซ์ใหม่ (สะท้อน)
คลาส createObjectClass {int คงที่ j = 10; createObjectClass () {i = j ++;
} int i; @Overridepublic String toString () {return "ค่าของ i:" + i;
-
} คลาส MainClass {public Static Void Main (String [] args) {ลอง {class cls = class.forName ("createObjectClass"); CreateObjectClass obj = (createObjectClass) cls.newinstance (); createObjectClass obj1 = (createObjectClass) Cls.NewInstance (); System.out.println (OBJ); System.out.println (OBJ1);
} catch (classnotFoundException e) {e.printStackTrace ();
} catch (InstantiationException E) {E.printStackTrace ();
} catch (unglegalAccessException e) {e.printStackTrace ();
-
-
-ใช้โคลน:
คลาส createObjectWithClone ใช้ cloneable {@OverrideProtected object clone () พ่น clonenotsupportException {return super.clone ();
} int i; int คงที่ j = 10; createObjectWithClone () {i = j ++;
} @Overridepublic String toString () {return "ค่าของ i:" + i;
-
} คลาส MainClass {public Static Void Main (String [] args) {createObjectWithClone OBJ1 = ใหม่ createObjectWithClone (); system.out.println (obj1); ลอง {createObjectWithClone obj2 = (createObjectWithClone) obj1.clone () println (obj2);
} catch (clonenotsupportedException e) {e.printStackTrace ();
-
-
-ใช้ classloader
คลาส createObjectWithClassLoader {Static int J = 10; createObjectWithClassLoader () {i = j ++;
} int i; @Overridepublic String toString () {return "ค่าของ i:" + i;
-
} คลาสสาธารณะ MainClass {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {createObjectWithClassLoader obj = null; ลอง {obj = (createObjectWithClassLoader) ใหม่ MainClass (). getClass ()
.getClassLoader (). loadclass ("createObjectWithClassLoader"). newInstance (); // ควรใช้ชื่อคลาสที่ผ่านการรับรองอย่างเต็มที่
} catch (InstantiationException E) {E.printStackTrace ();
} catch (unglegalAccessException e) {e.printStackTrace ();
} catch (classnotFoundException e) {e.printStackTrace ();
} system.out.println (obj);
-
-↥กลับไปด้านบน
คลาส Object เป็นคลาสหลักของคลาสทั้งหมดใน Java โดยค่าเริ่มต้น
| วิธี | คำอธิบาย |
|---|---|
| ชั้นเรียนสุดท้ายของสาธารณะ getClass () | ส่งคืนวัตถุคลาสคลาสของวัตถุนี้ ชั้นเรียนสามารถใช้เพิ่มเติมเพื่อให้ได้ข้อมูลเมตาของคลาสนี้ |
| hashcode int สาธารณะ () | ส่งคืนหมายเลข HashCode สำหรับวัตถุนี้ |
| บูลีนสาธารณะเท่ากับ (Object OBJ) | เปรียบเทียบวัตถุที่กำหนดกับวัตถุนี้ |
| object clone () phrows clonenotsupportedexception | สร้างและส่งคืนสำเนาที่แน่นอน (โคลน) ของวัตถุนี้ |
| สตริงสาธารณะ toString () | ส่งคืนการแสดงสตริงของวัตถุนี้ |
| โมฆะสุดท้ายสาธารณะแจ้งเตือน () | ตื่นขึ้นมาเธรดเดี่ยวรออยู่ที่จอภาพของวัตถุนี้ |
| โมฆะสุดท้ายสาธารณะแจ้งเตือน () | ปลุกเธรดทั้งหมดรออยู่บนจอภาพของวัตถุนี้ |
| การรอคอยสุดท้าย | ทำให้เธรดปัจจุบันรอมิลลิวินาทีที่ระบุจนกว่าเธรดอื่นจะแจ้งเตือน (เรียกใช้วิธีการแจ้งเตือน () หรือ notifyall ()) |
| Void Void สุดท้าย Public (Long หมดเวลา, Int Nanos) พ่น InterruptedException | ทำให้เธรดปัจจุบันรอมิลลิวินาทีที่ระบุและนาโนวินาทีจนกระทั่งเธรดอื่นแจ้ง (เรียกใช้วิธีการแจ้งเตือน () หรือ notifyall ()) |
| Void สุดท้าย Wait () พ่น InterruptedException | ทำให้เธรดปัจจุบันรอจนกว่าเธรดอื่นจะแจ้งเตือน (เรียกใช้วิธีการแจ้งเตือน () หรือ notifyall ()) |
| ช่องว่างที่ได้รับการป้องกันสรุป () โยนได้ | ถูกเรียกใช้โดยนักสะสมขยะก่อนที่วัตถุจะถูกเก็บรวบรวมขยะ |
↥กลับไปด้านบน
Optional ที่เป็นทางเลือกคือคอนเทนเนอร์สำหรับวัตถุที่อาจมีหรือไม่มีค่า null เสื้อคลุมดังกล่าวเป็นวิธีการป้องกันที่สะดวก
