1. วิธี Equals ใช้เพื่อเปรียบเทียบว่าเนื้อหาของวัตถุมีค่าเท่ากันหรือไม่ (แทนที่ในภายหลัง)
2. วิธี HashCode ใช้ในคอลเลกชันเท่านั้น
3. เมื่อวิธีการที่ Equals ถูกเขียนทับไม่ว่าวัตถุเปรียบเทียบจะเท่ากันจะถูกนำมาเปรียบเทียบผ่านวิธีการที่ถูกเขียนทับเท่ากับหรือไม่ (ตัดสินว่าเนื้อหาของวัตถุมีค่าเท่ากันหรือไม่)
4. เมื่อใส่วัตถุลงในคอลเลกชันก่อนอื่นให้พิจารณาว่าค่า HashCode ของวัตถุที่จะวางไว้จะเท่ากับค่า HashCode ขององค์ประกอบใด ๆ ในคอลเลกชันหรือไม่ หากไม่เท่ากันให้ใส่วัตถุลงในคอลเลกชันโดยตรง หากค่า hashcode เท่ากันให้ใช้วิธี Equals เพื่อตรวจสอบว่าวัตถุที่จะวางจะเท่ากับวัตถุใด ๆ ในการรวบรวมหรือไม่ หากการตัดสินเท่ากับไม่เท่ากันให้ใส่องค์ประกอบลงในคอลเลกชันโดยตรงมิฉะนั้นจะไม่ถูกวางไว้
5. วิธี Equals ใช้ไม่ว่าที่อยู่หน่วยความจำของวัตถุจะเท่ากับเพื่อพิจารณาว่าวัตถุนั้นเท่ากันหรือไม่
เนื่องจากเป็นวัตถุใหม่สองชิ้นที่อยู่หน่วยความจำของวัตถุไม่เท่ากันดังนั้น STU1.Equals (STU2) จึงเป็นเท็จ
6. เธรด A และ B ทั้งคู่จะต้องได้รับการล็อคของวัตถุ O. โดยสมมติว่าการล็อคของวัตถุ O, B จะรอให้ A เพื่อปล่อยล็อคของ O. หากใช้การซิงโครไนซ์หาก A ไม่ปล่อย B จะรอให้มันดำเนินการต่อและไม่สามารถขัดจังหวะได้ หากใช้ reentrantlock หาก A ไม่ปล่อย B สามารถขัดจังหวะการรอคอยหลังจากรอเวลานานพอและทำสิ่งอื่น ๆ
Reentrantlock ได้รับล็อคในสามวิธี:
a) ล็อค () หากได้มาซึ่งล็อคจะกลับมาทันที หากเธรดอื่นถือล็อคเธรดปัจจุบันจะยังคงอยู่ในสถานะที่อยู่เฉยๆจนกว่าจะได้รับการล็อค
b) trylock () หากได้รับล็อคมันจะส่งคืนจริงทันทีและหากเธรดอื่นถือล็อคมันจะส่งคืนเท็จทันที;
c) Trylock (Long Timeout, TimeUnit Unit) หากได้รับการล็อคมันจะกลับมาจริงทันที หากเธรดอื่นถือล็อคมันจะรอเวลาที่กำหนดของพารามิเตอร์
ในระหว่างกระบวนการรอหากการล็อคได้รับมันจะกลับมาจริงและหากหมดเวลารอมันจะส่งกลับเท็จ
d) ล็อคอย่างต่อเนื่อง: หากได้รับล็อคให้กลับมาทันที หากไม่ได้รับการล็อคเธรดปัจจุบันจะอยู่ในสถานะที่อยู่เฉยๆจนกระทั่งหรือล็อค
หรือเธรดปัจจุบันถูกขัดจังหวะโดยเธรดอื่น
ซิงโครไนซ์ถูกนำไปใช้ในระดับ JVM ไม่เพียง แต่สามารถตรวจสอบล็อคที่ซิงโครไนซ์ผ่านเครื่องมือตรวจสอบบางอย่างเท่านั้น แต่ยังสามารถเกิดข้อยกเว้นได้ในระหว่างการดำเนินการรหัส
JVM จะปล่อยล็อคโดยอัตโนมัติ แต่ไม่สามารถใช้ล็อคได้ ล็อคถูกนำไปใช้ผ่านรหัส เพื่อให้แน่ใจว่าล็อคจะถูกปล่อยออกมาปลดล็อค () จะต้องวางไว้ในที่สุด {}
เมื่อการแข่งขันทรัพยากรไม่รุนแรงมากประสิทธิภาพของการซิงโครไนซ์นั้นดีกว่าของ reetrantlock อย่างไรก็ตามเมื่อการแข่งขันทรัพยากรรุนแรงมากประสิทธิภาพของการซิงโครไนซ์จะลดลงหลายสิบครั้ง แต่ประสิทธิภาพของ reetrantlock ยังคงเป็นปกติ
ใน JDK คลาสต่อไปนี้ส่วนใหญ่จะใช้เพื่อใช้กลไกการสะท้อน Java ซึ่งทั้งหมดอยู่ในแพ็คเกจ java.lang.reflect:
คลาส: หมายถึงคลาส
คลาสฟิลด์: ตัวแปรสมาชิกที่เป็นตัวแทนของคลาส (ตัวแปรสมาชิกเรียกอีกอย่างว่าคุณลักษณะของคลาส)
เมธอดคลาส: วิธีที่แสดงถึงคลาส
คลาส Constructor: แสดงถึงวิธีการสร้างของคลาส
คลาสอาร์เรย์: ให้วิธีการคงที่สำหรับการสร้างอาร์เรย์แบบไดนามิกและการเข้าถึงองค์ประกอบของอาร์เรย์
นี่คือตัวอย่างเล็ก ๆ น้อย ๆ เพื่อดูแอปพลิเคชันจริงของการสะท้อน API:
1. รับตัวแปรสมาชิก, วิธีการสมาชิก, อินเทอร์เฟซ, superclasses, วิธีการสร้าง ฯลฯ ผ่านชั้นเรียน
วิธี getClass () ถูกกำหนดไว้ในคลาส java.lang.Object ดังนั้นสำหรับวัตถุ Java ใด ๆ ประเภทวัตถุสามารถรับได้ด้วยวิธีนี้ คลาสคลาสเป็นคลาสหลักในการสะท้อน API และมีวิธีการต่อไปนี้
getName (): รับชื่อเต็มของชั้นเรียน
getFields (): รับทรัพย์สินของประเภทสาธารณะของชั้นเรียน
GetDeclaredFields (): รับคุณสมบัติทั้งหมดของชั้นเรียน
getMethods (): วิธีการรับประเภทสาธารณะของชั้นเรียน
getDeclaredMethods (): รับวิธีการทั้งหมดของชั้นเรียน
getMethod (ชื่อสตริง, คลาส [] พารามิเตอร์ TYPES): รับวิธีเฉพาะของคลาสพารามิเตอร์ชื่อระบุชื่อของวิธีพารามิเตอร์พารามิเตอร์พารามิเตอร์ระบุประเภทพารามิเตอร์ของวิธี
GetConstructors (): รับตัวสร้างประเภทสาธารณะของชั้นเรียน
GetConstructor (parameterTypes): รับตัวสร้างเฉพาะของคลาส พารามิเตอร์พารามิเตอร์ระบุประเภทพารามิเตอร์ของตัวสร้าง
Newinstance (): สร้างวัตถุของคลาสนี้ผ่านตัวสร้างคลาสของคลาสโดยไม่มีพารามิเตอร์
ขั้นตอนในการเขียนตัวสะท้อนแสง Java:
1) คุณต้องได้รับวัตถุคลาสของคลาสก่อน
ตัวอย่างเช่น:
คลาส C1 = test.class; คลาส c2 = class.forname ("com.reflection.test"); คลาส C3 = การทดสอบใหม่ (). getClass (); 2) จากนั้นเรียกใช้วิธีการในวัตถุคลาสแยกกันเพื่อรับคุณสมบัติ/วิธีการ/ตัวสร้างของคลาส
หมายเหตุ: หากคุณต้องการรับวิธีการ/คุณสมบัติ/ตัวสร้างในชั้นเรียนตามปกติคุณควรมุ่งเน้นไปที่คลาสการสะท้อนต่อไปนี้
สนาม
ตัวสร้าง
วิธี
<servlet-mapping> <servlet-name> </servlet-name> <url-pattern> </url-pattern> </servlet-mapping> สำหรับ (string elementa: str) {system.out.print (elementa + ""); } รายการ <String> list = new ArrayList <String> (); สำหรับ (int i = 0; i <str.length; i ++) {ถ้า (! list.contains (str [i])) {list.add (str [i]); }} ตั้งค่า <string> set = new hashset <string> (); สำหรับ (int i = 0; i <str.length; i ++) {set.add (str [i]); -ฤดูใบไม้ผลิมีหกธุรกรรมและห้าระดับการแยก
หมวดที่ 1: Inte Short Int ยาว
หมวดที่ 2: ลอยสองเท่า
หมวดที่สาม: บูลีนโลจิคัล (มีเพียงสองค่าที่ถือได้ว่าเป็นเท็จจริง)
หมวดที่ 4: ตัวละครตัวละคร
วิธีการในคลาสการปรับเปลี่ยนขั้นสุดท้าย
ฟังก์ชั่น: สามารถสืบทอดได้ แต่ไม่สามารถเขียนใหม่ได้หลังจากการสืบทอด
คลาสการปรับเปลี่ยนขั้นสุดท้าย
ฟังก์ชั่น: คลาสไม่สามารถสืบทอดได้
เมื่อแก้ไขประเภทขั้นสุดท้ายค่าพื้นฐานจะไม่เปลี่ยนแปลง ประเภทการอ้างอิงระบุว่าที่อยู่ยังคงไม่เปลี่ยนแปลง นั่นคือเมื่อใหม่ที่อยู่ไม่สามารถกำหนดใหม่ได้
คุณรู้ว่าแอตทริบิวต์การปรับเปลี่ยนขั้นสุดท้าย
Preparestatement ถูกคอมไพล์ไว้ล่วงหน้า ก่อนอื่นส่ง SQL ไปยังฐานข้อมูลสำหรับการประมวลผลล่วงหน้าแล้วใส่ลงในแคช ครั้งต่อไปที่คุณพบว่ามีเหมือนกันคุณไม่จำเป็นต้องรวบรวมมัน ประสิทธิภาพการดำเนินการอยู่ในระดับสูงมีการแจ้งเตือนทางไวยากรณ์เพื่ออำนวยความสะดวกในการตรวจสอบและพารามิเตอร์เป็นแบบไดนามิกป้องกันการฉีด SQL เนื่องจากการตรวจสอบไวยากรณ์
เลือก * จาก tbname = 'zck' และ passwd = 'หรือ' 1 '=' 1 ';
คำสั่งไม่ได้คอมไพล์ล่วงหน้าและต้องมีการตรวจสอบด้วยตนเองสำหรับข้อผิดพลาดทางไวยากรณ์ซึ่งเป็น hardcoded
HashMap อนุญาตให้ NULL เป็นคีย์หรือค่าของรายการในขณะที่ Hashtable ไม่ได้
ใส่วิธีการ
HashMap จะดำเนินการประมวลผลพิเศษบนคีย์ค่า NULL วางไว้ในตำแหน่ง [0] เสมอ วางกระบวนการคือการคำนวณแฮชก่อนจากนั้นคำนวณค่าดัชนีผ่านแฮชและตารางความยาวจากนั้นใส่คีย์ที่ตำแหน่งตาราง [ดัชนี] เมื่อองค์ประกอบอื่นมีอยู่แล้วในตาราง [ดัชนี] รายการที่เชื่อมโยงจะถูกสร้างขึ้นที่ตำแหน่งตาราง [ดัชนี] และองค์ประกอบที่เพิ่มใหม่จะถูกวางไว้ในตาราง [ดัชนี] และองค์ประกอบดั้งเดิมจะเชื่อมโยงผ่านรายการถัดไป ด้วยวิธีนี้ปัญหาความขัดแย้งแฮชได้รับการแก้ไขในรูปแบบของรายการที่เชื่อมโยง เมื่อจำนวนองค์ประกอบถึงค่าวิกฤต (capactiy*ปัจจัย) ความจุจะขยายและความยาวของอาร์เรย์ตารางจะกลายเป็นตารางความยาว*2
รับวิธีการ
ในทำนองเดียวกันเมื่อคีย์เป็น NULL การประมวลผลพิเศษจะดำเนินการและองค์ประกอบที่มีคีย์คือ null จะพบในรายการที่เชื่อมโยงของตาราง [0]
กระบวนการของการรับคือการคำนวณแฮชก่อนจากนั้นคำนวณค่าดัชนีผ่านแฮชและตารางความยาวจากนั้นวนซ้ำผ่านรายการที่เชื่อมโยงบนตาราง [ดัชนี] จนกว่าจะพบคีย์จากนั้นส่งคืนการใช้งาน Hashmap และแฮชเทบิ ดัชนีซึ่งเป็นตัวห้อยของอาร์เรย์ตารางคำนวณตามแฮชและตารางความยาวคำนวณและดำเนินการดำเนินการที่สอดคล้องกัน
ดัชนีส่วนใหญ่ขึ้นอยู่กับ B-Tree
ปัญหาด้านความปลอดภัยของเธรด Servlet ส่วนใหญ่เกิดจากตัวแปรอินสแตนซ์ดังนั้นควรหลีกเลี่ยงตัวแปรอินสแตนซ์ใน Servlets
หากการออกแบบแอปพลิเคชันไม่สามารถหลีกเลี่ยงการใช้ตัวแปรอินสแตนซ์การซิงโครไนซ์จะใช้เพื่อป้องกันตัวแปรอินสแตนซ์ที่จะใช้ แต่สำหรับประสิทธิภาพของระบบที่ดีที่สุดเส้นทางรหัสที่มีความพร้อมใช้งานน้อยที่สุดควรซิงโครไนซ์
เขียนรูปแบบซิงเกิลตัน
สาธารณะแบบคงที่แบบคงที่ (int n) {ถ้า (n <= 0) return 0; ถ้า (n == 1) return 1; return recursive (n - 1) + recursive (n - 2);} ลูปยาวคงที่สาธารณะ (int n) {ถ้า (n <= 0) return 0; ถ้า (n == 1) i ++) {sum = fib1+fib2; fib1 = fib2; fib2 = sum;} return sum;} Hashtable เป็นคลาส Thread-Safe มันใช้การซิงโครไนซ์เพื่อล็อคตารางแฮชทั้งหมดเพื่อให้ได้ความปลอดภัยของเธรดนั่นคือล็อคตารางทั้งหมดทุกครั้งและปล่อยให้เธรดครอบครอง ConcurrentHashMap อนุญาตให้ดำเนินการปรับเปลี่ยนหลายครั้งพร้อมกันและคีย์คือการใช้เทคโนโลยีการแยกล็อค มันใช้ล็อคหลายตัวเพื่อควบคุมการปรับเปลี่ยนไปยังส่วนต่าง ๆ ของตารางแฮช
ConcurrentHashMap ใช้เซ็กเมนต์ (เซ็กเมนต์) เพื่อแสดงส่วนต่าง ๆ เหล่านี้ แต่ละเซ็กเมนต์นั้นเป็นแฮชต์ขนาดเล็กและพวกเขามีล็อคของตัวเอง ตราบใดที่การดำเนินการดัดแปลงหลายครั้งเกิดขึ้นในส่วนต่าง ๆ พวกเขาสามารถดำเนินการได้พร้อมกัน
บางวิธีต้องข้ามเซ็กเมนต์เช่นขนาด () และ containSvalue () พวกเขาอาจต้องล็อคตารางทั้งหมดแทนที่จะเป็นเพียงส่วนที่แน่นอน สิ่งนี้ต้องล็อคทุกกลุ่มตามลำดับ หลังจากการดำเนินการเสร็จสมบูรณ์ล็อคของทุกส่วนจะถูกปล่อยออกมาตามลำดับ "คำสั่ง" มีความสำคัญมากที่นี่ไม่เช่นนั้นมีความเป็นไปได้สูงที่จะหยุดชะงัก ใน ConcurrentHashMap อาร์เรย์เซ็กเมนต์ถือเป็นที่สิ้นสุดและตัวแปรสมาชิกเป็นที่สิ้นสุดจริง อย่างไรก็ตามเพียงแค่ประกาศอาร์เรย์เป็นขั้นสุดท้ายไม่รับประกันว่าสมาชิกอาเรย์เป็นที่สิ้นสุดซึ่งต้องมีการรับประกันการดำเนินการ
สิ่งนี้ทำให้มั่นใจได้ว่าไม่มีการหยุดชะงักเนื่องจากคำสั่งที่ได้รับการล็อคได้รับการแก้ไข
① Threadlocal ②ซิงโครไนซ์ () ③รอ () และแจ้งเตือน () ④ผันผวน
ด้าย
ThreadLocal ทำให้มั่นใจได้ว่าเธรดที่แตกต่างกันมีอินสแตนซ์ที่แตกต่างกันและเธรดเดียวกันจะต้องมีอินสแตนซ์เดียวกันนั่นคือแต่ละเธรดที่ใช้ตัวแปรจะให้สำเนาของค่าของตัวแปร แต่ละเธรดสามารถเปลี่ยนสำเนาของตัวเองได้อย่างอิสระแทนที่จะขัดแย้งกับสำเนาของเธรดอื่น ๆ
ข้อดี: จัดเตรียมวัตถุที่ใช้ร่วมกันอย่างปลอดภัย
ความแตกต่างจากกลไกการซิงโครไนซ์อื่น ๆ : กลไกการซิงโครไนซ์คือการซิงโครไนซ์การเข้าถึงทรัพยากรเดียวกันโดยหลายเธรดและเพื่อสื่อสารระหว่างหลายเธรด;
ThreadLocal เป็นการแชร์ข้อมูลที่แยกได้จากหลายเธรดและพื้นฐานไม่ได้แชร์ทรัพยากรระหว่างหลายเธรด สิ่งนี้ไม่จำเป็นต้องมีหลายเธรดที่จะซิงโครไนซ์
ระเหย
ตัวแปรสมาชิกที่ปรับเปลี่ยนได้จะถูกบังคับให้อ่านค่าของตัวแปรสมาชิกจากหน่วยความจำที่ใช้ร่วมกันในแต่ละครั้งที่มีการเข้าถึงโดยเธรด และ,
เมื่อตัวแปรสมาชิกเปลี่ยนแปลงเธรดจะถูกบังคับให้เขียนค่าการเปลี่ยนแปลงกลับไปเป็นหน่วยความจำที่ใช้ร่วมกัน
ข้อดี: ด้วยวิธีนี้เมื่อใดก็ตามที่สองเธรดที่แตกต่างกันจะเห็นค่าเดียวกันของตัวแปรสมาชิกบางตัวเสมอ
เหตุผล: ข้อกำหนดภาษา Java ระบุว่าเพื่อให้ได้ความเร็วที่ดีที่สุดเธรดได้รับอนุญาตให้บันทึกสำเนาส่วนตัวของตัวแปรสมาชิกที่ใช้ร่วมกัน
และเปรียบเทียบกับค่าดั้งเดิมของตัวแปรสมาชิกที่ใช้ร่วมกันเมื่อเธรดเข้าหรือออกจากบล็อกรหัสแบบซิงโครนัส
ด้วยวิธีนี้เมื่อหลายเธรดโต้ตอบกับวัตถุในเวลาเดียวกันจำเป็นต้องให้ความสนใจกับการอนุญาตให้เธรดได้รับการเปลี่ยนแปลงในตัวแปรสมาชิกที่ใช้ร่วมกันในเวลาที่เหมาะสม
คำหลักที่ผันผวนจะแจ้งให้ VM: สำหรับตัวแปรสมาชิกนี้ไม่สามารถบันทึกสำเนาส่วนตัวได้ แต่ควรโต้ตอบโดยตรงกับตัวแปรสมาชิกที่ใช้ร่วมกัน
เคล็ดลับการใช้งาน: ใช้ความผันผวนกับตัวแปรสมาชิกที่เข้าถึงได้โดยสองเธรดขึ้นไป
ไม่จำเป็นต้องใช้เมื่อตัวแปรที่จะเข้าถึงมีอยู่แล้วในบล็อกรหัสที่ซิงโครไนซ์หรือเป็นค่าคงที่
เพื่อปรับปรุงประสิทธิภาพเธรดจะคัดลอกตัวแปรสมาชิก (เช่น A) (เช่น B) และการเข้าถึง A ในเธรดการเข้าถึง B. การซิงโครไนซ์ของ A และ B นั้นดำเนินการเฉพาะในการกระทำบางอย่างดังนั้นจึงมีสถานการณ์ที่ A และ B ไม่สอดคล้องกัน ความผันผวนใช้เพื่อหลีกเลี่ยงสถานการณ์นี้
ความผันผวนบอก JVM ว่าตัวแปรที่ปรับเปลี่ยนไม่เก็บสำเนาและเข้าถึงสำเนาโดยตรงในหน่วยความจำหลัก (เป็นการดีกว่าที่จะใช้เมื่อมีการอ่านจำนวนมากการสื่อสารจำเป็นต้องมีการสื่อสารระหว่างเธรด แต่บทความนี้ไม่สามารถทำได้)
ตัวแปรระเหยง่ายมีคุณสมบัติการมองเห็นแบบซิงโครไนซ์ แต่ไม่มีคุณสมบัติอะตอม
ซึ่งหมายความว่าเธรดสามารถค้นพบค่าล่าสุดของตัวแปรผันผวนโดยอัตโนมัติ ตัวแปรระเหยง่ายสามารถใช้เพื่อให้ความปลอดภัยของเธรด แต่สามารถนำไปใช้กับชุดการใช้งานที่ จำกัด มากเท่านั้น: ไม่มีข้อ จำกัด ระหว่างตัวแปรหลายตัวหรือระหว่างค่าปัจจุบันของตัวแปรและค่าที่แก้ไข
คุณสามารถใช้ตัวแปรผันผวนแทนล็อคในกรณีที่ จำกัด เพื่อให้ความปลอดภัยของด้ายในอุดมคติตัวแปรระเหยได้ต้องปฏิบัติตามสองเงื่อนไขต่อไปนี้ในเวลาเดียวกัน:
การดำเนินการเขียนไปยังตัวแปรไม่ได้ขึ้นอยู่กับค่าปัจจุบัน ตัวแปรไม่รวมอยู่ในค่าคงที่กับตัวแปรอื่น ๆ
sleep () vs wait ()
Sleep เป็นคลาสเธรด (เธรด) ซึ่งทำให้เธรดนี้หยุดทำงานชั่วคราวตามเวลาที่กำหนดและส่งโอกาสในการดำเนินการไปยังเธรดอื่น ๆ แต่สถานะการตรวจสอบยังคงอยู่และจะกลับมาทำงานโดยอัตโนมัติหลังจากนั้น การโทรสลีปจะไม่ปล่อยล็อควัตถุ
รอเป็นวิธีการของคลาสวัตถุ การเรียกใช้วิธีการรอบนวัตถุนี้ทำให้เธรดยอมแพ้ล็อควัตถุและป้อนพูลล็อครอรอวัตถุนี้ หลังจากออกวิธีการแจ้งเตือน (หรือแจ้งเตือน) สำหรับวัตถุนี้เธรดนี้จะเข้าสู่พูลล็อควัตถุและเตรียมที่จะรับล็อควัตถุและเข้าสู่สถานะการทำงาน (หากตัวแปรถูกประกาศว่าเป็นความผันผวนมันจะสอดคล้องกับหน่วยความจำหลักทุกครั้งที่เข้าถึงได้หากตัวแปรถูกเข้าถึงในวิธีการซิงโครนัสหรือบล็อกซิงโครนัสตัวแปรจะถูกซิงโครไนซ์เมื่อล็อคได้ที่ทางเข้าของวิธีการหรือบล็อก
http://www.yjbys.com/news/202750.html
โปรแกรมไคลเอนต์จำเป็นต้องได้รับบทบาทคอนเทนเนอร์เฉพาะก่อนจากนั้นรับบทบาทตัววนซ้ำที่เฉพาะเจาะจงผ่านบทบาทคอนเทนเนอร์ที่เฉพาะเจาะจง
iterator it = new ArrayList.Iterator ();
1) เข้าถึงเนื้อหาของวัตถุคอนเทนเนอร์โดยไม่เปิดเผยการเป็นตัวแทนภายใน
2) รองรับการเดินทางหลายครั้งของวัตถุคอนเทนเนอร์
3) จัดเตรียมอินเทอร์เฟซแบบครบวงจร (การวนซ้ำ polymorphic) สำหรับการสำรวจโครงสร้างภาชนะที่แตกต่างกัน
ใช้คำหลักใหม่} →ตัวสร้างถูกเรียก
ใช้วิธีการ newinstance ของคลาสคลาส} →ตัวสร้างถูกเรียก
ใช้วิธีการ newinstance ของคลาสคอนสตรัคเตอร์} →ฟังก์ชันตัวสร้างถูกเรียก
การใช้วิธีการโคลน} →ไม่มีตัวสร้างที่เรียกว่า
การใช้ deserialization} →ไม่มีตัวสร้างที่เรียกว่า
พนักงาน EMP2 = (พนักงาน) class.forName ("com.employee"). newInstance (); หรือ
พนักงาน EMP2 = Employee.class.NewInstance (); Constructor Constructor = Employee.class.getConstructor (); พนักงาน emp3 = constructor.newinstance ();
การใช้วิธีการโคลนเราต้องใช้อินเตอร์เฟส cloneable และใช้วิธีการโคลนที่กำหนดโดยมันก่อน
พนักงาน emp4 = (พนักงาน) emp3.clone ();
เมื่อโปรแกรมเริ่มต้นจะไม่โหลดไฟล์คลาสทั้งหมดที่จะใช้โดยโปรแกรมในครั้งเดียว แต่จะโหลดไฟล์คลาสที่แน่นอนลงในหน่วยความจำผ่านกลไกการโหลดคลาส Java (classloader) ตามความต้องการของโปรแกรม ดังนั้นหลังจากที่ไฟล์คลาสถูกโหลดลงในหน่วยความจำเท่านั้นที่จะสามารถอ้างอิงได้โดยคลาสอื่น ๆ ดังนั้น classloader จึงใช้ในการโหลดไฟล์คลาสแบบไดนามิกลงในหน่วยความจำ
Bootstrap classloader: เรียกว่าตัวโหลดคลาสเริ่มต้นมันเป็นตัวโหลดคลาสระดับบนสุดในลำดับชั้นการโหลดคลาส Java ซึ่งรับผิดชอบในการโหลดไลบรารีคลาสหลักใน JDK เช่น: RT.JAR, Resources.jar, charsets.jar ฯลฯ java_home/jre/lib/ext/โดยค่าเริ่มต้น
App Classloader: เรียกว่าตัวโหลดคลาสระบบซึ่งรับผิดชอบในการโหลดขวดและไฟล์คลาสทั้งหมดในไดเรกทอรีแอปพลิเคชันคลาส
เนื่องจากสิ่งนี้สามารถหลีกเลี่ยงการโหลดซ้ำ ๆ เมื่อพ่อโหลดชั้นเรียนจึงไม่จำเป็นต้องให้คลาสเด็กโหลดโหลดอีกครั้ง
เมื่อพิจารณาถึงปัจจัยด้านความปลอดภัยลองจินตนาการว่าถ้าเราไม่ใช้โหมดผู้แทนนี้เราสามารถแทนที่ประเภทที่กำหนดไว้ใน Java Core API ได้ตลอดเวลาซึ่งจะก่อให้เกิดความเสี่ยงด้านความปลอดภัยที่ยิ่งใหญ่มาก วิธีการมอบหมายหลักสามารถหลีกเลี่ยงสถานการณ์นี้ได้เนื่องจากสตริงถูกโหลดโดยตัวโหลดคลาสบูตแล้ว (bootSTRCP classloader) ในการเริ่มต้นดังนั้นคลาสที่กำหนดโดยผู้ใช้จะไม่สามารถโหลดสตริงที่เขียนด้วยตัวเองเว้นแต่คุณจะเปลี่ยนอัลกอริทึมเริ่มต้นของคลาสการค้นหาคลาส
1. คำขอของไคลเอ็นต์วัตถุคำขอคำขอนี้จะมีพารามิเตอร์จากคำขอ GET/POST และสามารถเข้าใจความต้องการของลูกค้าเท่านั้นและตอบกลับ
2. ข้อมูลที่เกี่ยวข้องเกี่ยวกับวัตถุตอบสนองตอบสนองต่อคำขอของลูกค้า
3. วัตถุเซสชันหมายถึงเซสชันระหว่างไคลเอนต์และเซิร์ฟเวอร์เริ่มต้นจากการสมัครเว็บจากไคลเอนต์ไปยังเซิร์ฟเวอร์จนกว่าไคลเอ็นต์จะถูกตัดการเชื่อมต่อจากเซิร์ฟเวอร์
4. วัตถุ OUT เป็นอินสแตนซ์ของคลาส JSPWriter และเป็นวัตถุที่ใช้กันทั่วไปเพื่อส่งออกเนื้อหาไปยังไคลเอนต์
5. วัตถุหน้ากำลังชี้ไปที่หน้า JSP ปัจจุบันเองซึ่งเป็นเหมือนตัวชี้นี้ในชั้นเรียน มันเป็นตัวอย่างของคลาส java.lang.object
6. วัตถุแอปพลิเคชันตระหนักถึงการแบ่งปันข้อมูลระหว่างผู้ใช้และสามารถจัดเก็บตัวแปรทั่วโลก เริ่มต้นด้วยการเริ่มต้นเซิร์ฟเวอร์จนกว่าเซิร์ฟเวอร์จะปิดตัวลง
7. วัตถุข้อยกเว้นเป็นวัตถุข้อยกเว้น เมื่อมีข้อยกเว้นเกิดขึ้นในระหว่างกระบวนการทำงานวัตถุนี้จะถูกสร้างขึ้น
8. วัตถุ PageContext ให้การเข้าถึงวัตถุและเนมสเปซทั้งหมดในหน้า JSP
9. วัตถุกำหนดค่าใช้งานโดยเอ็นจิ้น JSP เพื่อส่งผ่านข้อมูลไปเมื่อ servlet เริ่มต้น
JS มีฟังก์ชั่น iSnan (val) // ถ้าเป็นตัวเลขมันจะส่งคืนเท็จ
มีการแยกวิเคราะห์ xmldom, การแยกวิเคราะห์แซ็กโซโฟนและการแยกวิเคราะห์ Stax
xmldom: (xmldocumentobjectmodel) ประสิทธิภาพลดลงอย่างมากเมื่อประมวลผลไฟล์ขนาดใหญ่ ปัญหานี้เกิดจากโครงสร้างต้นไม้ DOM ซึ่งมีหน่วยความจำจำนวนมากและ DOM จะต้องโหลดเอกสารทั้งหมดลงในหน่วยความจำก่อนที่จะแยกวิเคราะห์ไฟล์ซึ่งเหมาะสำหรับการเข้าถึง XML แบบสุ่ม
SAX: (SimpleApIforXML) ซึ่งแตกต่างจาก DOM, SAX เป็นวิธีการแยกวิเคราะห์ XML ที่ขับเคลื่อนด้วยเหตุการณ์ มันอ่านไฟล์ XML ตามลำดับและไม่จำเป็นต้องโหลดไฟล์ทั้งหมดในครั้งเดียว เมื่อพบเหตุการณ์เช่นจุดเริ่มต้นของไฟล์จุดสิ้นสุดของเอกสารหรือจุดเริ่มต้นของแท็กและจุดสิ้นสุดของแท็กจะกระตุ้นเหตุการณ์ที่ผู้ใช้ประมวลผลไฟล์ XML โดยการเขียนรหัสการประมวลผลในเหตุการณ์การโทรกลับเหมาะสำหรับการเข้าถึง XML ตามลำดับ
Stax: ความแตกต่างระหว่าง (StreamingApiforXML) และวิธีอื่น ๆ คือแอปพลิเคชันสามารถจัดการ XML เป็นสตรีมเหตุการณ์ซึ่งดีกว่าวิธีอื่น ๆ ในแง่ของประสิทธิภาพและความพร้อมใช้งาน
thread.getState ()
ข้างต้นคือคำถามสัมภาษณ์ Java ที่รวบรวมโดยบรรณาธิการสำหรับคุณ ฉันหวังว่าพวกเขาจะเป็นประโยชน์กับคุณ หากคุณมีคำถามใด ๆ โปรดฝากข้อความถึงฉัน บรรณาธิการจะตอบกลับคุณทันเวลา!