การใช้หลาย JFrames: การปฏิบัติดีหรือไม่ดี? [ปิด]

ฉันกำลังพัฒนาแอพพลิเคชั่นที่แสดงภาพและเล่นเสียงจากฐานข้อมูล ฉันกำลังพยายามตัดสินใจว่าจะใช้ JFrame แยกต่างหากเพื่อเพิ่มรูปภาพในฐานข้อมูลจาก GUI หรือไม่

ฉันแค่สงสัยว่ามันเป็นวิธีปฏิบัติที่ดีในการใช้หลายหน้าต่าง JFrame หรือไม่?

ฉันแค่สงสัยว่ามันเป็นวิธีปฏิบัติที่ดีในการใช้ JFrames หลายรายการหรือไม่

การปฏิบัติที่ไม่ดี (เลวร้าย)

• ผู้ใช้ไม่เป็นมิตร: ผู้ใช้เห็นไอคอนหลายไอคอนในทาสก์บาร์ของพวกเขาเมื่อคาดว่าจะเห็นเพียงหนึ่งไอคอน บวกกับผลข้างเคียงของปัญหาการเข้ารหัส ..
• ฝันร้ายที่จะเขียนโค้ดและรักษา:
  • กิริยาโต้ตอบข้อเสนอโอกาสที่ง่ายต่อการให้ความสนใจมุ่งเน้นไปที่เนื้อหาของกล่องโต้ตอบว่า - เลือก / แก้ไข / ยกเลิกนี้แล้วดำเนินการต่อไป หลายเฟรมทำไม่ได้
  • กล่องโต้ตอบ (หรือแถบเครื่องมือลอย) กับผู้ปกครองจะปรากฏขึ้นด้านหน้าเมื่อผู้ปกครองคลิกที่ - คุณจะต้องใช้มันในเฟรมหากนั่นเป็นพฤติกรรมที่ต้องการ

มีหลายวิธีในการแสดงองค์ประกอบหลายอย่างใน GUI เดียวเช่น:

• CardLayout( ตัวอย่างสั้น ๆ) ที่ดีสำหรับ:
  1. แสดงตัวช่วยสร้างเช่นกล่องโต้ตอบ
  2. การแสดงรายการการเลือกต้นไม้เป็นต้นสำหรับรายการที่มีองค์ประกอบที่เกี่ยวข้อง
  3. พลิกระหว่างไม่มีองค์ประกอบและองค์ประกอบที่มองเห็นได้
• JInternalFrame/JDesktopPaneโดยปกติจะใช้สำหรับMDI
• JTabbedPane สำหรับกลุ่มของส่วนประกอบ
• JSplitPane วิธีในการแสดงสององค์ประกอบที่ความสำคัญระหว่างหนึ่งหรืออื่น ๆ (ขนาด) แตกต่างกันไปตามสิ่งที่ผู้ใช้กำลังทำ
• JLayeredPane ไกลมากดี .. ส่วนประกอบเลเยอร์
• JToolBarโดยทั่วไปจะมีกลุ่มของการกระทำหรือการควบคุม สามารถลากไปรอบ ๆ GUI หรือปิดทั้งหมดตามความต้องการของผู้ใช้ ดังกล่าวข้างต้นจะลด / เรียกคืนตามผู้ปกครองทำเช่นนั้น
• เป็นรายการในJList(ตัวอย่างง่ายๆด้านล่าง)
• JTreeในฐานะที่เป็นโหนดใน
• รูปแบบที่ซ้อนกัน
  

แต่ถ้ากลยุทธ์เหล่านั้นใช้ไม่ได้กับกรณีการใช้งานเฉพาะลองทำดังต่อไปนี้ สร้างหลักเดียวJFrameจากนั้นมีJDialogหรือJOptionPaneอินสแตนซ์ปรากฏขึ้นสำหรับองค์ประกอบที่เหลือลอยตัวโดยใช้เฟรมเป็นพาเรนต์สำหรับไดอะล็อก

ภาพมากมาย

ในกรณีนี้ที่องค์ประกอบหลาย ๆ อย่างเป็นรูปภาพควรใช้วิธีใดวิธีหนึ่งต่อไปนี้แทน:

1. หนึ่งJLabel(กึ่งกลางในบานหน้าต่างเลื่อน) เพื่อแสดงรูปใดที่ผู้ใช้สนใจในขณะนั้น เท่าที่เห็นImageViewerค่ะ
   
2. JListแถวเดียว เท่าที่เห็นในคำตอบนี้ ส่วน 'แถวเดี่ยว' ของส่วนนั้นจะใช้งานได้หากมันมีขนาดเท่ากันทั้งหมด อีกทางเลือกหนึ่งถ้าคุณพร้อมที่จะปรับขนาดของภาพในทันทีและอัตราส่วนทั้งหมดเดียวกัน (เช่น 4: 3 หรือ 16: 9)

JFrameวิธีการหลายอย่างเป็นสิ่งที่ฉันนำไปใช้ตั้งแต่เริ่มเขียนโปรแกรมแอพ Swing ส่วนใหญ่ฉันทำตั้งแต่แรกเพราะไม่รู้อะไรเลย อย่างไรก็ตามเมื่อฉันครบกำหนดในประสบการณ์และความรู้ของฉันในฐานะนักพัฒนาและเมื่อเริ่มอ่านและรับฟังความคิดเห็นของ Java devs ที่มีประสบการณ์มากขึ้นทางออนไลน์ฉันพยายามเปลี่ยนจากหลายJFrameแนวทาง (ทั้งในโครงการปัจจุบันและโครงการในอนาคต ) เท่านั้นที่จะได้พบกับ ... รับสิ่งนี้ ... ความต้านทานจากลูกค้าของฉัน! เมื่อฉันเริ่มใช้กล่องโต้ตอบโมดอลเพื่อควบคุมหน้าต่างและลูก "ย่อย" JInternalFrameสำหรับส่วนประกอบแยกกันลูกค้าของฉันเริ่มบ่น!ฉันค่อนข้างประหลาดใจเมื่อฉันทำสิ่งที่ฉันคิดว่าเป็นการปฏิบัติที่ดีที่สุด! แต่อย่างที่พวกเขาพูดว่า "ภรรยาที่มีความสุขคือชีวิตที่มีความสุข" กันไปสำหรับลูกค้าของคุณ แน่นอนฉันเป็นผู้รับเหมาดังนั้นผู้ใช้ของฉันสามารถเข้าถึงฉันโดยตรงผู้พัฒนาซึ่งเห็นได้ชัดว่าไม่ใช่สถานการณ์ทั่วไป

ดังนั้นฉันจะอธิบายถึงประโยชน์ของJFrameวิธีการที่หลากหลายรวมถึงตำนานที่เล่าขานถึงข้อเสียที่คนอื่นนำเสนอ

1. ความยืดหยุ่นสูงสุดในการจัดวาง - คุณสามารถแยกแยะJFrameผู้ใช้ปลายทางของคุณเพื่อกระจายและควบคุมสิ่งที่อยู่บนหน้าจอของเขา / เธอ แนวคิดดังกล่าวให้ความรู้สึก "เปิดกว้าง" และไม่มีการ จำกัด คุณจะสูญเสียนี้เมื่อคุณไปสู่ขนาดใหญ่JFrameและพวงของJInternalFrames
2. ทำงานได้ดีสำหรับแอปพลิเคชันที่ปรับเป็นโมดูลได้มาก - ในกรณีของฉันแอปพลิเคชั่นส่วนใหญ่ของฉันมี "โมดูล" ขนาดใหญ่ 3 - 5 ตัวที่ไม่มีอะไรเกี่ยวข้องกันเลย ตัวอย่างเช่นหนึ่งโมดูลอาจเป็นแผงควบคุมการขายและหนึ่งอาจเป็นแผงควบคุมการบัญชี พวกเขาไม่ได้พูดคุยกันหรืออะไรก็ตาม อย่างไรก็ตามผู้บริหารอาจต้องการเปิดทั้งสองอย่างและแยกเป็นเฟรมบนแถบงานทำให้ชีวิตของเขาง่ายขึ้น
3. ทำให้ผู้ใช้ปลายทางสามารถอ้างอิงวัสดุภายนอกได้ - เมื่อฉันมีสถานการณ์นี้: แอปของฉันมี "ตัวแสดงข้อมูล" ซึ่งคุณสามารถคลิก "เพิ่มใหม่" และมันจะเปิดหน้าจอการป้อนข้อมูล ในขั้นต้นทั้งคู่เป็นJFrameเอส อย่างไรก็ตามฉันต้องการให้หน้าจอป้อนข้อมูลเป็นJDialogผู้ปกครองซึ่งเป็นผู้ดูข้อมูล ฉันทำการเปลี่ยนแปลงและทันทีที่ฉันได้รับโทรศัพท์จากผู้ใช้ปลายทางซึ่งพึ่งพาอย่างมากกับความจริงที่ว่าเขาสามารถย่อหรือปิดโปรแกรมดูและเปิดโปรแกรมแก้ไขในขณะที่เขาอ้างอิงส่วนอื่นของโปรแกรม (หรือเว็บไซต์ฉันไม่ได้ จำไม่ได้) เขาไม่ได้อยู่บนจอภาพหลายจอดังนั้นเขาต้องการไดอะล็อกการเข้าร่วมเป็นอันดับแรกและอย่างอื่นเป็นอันดับสองโดยซ่อนตัวดูข้อมูลไว้อย่างสมบูรณ์ นี่เป็นไปไม่ได้ด้วยJDialogและแน่นอนว่าจะเป็นไปไม่ได้ด้วยJInternalFrameเช่นกัน ฉันเปลี่ยนมันกลับมาเป็นการแยกจากกันJFramesเพื่อความมีสติของเขา แต่มันก็สอนบทเรียนสำคัญให้ฉัน
4. ตำนาน: ยากที่จะเขียนโค้ด - สิ่งนี้ไม่เป็นความจริงในประสบการณ์ของฉัน ผมไม่เห็นว่าทำไมมันจะได้ง่ายขึ้นในการสร้างกว่าJInternalFrame JFrameจากประสบการณ์จริงของฉันJInternalFramesมีความยืดหยุ่นน้อยกว่ามาก ฉันได้พัฒนาวิธีที่เป็นระบบในการจัดการการเปิด & ปิดของJFrames ในแอพของฉันที่ใช้งานได้ดีจริงๆ ฉันควบคุมเฟรมเกือบทั้งหมดจากภายในรหัสของเฟรมเอง การสร้างเฟรมใหม่, SwingWorkers ที่ควบคุมการดึงข้อมูลบนเธรดพื้นหลังและรหัส GUI บน EDT, การเรียกคืน / นำไปด้านหน้าเฟรมหากผู้ใช้พยายามเปิดมันสองครั้ง, ฯลฯ สิ่งที่คุณต้องเปิดJFrameคือ เรียกวิธีสาธารณะคงที่open()และวิธีการเปิดรวมกับwindowClosing() เหตุการณ์จัดการส่วนที่เหลือ (เฟรมเปิดอยู่แล้วหรือไม่เปิด แต่โหลดหรือไม่เป็นต้น) ฉันทำแบบนี้เป็นเทมเพลตดังนั้นจึงไม่ยากที่จะนำไปใช้กับแต่ละเฟรม
5. Myth / Unproven: Resource หนัก - ฉันต้องการเห็นข้อเท็จจริงบางอย่างที่อยู่เบื้องหลังคำแถลงการเก็งกำไรนี้ แม้ว่าบางทีคุณสามารถพูดได้ว่าJFrameต้องการพื้นที่มากกว่า a JInternalFrameถึงแม้ว่าคุณจะเปิด 100 JFrames คุณจะต้องใช้ทรัพยากรเพิ่มอีกเท่าไหร่? หากคุณกังวลคือการรั่วไหลของหน่วยความจำเพราะของทรัพยากร: โทรdispose()ปลดปล่อยทรัพยากรทั้งหมดที่ใช้โดยกรอบการเก็บขยะ (และอีกครั้งที่ผมพูดเป็นJInternalFrameควรเรียกว่าความกังวลเดียวกัน)

ฉันเขียนมากและฉันรู้สึกว่าฉันสามารถเขียนได้มากขึ้น อย่างไรก็ตามฉันหวังว่าฉันจะไม่ได้รับการโหวตเพียงเพราะมันเป็นความคิดเห็นที่ไม่เป็นที่นิยม คำถามนี้เป็นคำถามที่มีค่าอย่างชัดเจนและฉันหวังว่าฉันจะได้รับคำตอบที่มีค่าแม้ว่าจะไม่ใช่ความคิดเห็นทั่วไปก็ตาม

ตัวอย่างที่ดีของหลายเฟรม / เอกสารเดี่ยวต่อเฟรม ( SDI ) เทียบกับเฟรมเดี่ยว / หลายเอกสารต่อเฟรม ( MDI ) คือ Microsoft Excel ประโยชน์บางอย่างของ MDI:

• เป็นไปได้ที่จะมีสองสามหน้าต่างในรูปทรงสี่เหลี่ยม - ดังนั้นพวกเขาจึงไม่ซ่อนเดสก์ท็อปหรือหน้าต่างอื่นจากกระบวนการอื่น (เช่นเว็บเบราว์เซอร์)
• เป็นไปได้ที่จะเปิดหน้าต่างจากกระบวนการอื่นบนหน้าต่าง Excel หนึ่งขณะที่เขียนในหน้าต่าง Excel ที่สอง - ด้วย MDI การพยายามเขียนในหนึ่งในหน้าต่างภายในจะให้ความสำคัญกับหน้าต่าง Excel ทั้งหมดดังนั้นจึงซ่อนหน้าต่างจากกระบวนการอื่น
• เป็นไปได้ที่จะมีเอกสารต่าง ๆ บนหน้าจอที่แตกต่างกันซึ่งมีประโยชน์อย่างยิ่งเมื่อหน้าจอไม่มีความละเอียดเดียวกัน

SDI (อินเทอร์เฟซเอกสารเดียวคือหน้าต่างทุกบานสามารถมีเอกสารเดียว):

MDI (อินเทอร์เฟซหลายเอกสารกล่าวคือทุกหน้าต่างสามารถมีเอกสารหลายฉบับ):

ฉันต้องการโต้แย้งการโต้เถียง "ไม่เป็นมิตรกับผู้ใช้" ด้วยตัวอย่างที่ฉันเพิ่งมีส่วนร่วม

ในแอปพลิเคชันของเราเรามีหน้าต่างหลักที่ผู้ใช้เรียกใช้ 'โปรแกรม' เป็นแท็บแยกต่างหาก มากที่สุดเท่าที่เป็นไปได้เราพยายามเก็บใบสมัครของเราไว้ในหน้าต่างเดียวนี้

หนึ่งใน 'โปรแกรม' ที่พวกเขาเรียกใช้จะแสดงรายการรายงานที่สร้างขึ้นโดยระบบและผู้ใช้สามารถคลิกที่ไอคอนในแต่ละบรรทัดเพื่อเปิดป๊อปอัพกล่องโต้ตอบตัวแสดงรายงาน ผู้ดูนี้แสดงเทียบเท่ากับหน้า A4 แนวตั้ง / แนวนอนของรายงานดังนั้นผู้ใช้เช่นหน้าต่างนี้จะค่อนข้างใหญ่เกือบเต็มหน้าจอ

ไม่กี่เดือนที่ผ่านมาเราเริ่มรับคำขอจากลูกค้าของเราเพื่อทำให้หน้าต่างตัวดูรายงานเหล่านี้ไม่มีการเปลี่ยนแปลงเพื่อให้พวกเขาสามารถเปิดรายงานหลายฉบับได้ในเวลาเดียวกัน

บางครั้งฉันคัดค้านการร้องขอนี้เพราะฉันไม่คิดว่านี่เป็นทางออกที่ดี อย่างไรก็ตามความคิดของฉันก็เปลี่ยนไปเมื่อฉันค้นพบว่าผู้ใช้มีการ 'แก้ไข' ระบบของเราอย่างไร

พวกเขากำลังเปิดตัวแสดงโดยใช้เครื่องมือ 'บันทึกเป็น' เพื่อบันทึกรายงานเป็น PDF ไปยังไดเรกทอรีที่ระบุโดยใช้ Acrobat Reader เพื่อเปิดไฟล์ PDF จากนั้นพวกเขาจะทำเช่นเดียวกันกับรายงานถัดไป พวกเขาจะมีผู้อ่าน Acrobat หลายคนที่ทำงานด้วยเอาต์พุตรายงานต่างๆที่พวกเขาต้องการดู

ดังนั้นฉันจึงผ่อนปรนและทำให้ผู้ดูไม่อยู่บ้าน ซึ่งหมายความว่าผู้ดูแต่ละคนจะมีไอคอนแถบงาน

เมื่อเวอร์ชันล่าสุดออกวางจำหน่ายเมื่อสัปดาห์ที่แล้วการตอบรับอย่างล้นหลามคือพวกเขารักมัน มันเป็นหนึ่งในการปรับปรุงล่าสุดที่เป็นที่นิยมมากที่สุดในระบบ

ดังนั้นคุณจึงไปข้างหน้าและบอกผู้ใช้ของคุณว่าสิ่งที่พวกเขาต้องการนั้นไม่ดี แต่ในที่สุดมันจะไม่ช่วยอะไรคุณ

หมายเหตุบางส่วน:

• ดูเหมือนว่าวิธีปฏิบัติที่ดีที่สุดในการใช้ JDialog สำหรับหน้าต่างที่ไม่มีการเปลี่ยนแปลงเหล่านี้
• ใช้ตัวสร้างที่ใช้ใหม่ModalityTypeมากกว่าการmodalโต้แย้งบูลีน นี่คือสิ่งที่ทำให้กล่องโต้ตอบเหล่านี้มีไอคอนแถบงาน
• สำหรับไดอะล็อกที่สร้างไม่ผ่านให้ส่งค่าพาเรนต์ null ไปยังตัวสร้าง แต่ระบุตำแหน่งที่สัมพันธ์กับหน้าต่าง
• Java เวอร์ชัน 6 บน Windows มีข้อผิดพลาดซึ่งหมายความว่าหน้าต่างหลักของคุณจะกลายเป็น 'อยู่ด้านบนเสมอ' โดยที่คุณไม่ต้องบอก อัปเกรดเป็นเวอร์ชัน 7 เพื่อแก้ไขปัญหานี้

ทำให้ jInternalFrame เป็นเฟรมหลักและทำให้มองไม่เห็น จากนั้นคุณสามารถใช้มันสำหรับกิจกรรมเพิ่มเติม

jInternalFrame.setSize(300,150);
jInternalFrame.setVisible(true);

เป็นเวลานานแล้วที่ฉันสัมผัสถึงการแกว่ง แต่โดยทั่วไปแล้วมันเป็นการฝึกฝนที่ไม่ดีเลย ข้อเสียเปรียบหลักบางประการที่อยู่ในใจ:

• มันแพงกว่า:คุณจะต้องจัดสรรทรัพยากรให้มากขึ้นเพื่อวาด JFrame ที่คอนเทนเนอร์หน้าต่างชนิดอื่นเช่น Dialog หรือ JInternalFrame

• ไม่เป็นมิตรกับผู้ใช้:ไม่ใช่เรื่องง่ายที่จะนำทางไปยังกลุ่ม JFrame ที่ติดกันมันจะดูเหมือนว่าแอปพลิเคชันของคุณเป็นชุดของแอปพลิเคชันที่ไม่สอดคล้องกันและการออกแบบไม่ดี

• มันใช้งานง่าย JInternalFrameนี่เป็น retorical ตอนนี้มันง่ายกว่าและคนอื่น ๆ ฉลาดกว่า (หรือมีเวลาว่าง) มากกว่าที่เราคิดผ่านเดสก์ท็อปและ JInternalFrame ดังนั้นฉันอยากจะแนะนำให้ใช้

การปฏิบัติที่ไม่ดีอย่างแน่นอน เหตุผลหนึ่งก็คือมันไม่ 'ใช้งานง่าย' มากนักเพราะทุกคนJFrameแสดงไอคอนแถบงานใหม่ การควบคุมหลายJFrames คุณจะต้องถอนผมออก

โดยส่วนตัวฉันจะใช้ ONE JFrameสำหรับแอปพลิเคชันของคุณ วิธีการแสดงสิ่งต่าง ๆ นั้นขึ้นอยู่กับคุณมีหลายวิธี CanvasES, JInternalFrame, CardLayoutแม้JPanels อาจ

วัตถุ JFrame หลายรายการ = ความเจ็บปวดปัญหาและปัญหา

ฉันคิดว่าการใช้หลายรายการJframeไม่ใช่ความคิดที่ดี

แต่เราสามารถใช้JPanelมากกว่าหนึ่งอย่างJPanelในที่เดียวกันJFrameได้

นอกจากนี้เราสามารถสลับไปมาระหว่างนี้JPanels JFrameดังนั้นมันทำให้เรามีเสรีภาพในการแสดงผลมากกว่าสิ่งใน

สำหรับJPanelเราแต่ละคนสามารถออกแบบสิ่งต่าง ๆ และทั้งหมดนี้JPanelสามารถแสดงบนJFrameหนึ่งครั้ง

เพื่อสลับระหว่างการJPanelใช้งานนี้JMenuBarกับJMenuItemsสำหรับแต่ละJPanelหรือ 'JButton for eachJPanel`

มากกว่าหนึ่งJFrameไม่ได้เป็นวิธีปฏิบัติที่ดี JFrameแต่มีอะไรผิดปกติถ้าเราต้องการมากกว่าหนึ่ง

แต่มันจะดีกว่าที่จะเปลี่ยนหนึ่งJFrameสำหรับความต้องการที่แตกต่างกันของเราแทนที่จะมีหลายJFrames

หากเฟรมจะมีขนาดเท่ากันทำไมไม่สร้างเฟรมและส่งเฟรมแล้วเป็นการอ้างอิงถึงเฟรมนั้นแทน

เมื่อคุณผ่านเฟรมไปแล้วคุณสามารถตัดสินใจว่าจะเติมมันอย่างไร มันเหมือนมีวิธีในการคำนวณค่าเฉลี่ยของชุดตัวเลข คุณจะสร้างวิธีนี้ซ้ำแล้วซ้ำอีก?

มันไม่ใช่วิธีปฏิบัติที่ดี แต่แม้ว่าคุณต้องการใช้มันคุณสามารถใช้รูปแบบซิงเกิลที่ดี ฉันใช้รูปแบบซิงเกิลในโครงการส่วนใหญ่ของฉันมันดี