ในบทความสั้น ๆ นี้ ฉันต้องการอธิบายกระบวนการสร้างโปรแกรมขนาดเล็กที่รองรับ GUI ในภาษา ชวา- สันนิษฐานว่าผู้อ่านมีความคุ้นเคยกับพื้นฐานของภาษา ชวา.

แล้วเราต้องการเครื่องมืออะไรบ้าง:

• เครื่องเสมือน Java (OpenJDK หรือ Oracle JDK)
• Intellij IDEA(หรือ Java IDE อื่นๆ)

หลังการติดตั้ง ซอฟต์แวร์ที่จำเป็น, เปิด Intellij IDEAและสร้างโปรเจ็กต์ใหม่: File -> New Project…

ฉันตั้งชื่อโครงการ กุยเบส- อย่างที่คุณเห็นในภาพหน้าจอคือโฟลเดอร์ srcไม่มีสิ่งใดเลยเราจึงสร้างของเรา ชั้นเรียนหลักประกอบด้วยฟังก์ชัน หลัก.

คลาสสาธารณะ Main ( โมฆะสาธารณะคงที่ main(String args) ( System.out.println("Hello, Govzalla!"); ) )

คุณสามารถดูเนื้อหาของคลาสหลักด้านบน ตอนนี้เราสามารถสร้างโครงการ ( สร้างโครงการ ) และรันมัน ( วิ่ง - ลงในเทอร์มินัลของคุณ ไอดีคุณจะเห็นข้อความ “สวัสดี กอฟซาล่า!”- แต่อย่างที่คุณเข้าใจแล้วว่ามันไม่รองรับ GUI

ในขั้นตอนนี้ เรามีโปรแกรมที่ใช้งานได้อยู่แล้ว แต่ไม่มีการสนับสนุน GUI และตอนนี้อยู่ในโฟลเดอร์เดียวกัน srcมาสร้างกันเถอะ แบบฟอร์ม GUI: ใหม่ -> แบบฟอร์ม GUI

เปิดแบบฟอร์ม GUI ที่สร้างขึ้น คลิกที่ เจพาเนลและตั้งค่าตัวระบุในช่อง ชื่อฟิลด์ฉันถาม แผงหน้าปัด.

จากนั้นลากไปวางบนแบบฟอร์มด้วย ด้านขวา JTextField, JPasswordFieldและ เจบัตตัน:

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

แม้ว่าคลาสหน้าต่างของเราจะมี องค์ประกอบที่จำเป็นแต่ถึงตอนนี้ มันไม่เกี่ยวอะไรกับ GUI เลย มาขยายความกันดีกว่า เจเฟรมและสืบทอดฟังก์ชัน GUI พื้นฐานและที่จำเป็นทั้งหมด .

ใน ในขณะนี้เรามีแบบฟอร์ม MainWindowและชั้นเรียน MainWindowขยายด้วย เจเฟรม- ตอนนี้เราจำเป็นต้องกำหนดองค์ประกอบ GUI ที่เพิ่มเข้ามาทั้งหมดให้เป็นเนื้อหาของชั้นเรียน MainWindow
this.getContentPane().add(แผง);
หลังจากนั้นเนื้อหาของไฟล์ MainWindow.java จะมีการเปลี่ยนแปลงดังนี้:

นำเข้า javax.swing.*; MainWindow คลาสสาธารณะขยาย JFrame (JTextField textField1 ส่วนตัว JPasswordField รหัสผ่านField1 ส่วนตัว ปุ่ม JButton ส่วนตัว 1 แผง JPanel ส่วนตัว MainWindow สาธารณะ () ( this.getContentPane().add(panel); ) )

หากคุณพยายามเรียกใช้โค้ด คุณจะเห็นข้อความ “Hello, Govzalla!” เดิมอีกครั้ง ความจริงก็คือเราสร้างคลาสและแบบฟอร์มสำหรับคลาสนั้น แต่ไม่ได้สร้างอินสแตนซ์ของคลาสนี้

ถึงเวลาเปลี่ยนไฟล์ Main.java และเพิ่มโค้ดสำหรับสร้าง GUI ของเราที่นั่น:

นำเข้า java.awt.*; public class Main ( public static void main(String args) ( // สร้างอินสแตนซ์ของคลาส MainWindow MainWindow mainWindow = new MainWindow(); // แพ็คองค์ประกอบทั้งหมดจากแบบฟอร์ม mainWindow.pack(); // ปรับขนาดหน้าต่าง mainWindow.setSize( new Dimension(200, 200)); // แสดงหน้าต่างที่สร้าง mainWindow.setVisible(true) )

กำลังรันโค้ด

เมื่อคลิกปุ่ม คุณจะสังเกตเห็นว่าโปรแกรมไม่ตอบสนองเลย ประเด็นก็คือเรายังไม่ได้เพิ่มผู้ฟัง ( ผู้ฟัง) สำหรับกิจกรรม ( กิจกรรม) ปุ่ม ปุ่ม

ผู้ฟังเหตุการณ์ ( ผู้ฟังเหตุการณ์) เจบัตตันต้องเป็นอะแดปเตอร์การปลูกถ่าย ActionListenerดังนั้นเรามาเพิ่มโค้ดต่อไปนี้ในเนื้อหาของคลาส MainWindow:

คลาสส่วนตัว MyButtonListener ใช้ ActionListener ( @Override โมฆะสาธารณะ actionPerformed(ActionEvent actionEvent) ( ) )

วิธี การกระทำที่ดำเนินการแล้ว() จะประมวลผลเหตุการณ์ทั้งหมดของ button1 แต่ก่อนอื่นคุณยังคงต้องบอก button1 ว่าคลาสใดที่จะประมวลผล ดังนั้นให้เพิ่มโค้ดต่อไปนี้ให้กับ Constructor ของคลาส MainWIndow:
this.button1.addActionListener (MyButtonListener ใหม่ ());
เพื่อป้องกันไม่ให้ตัวจัดการของเราไร้ความหมาย ให้เพิ่มโค้ดต่อไปนี้ในเมธอด การกระทำที่ดำเนินการแล้ว():

@แทนที่การกระทำโมฆะสาธารณะดำเนินการ(ActionEvent actionEvent) ( if (textField1.getText().equals(passwordField1.getText())) ( JOptionPane.showMessageDialog(null, "Success"); ) else ( JOptionPane.showMessageDialog(null, "Failure) " ");

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

อินเทอร์เฟซแบบกราฟิกใน Java ได้ผ่านเส้นทางการพัฒนาและการก่อตัวที่ยุ่งยากมาก เป็นเวลานานที่เขาถูกกล่าวหาว่า ทำงานช้าความโลภต่อทรัพยากรระบบและฟังก์ชันการทำงานที่จำกัด

จาวา AWT

ความพยายามครั้งแรกของ Sun ในการสร้าง GUI สำหรับ Java คือไลบรารี เอ.ดับบลิว.ที.(Abstract Window Toolkit) - ชุดเครื่องมือสำหรับการทำงานกับสภาพแวดล้อมหน้าต่างต่างๆ Sun สร้างเลเยอร์ Java ที่เรียกเมธอดจากไลบรารีที่เขียนด้วย C เมธอดไลบรารี AWT สร้างและใช้ส่วนประกอบแบบกราฟิกของสภาพแวดล้อมการทำงาน ในแง่หนึ่ง นี่เป็นสิ่งที่ดี เนื่องจากโปรแกรม Java นั้นคล้ายคลึงกับโปรแกรมอื่นๆ ในระบบปฏิบัติการเดียวกัน แต่เมื่อคุณรันบนแพลตฟอร์มอื่น ขนาดส่วนประกอบและแบบอักษรที่แตกต่างกันอาจเกิดขึ้นได้ ซึ่งจะทำให้รูปลักษณ์ของโปรแกรมเสีย

เพื่อให้แน่ใจว่ามีหลากหลายแพลตฟอร์ม เอ.ดับบลิว.ที.อินเทอร์เฟซการเรียกส่วนประกอบเป็นหนึ่งเดียว ส่งผลให้ฟังก์ชันการทำงานลดลงเล็กน้อย และชุดส่วนประกอบก็ค่อนข้างเล็ก ตัวอย่างเช่น AWT ไม่มีตาราง และปุ่มต่างๆ ไม่รองรับการแสดงไอคอน ยังแพ็คอยู่ครับ java.awtถูกรวมอยู่ใน Java ตั้งแต่รุ่นแรกสุดและสามารถใช้เพื่อสร้าง GUI ได้

ดังนั้นส่วนประกอบ เอ.ดับบลิว.ที.พวกเขาไม่ได้ทำ "งาน" ใด ๆ มันเป็นเพียง "Java wrapper" สำหรับการควบคุมระบบปฏิบัติการที่พวกมันทำงาน คำขอทั้งหมดไปยังส่วนประกอบเหล่านี้จะถูกเปลี่ยนเส้นทางไปยังระบบปฏิบัติการซึ่งทำงานทั้งหมด

ทรัพยากรที่ใช้ เอ.ดับบลิว.ที.พยายามที่จะปล่อยโดยอัตโนมัติ สิ่งนี้จะเพิ่มความซับซ้อนเล็กน้อยให้กับสถาปัตยกรรมและส่งผลต่อประสิทธิภาพ การเขียนสิ่งที่จริงจังโดยใช้ AWT จะค่อนข้างยาก ปัจจุบันใช้สำหรับแอปเพล็ตเท่านั้น

แนวคิดพื้นฐานของ SWING

กำลังติดตาม เอ.ดับบลิว.ที.ซันได้พัฒนาไลบรารีส่วนประกอบกราฟิก แกว่งเขียนด้วยภาษา Java ทั้งหมด 2D ใช้สำหรับการเรนเดอร์ ซึ่งมีข้อดีหลายประการ ชุดส่วนประกอบมาตรฐานเหนือกว่า AWT อย่างมากในแง่ของความหลากหลายและฟังก์ชันการทำงาน Swing ทำให้ง่ายต่อการสร้างส่วนประกอบใหม่โดยสืบทอดจากส่วนประกอบที่มีอยู่ และรองรับสไตล์และสกินที่แตกต่างกัน

ผู้สร้างห้องสมุดใหม่ ส่วนต่อประสานกับผู้ใช้ แกว่งพวกเขาไม่ได้ "คิดค้นวงล้อใหม่" และเลือก AWT เป็นพื้นฐานสำหรับห้องสมุดของพวกเขา แน่นอนว่าเราไม่ได้พูดถึงการใช้ส่วนประกอบ AWT รุ่นหนาโดยเฉพาะ (แสดงโดยปุ่ม ป้ายกำกับ และคลาสที่คล้ายกัน) เฉพาะส่วนประกอบที่มีน้ำหนักเบาเท่านั้นที่ให้ความยืดหยุ่นและความสามารถในการควบคุมในระดับที่ต้องการ แผนภาพมรดกแสดงความสัมพันธ์ระหว่าง AWT และ Swing

ความแตกต่างที่สำคัญที่สุด แกว่งจาก AWT คือส่วนประกอบของ Swing ไม่ได้เชื่อมต่อกับระบบปฏิบัติการเลย จึงมีความเสถียรและรวดเร็วกว่ามาก ส่วนประกอบเหล่านี้เรียกว่า Lightweights ใน Java และการทำความเข้าใจหลักการพื้นฐานของวิธีการทำงานจะช่วยอธิบายวิธีการทำงานของ Swing ได้เป็นอย่างดี

แกว่งตู้คอนเทนเนอร์ระดับสูงสุด

เพื่อสร้าง กุยแอปพลิเคชันจำเป็นต้องใช้ส่วนประกอบไลบรารี Swing พิเศษที่เรียกว่าคอนเทนเนอร์ระดับบนสุด เป็นหน้าต่างระบบปฏิบัติการที่เก็บส่วนประกอบส่วนต่อประสานกับผู้ใช้ คอนเทนเนอร์ระดับบนสุดประกอบด้วยหน้าต่าง JFrame และ JWindow กล่องโต้ตอบ JDialog และแอปเพล็ต JApplet (ซึ่งไม่ใช่หน้าต่าง แต่ยังได้รับการออกแบบเพื่อแสดงอินเทอร์เฟซในเบราว์เซอร์ที่เรียกใช้แอปเพล็ตนี้) คอนเทนเนอร์ชั้นบนสุดของ Swing เป็นส่วนประกอบที่มีน้ำหนักมากและเป็นข้อยกเว้นของกฎทั่วไป ส่วนประกอบสวิงอื่นๆ ทั้งหมดมีน้ำหนักเบา

เรียบง่าย แกว่งตัวอย่างการสร้างหน้าต่างอินเตอร์เฟส เจเฟรม.

นำเข้า java.awt.Dimension; นำเข้า javax.swing.JFrame; นำเข้า javax.swing.JLabel; คลาสสาธารณะ JFrameTest ( โมฆะสาธารณะคงที่ createGUI() ( JFrame frame = new JFrame("Test frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JLabel label = new JLabel("Test label"); frame.getContentPane() เพิ่ม (ฉลาก); frame.setPreferredSize (มิติใหม่ (200, 100)); frame.setVisible (จริง); โมฆะสาธารณะคงที่หลัก (Args สตริง) (JFrame.setDefaultLookAndFeelDecorated (จริง); javax. swing.SwingUtilities.inurgeLater (ใหม่ Runnable() ( โมฆะสาธารณะ run() ( createGUI(); ) ) )

ตัวสร้าง เจเฟรม()สร้างโดยไม่มีพารามิเตอร์ หน้าต่างว่างเปล่า- ตัวสร้าง JFrame (ชื่อสตริง)สร้างหน้าต่างว่างด้วย ชื่อหัวเรื่อง- เพื่อสร้าง โปรแกรมที่ง่ายที่สุดด้วยหน้าต่างว่างคุณต้องใช้วิธีการต่อไปนี้:

• setSize(int width, int height) - กำหนดขนาดของหน้าต่าง
• setDefaultCloseOperation(int operation) - กำหนดการดำเนินการเมื่อโปรแกรมสิ้นสุด
• setVisible(มองเห็นบูลีน) - ทำให้หน้าต่างมองเห็นได้

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

เมธอด setDefaultCloseOperation ระบุการดำเนินการที่จะดำเนินการเมื่อ "ออกจากโปรแกรม" ในการดำเนินการนี้ คุณควรส่งค่าคงที่ EXIT_ON_CLOSE ตามที่อธิบายไว้ในคลาส JFrame เป็นพารามิเตอร์การดำเนินการ

ตามค่าเริ่มต้น หน้าต่างจะถูกสร้างขึ้นให้มองไม่เห็น ในการแสดงหน้าต่างบนหน้าจอ เมธอด setVisible จะถูกเรียกพร้อมกับพารามิเตอร์ true หากเรียกด้วยพารามิเตอร์ false หน้าต่างจะมองไม่เห็น

ส่วนต่อประสานกราฟิก ชวาสวิงตัวอย่างการสร้างหน้าต่าง เจเฟรมแสดงไว้ในรูปต่อไปนี้

เพื่อเชื่อมต่อห้องสมุด แกว่งแอปพลิเคชันจำเป็นต้องนำเข้าไลบรารี javax.สวิง.

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

รากสีซีด JRootPaneเพิ่มคุณสมบัติ "ความลึก" ให้กับคอนเทนเนอร์ โดยให้ความสามารถไม่เพียงแต่ในการวางส่วนประกอบหนึ่งไว้เหนือส่วนประกอบอื่นเท่านั้น แต่ยังเปลี่ยนตำแหน่ง เพิ่มหรือลดความลึกของส่วนประกอบหากจำเป็นด้วย คุณสมบัตินี้จำเป็นเมื่อสร้างแอปพลิเคชันหลายเอกสาร แกว่งซึ่งหน้าต่างแสดงถึงส่วนประกอบน้ำหนักเบาที่อยู่ด้านบนของกันและกัน รวมถึงเมนูแบบเลื่อนลง (ตามบริบท) และคำแนะนำเครื่องมือ

รูปภาพต่อไปนี้แสดงโครงสร้างของแผงรากอย่างชัดเจน JRootPane.

แผงราก JRootPaneเป็นคอนเทนเนอร์ที่สืบทอดมาจาก คลาสพื้นฐานสวิง JComponent ในคอนเทนเนอร์นี้ ตัวจัดการโครงร่างพิเศษที่นำไปใช้ในคลาสภายใน RootPaneLayout มีหน้าที่รับผิดชอบในการจัดเรียงส่วนประกอบ เครื่องมือจัดการเลย์เอาต์นี้มีหน้าที่รับผิดชอบในการตรวจสอบให้แน่ใจว่าส่วนประกอบทั้งหมดของแผงรูทถูกวางตามที่ควรจะเป็น: แผงแบบเลเยอร์จะใช้พื้นที่หน้าต่างทั้งหมด เลเยอร์ FRAME_CONTENT_LAYER มีแถบเมนูและแผงเนื้อหา และเหนือสิ่งอื่นใดคือแผงโปร่งใส

ส่วนประกอบทั้งหมดของแผงรูท JRootPaneสามารถรับหรือเปลี่ยนแปลงได้ เมื่อต้องการทำเช่นนี้ มีชุดของวิธีการรับ/ตั้งค่า โดยทางโปรแกรม JRootPaneสามารถรับได้โดยใช้เมธอด getRootPane()

นอกจากคอนเทนเนอร์ระดับบนสุดแล้ว แผงรูทยังใช้ในหน้าต่าง JInternalFrame ภายในที่สร้างขึ้นในแอปพลิเคชันหลายเอกสารและอยู่บน “เดสก์ท็อป” ของ JDesktopPane วิธีนี้ช่วยให้คุณลืมความจริงที่ว่าหน้าต่างเหล่านี้เป็นส่วนประกอบที่มีน้ำหนักเบาธรรมดาและทำงานร่วมกับหน้าต่างเหล่านั้นได้ราวกับว่าเป็นคอนเทนเนอร์ระดับบนสุดจริง

JLayeredPane

ที่ฐานของแผงรูท (คอนเทนเนอร์) จะมีแผงที่เรียกว่าหลายชั้นอยู่ JLayeredPaneครอบครองพื้นที่ว่างทั้งหมดของคอนเทนเนอร์ ในแผงนี้จะมีส่วนอื่นๆ ทั้งหมดของแผงรากอยู่ รวมถึงส่วนประกอบส่วนต่อประสานผู้ใช้ทั้งหมด

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

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

ส่วนประกอบบางอย่างใช้ความสามารถของแผงลามิเนตกันอย่างแพร่หลาย แกว่ง- มีความสำคัญอย่างยิ่งสำหรับแอปพลิเคชันหลายเอกสาร คำแนะนำเครื่องมือ และเมนู หลายเอกสาร แกว่งแอปพลิเคชันใช้คอนเทนเนอร์พิเศษ JDesktopPane("เดสก์ท็อป") ซึ่งสืบทอดมาจาก JLayeredPaneซึ่งเป็นที่ตั้งของหน้าต่างสวิงภายใน มากที่สุด ฟังก์ชั่นที่สำคัญแอปพลิเคชันหลายเอกสาร - การวางหน้าต่าง "ใช้งานอยู่" เหนือหน้าต่างอื่น ๆ ย่อขนาดหน้าต่างให้เล็กสุดลากมัน - มาจากกลไกของแผงหลายเลเยอร์ ประโยชน์หลักของการใช้แผงแบบเลเยอร์สำหรับคำแนะนำเครื่องมือและเมนูก็คือ ทำงานได้เร็วขึ้น แทนที่จะสร้างหน้าต่างที่ใช้งานหนักใหม่สำหรับคำแนะนำเครื่องมือหรือเมนูแต่ละรายการที่อยู่เหนือส่วนประกอบที่ขอคำแนะนำเครื่องมือหรือเมนู แกว่งสร้างส่วนประกอบที่รวดเร็วและมีน้ำหนักเบา ส่วนประกอบนี้วางอยู่ในที่สูงเพียงพอในแผงแบบเลเยอร์เหนือสแต็กของส่วนประกอบอื่นๆ ทั้งหมด และใช้เพื่อแสดงคำแนะนำเครื่องมือหรือเมนู

แผงหลายชั้นช่วยให้คุณสามารถจัดระเบียบเลเยอร์ได้ไม่จำกัดจำนวน โครงสร้าง JLayeredPaneประกอบด้วยเลเยอร์มาตรฐานหลายชั้นซึ่งส่วนประกอบ Swing ทั้งหมดใช้ซึ่งช่วยให้มั่นใจได้ถึงการทำงานที่ถูกต้องของกลไกทั้งหมดของแผงหลายชั้น เลเยอร์ JLayeredPane มาตรฐานจะแสดงในรูปต่อไปนี้

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

เลเยอร์ Palette ได้รับการออกแบบมาเพื่อจัดวางหน้าต่างด้วยชุดเครื่องมือ ซึ่งโดยปกติจะทับซ้อนองค์ประกอบอินเทอร์เฟซอื่นๆ คุณสามารถสร้างหน้าต่างดังกล่าวได้โดยใช้ JDesktopPane ซึ่งวางไว้บนเลเยอร์นี้

เลเยอร์ Modal มีวัตถุประสงค์เพื่อโฮสต์กล่องโต้ตอบ modal แบบน้ำหนักเบา อย่างไรก็ตามดังกล่าว กล่องโต้ตอบยังไม่ได้ถูกนำมาใช้ ดังนั้น เลเยอร์นี้จึงไม่ได้ถูกนำมาใช้ใน Swing

เลเยอร์ที่ใช้บ่อยที่สุดสำหรับการวางเมนูป๊อปอัปและคำแนะนำเครื่องมือ

ชั้นบนสุด. ออกแบบมาเพื่อการลากและวาง ( ลากและวาง drop) ซึ่งควรจะมองเห็นได้ชัดเจนในอินเทอร์เฟซของโปรแกรม

ตัวอย่างเล็กๆ ของ JLayeredPane ที่มีพาเนลแบบเลเยอร์จะแสดงวิธีเพิ่มส่วนประกอบลงในเลเยอร์ต่างๆ และวิธีที่เลเยอร์ซ้อนกันซ้อนกัน:

นำเข้า javax.swing.*; นำเข้า java.awt.*; // คลาสสำหรับการวาดภาพสองประเภทด้วยคลาสข้อความ รูปภาพขยาย JComponent ( ส่วนตัวคงที่สุดท้ายยาว serialVersionUID = 1L; สีสีส่วนตัว; ประเภท int ส่วนตัว; ข้อความสตริงส่วนตัว; // พารามิเตอร์: สีและประเภทของรูป (สีสี, int type, String text) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) public void paintComponent(Graphics g) ( // วาดรูป g.setColor(color) ; สวิตช์ (ประเภท ) ( กรณีที่ 0: g.fillOval(0, 0, 90, 90); แตก; กรณีที่ 1: g.fillRect(0, 0, 130, 80); แตก; ) g.setColor(Color.yellow ); DrawString(text, 10, 35); ) ) คลาสสาธารณะ JLayeredPaneTest ขยาย JFrame (ส่วนตัวคงที่สุดท้าย serialVersionUID = 1L; public JLayeredPaneTest() ( // สร้างหน้าต่าง super("Example LayeredTest"); // ออกเมื่อปิด หน้าต่าง setDefaultCloseOperation( EXIT_ON_CLOSE); // กำหนดแผงหลายชั้น JLayeredPane lp = getLayeredPane(); // สร้างตัวเลขสามตัว รูปที่ 1 = รูปใหม่ (Color.red, 0, "ป๊อปอัปรูป");

รูปที่ 2 = รูปใหม่ (Color.blue, 0, "รูปที่ 1"); เจเฟรมรูปที่ 3 = รูปใหม่ (Color.cyan, 1, "รูปที่ 2"); // กำหนดตำแหน่งของตัวเลขในหน้าต่าง รูปที่1.setBounds(10, 40, 120, 120);.

รูปที่2.setBounds(60, 120, 160, 180);

เมื่อกำหนดอินเทอร์เฟซ จะมีการสร้างรูปร่างสามสีที่แตกต่างกัน (วงกลมสองวงและสี่เหลี่ยม) วงกลมวางอยู่ในเลเยอร์ POPUP_LAYER และวางสี่เหลี่ยมไว้ในเลเยอร์ PALETTE_LAYER เมื่อวางส่วนประกอบ คุณจะต้องระบุพิกัดหน้าจอที่แน่นอน เนื่องจากตัวจัดการเลย์เอาต์ทั่วไปไม่ทำงานในแผงแบบเลเยอร์

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

ใน แอปพลิเคชันทั่วไปแผงหลายชั้นไม่ค่อยได้ใช้โดยตรงโดยไม่มีใครสังเกตเห็น อย่างไรก็ตาม บางครั้งการสร้างเอฟเฟกต์ที่น่าทึ่งและอินเทอร์เฟซที่ไม่ธรรมดาก็ช่วยสร้างได้ เช่น การวางแอนิเมชันหรือวิดีโอไว้เหนือส่วนประกอบทั่วไป โดยไม่ต้องใช้ความพยายามและลูกเล่นเหนือมนุษย์จากนักพัฒนา

บานหน้าต่างเนื้อหา

บานหน้าต่างเนื้อหา ContentPane เป็นส่วนถัดไปของบานหน้าต่างราก ซึ่งใช้เก็บส่วนประกอบอินเทอร์เฟซผู้ใช้ของโปรแกรม บานหน้าต่างเนื้อหาใช้พื้นที่ส่วนใหญ่ของแผงแบบเลเยอร์ (ยกเว้นพื้นที่ที่แถบเมนูครอบครอง) เพื่อป้องกันไม่ให้แผงเนื้อหาบดบังส่วนประกอบที่ถูกเพิ่มลงในหน้าต่างในเวลาต่อมา แผงที่มีเลเยอร์จะวางแผงเนื้อหาไว้ในเลเยอร์พิเศษที่ต่ำมากที่เรียกว่า FRAME_CONTENT_LAYER ซึ่งมีหมายเลข -30000

คุณสามารถเข้าถึงแผงเนื้อหาได้โดยใช้วิธีการ getContentPane()คลาส JFrame เมื่อใช้เมธอด add(Component Component) คุณสามารถเพิ่มองค์ประกอบควบคุมใดๆ ลงไปได้ แทนที่ บานหน้าต่างเนื้อหากับพาเนลประเภท JPanel อื่น ๆ ที่คุณสามารถใช้วิธีนี้ได้ setContentPane()

ตัวอย่างการเพิ่มปุ่มลงในแผงเนื้อหา:

JButton newButton = JButton ใหม่ (); getContentPane().add(ปุ่มใหม่);

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

สามารถเปลี่ยนแผงเนื้อหาได้อย่างสมบูรณ์ พิจารณาสิ่งต่อไปนี้ แกว่งตัวอย่างการใช้แผงเนื้อหา บานหน้าต่างเนื้อหา.

นำเข้า javax.swing.*; คลาสสาธารณะ ContentPaneReplace ขยาย JFrame (ส่วนตัวคงที่สุดท้ายสุดท้าย serialVersionUID = 1L; public ContentPaneReplace() ( super("Test ContentPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // สร้างพาเนลที่มีสองปุ่ม เนื้อหา JPanel = ใหม่ JPanel(); เนื้อหา เพิ่ม (JButton ใหม่ ("Family")); contents.add (JButton ใหม่ ("School")); // การเปลี่ยนแผงเนื้อหา setContentPane (เนื้อหา); // การกำหนดขนาดของหน้าต่าง setSize (200, 100) ; (จริง); โมฆะสาธารณะหลัก (String args) ( JFrame.setDefaultLookAndFeelDecorated(true); new ContentPaneAdd(); ) )

ตัวอย่างนี้จะสร้างหน้าต่างเล็กๆ และแผงที่มีปุ่มสองปุ่ม ซึ่งก็คือ setContentPane()แทนที่แผงเนื้อหาของหน้าต่าง จึงมีการใช้สิ่งทดแทนแทนมากขึ้น นอกจากนี้ง่ายๆ- เรียกใช้เมธอด add() อินเทอร์เฟซของหน้าต่างจะแสดงในภาพหน้าจอต่อไปนี้

แผงเนื้อหา บานหน้าต่างเนื้อหาตัวมันเองไม่มีอะไรพิเศษ คุณเพียงแค่ต้องจำไว้ว่ามีการเพิ่มส่วนประกอบเข้าไปโดยเฉพาะ

JOptionPane โปร่งใส

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

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

แผงโปร่งใสสามารถใช้ได้ในกรณีใดบ้าง? JOptionPane- ด้วยความช่วยเหลือนี้ คุณสามารถระบุฟังก์ชันของแอปพลิเคชันที่ต้องใช้ความพยายามอย่างมากในการปรับใช้ตั้งแต่เริ่มต้น แผงโปร่งใสสามารถปรับให้เหมาะกับการทดสอบส่วนต่อประสานกับผู้ใช้แบบอัตโนมัติ เหตุการณ์ที่สังเคราะห์ขึ้นในนั้นทำให้คุณสามารถติดตามผลการแก้ไขจุดบกพร่องระดับกลางได้ บางครั้งแนวทางนี้มีประสิทธิภาพมากกว่าการทดสอบด้วยตนเองมาก

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

ตัวอย่างการใช้ Swing JOptionPane แบบโปร่งใส:

// การใช้แผงโปร่งใส JOptionPane นำเข้า java.awt.Dimension; นำเข้า java.awt.Font; นำเข้า java.awt.event.WindowEvent; นำเข้า java.awt.event.WindowListener; นำเข้า javax.swing.JDialog; นำเข้า javax.swing.JFrame; นำเข้า javax.swing.JLabel; นำเข้า javax.swing.JOptionPane; นำเข้า javax.swing.UIManager; คลาสสาธารณะ JOptionPaneTest ขยาย JFrame (ส่วนตัวคงที่สุดท้ายแบบยาว serialVersionUID = 1L; สาธารณะคงที่สุดท้าย ฟอนต์ ฟอนต์= แบบอักษรใหม่ ("Verdana", Font.PLAIN, 11);

โมฆะสาธารณะคงที่ createGUI() ( JFrame frame = new JFrame("Test JOptionPane"); frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); frame.addWindowListener(new WindowListener() ( โมฆะสาธารณะ windowActivated (เหตุการณ์ WindowEvent) () โมฆะสาธารณะ windowClosed( เหตุการณ์ WindowEvent) () โมฆะสาธารณะ windowDeactivated (เหตุการณ์ WindowEvent) () โมฆะสาธารณะ windowDeiconified (เหตุการณ์ WindowEvent) () โมฆะสาธารณะ windowIconified (เหตุการณ์ WindowEvent) () โมฆะสาธารณะ windowOpened (เหตุการณ์ WindowEvent) () โมฆะสาธารณะ windowClosing (เหตุการณ์ WindowEvent) ( วัตถุ options = ("ใช่", "ไม่!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "ปิดหน้าต่าง?", "ยืนยัน", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, ตัวเลือก, ตัวเลือก) ; if (rc == 0) ( event.getWindow().setVisible(false); System.exit(0); ) )); JLabel label = new JLabel("การใช้แผงโปร่งใสเมื่อปิดหน้าต่าง"); ().เพิ่ม(ฉลาก); frame.setPreferredSize(มิติข้อมูลใหม่ (350, 80)); กรอบ.แพ็ค(); frame.setLocationRelativeTo(null); frame.setVisible(จริง);) โมฆะสาธารณะคงหลัก (String args) ( javax.swing.SwingUtilities.invoidLater (new Runnable () ( public void run () ( UIManager.put ("Button.font", FONT); UIManager.put ("Label.font ", FONT); JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); createGUI(); ) )); ) ) หากคุณส่งผ่านค่าคงที่ไปยังเมธอด setDefaultCloseOperation JFrame.EXIT_ON_CLOSE

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

แถบเมนู JMenuBar

หนึ่งในคุณสมบัติที่สำคัญของการใช้ JRootPane ใน Swing คือความจำเป็นในการวางแถบเมนูในหน้าต่าง เจเมนูบาร์- ไม่สามารถสร้างแอปพลิเคชันที่จริงจังได้หากไม่มีเมนูบางประเภทเพื่อเข้าถึงฟังก์ชันของโปรแกรม ไลบรารี Swing มอบความสามารถที่ยอดเยี่ยมสำหรับการสร้างเมนู JMenuBar ที่ใช้งานง่ายซึ่งเป็นส่วนประกอบที่มีน้ำหนักเบา

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

แผงรากช่วยให้แน่ใจว่าแผงเนื้อหาและแถบเมนู เจเมนูบาร์ไม่ทับซ้อนกัน หากไม่จำเป็นต้องใช้แถบเมนู แผงรูทจะใช้พื้นที่ทั้งหมดเพื่อรองรับแผงเนื้อหา

ตัวอย่างการสวิง

สามารถดาวน์โหลดซอร์สโค้ดของตัวอย่างที่กล่าวถึงในข้อความของเพจได้

เราเดาว่าเราคงทำให้คุณเบื่อหน่ายด้วยการพูดคุยตลอดเวลาเกี่ยวกับโปรแกรมเอาท์พุต ข้อความไปที่คอนโซล ในบทเรียนนี้ ชุดตัวอย่างที่ "น่าเบื่อ" นี้จะถูกขัดจังหวะในที่สุด: เราจะแสดงให้เห็นว่า windows ถูกสร้างขึ้นอย่างไรใน Java และคุณจะเห็นว่านี่เป็นงานง่ายๆ นี่คือโค้ดของเรา (เราจะเริ่มพูดคุยกันในบทเรียนถัดไป เนื่องจากมีฟีเจอร์มากมายที่คุณจำเป็นต้องรู้จริงๆ):

นำเข้า java.awt.*;

นำเข้า javax.swing.*;

MoneyForNothing คลาสสาธารณะขยาย JFrame (

// ตัวสร้าง

MoneyForNothing สาธารณะ () (

setTitle("ยินดีต้อนรับสู่ Money for Nothing");

setSize(มิติใหม่(600, 400));

setDefaultCloseOperation(EXIT_ON_CLOSE);

setVisible (จริง);

โมฆะคงที่สาธารณะหลัก (String args) (

MoneyForNothing mfn = ใหม่ MoneyForNothing();

และนี่คือรหัสเดียวกันในหน้าต่างแก้ไข FAR:

อย่างไรก็ตาม เราขอแนะนำให้คุณพิมพ์ซอร์สโค้ดของโปรแกรมในการเข้ารหัส CP1251 ทันที (หรือสำนวนทั่วไปใน การเข้ารหัสวินโดวส์): การสลับการเข้ารหัสทำได้โดยการกดปุ่ม F8 และการเข้ารหัสปัจจุบันจะแสดงในแถบสถานะเหนือพื้นที่แก้ไข

จุดเริ่มต้นยังคงไม่เปลี่ยนแปลง แต่โค้ดที่เหลือเปลี่ยนไปไม่น้อย (แต่อย่าก้าวไปข้างหน้า) เมื่อคอมไพล์และรันแล้วคุณจะเห็นสิ่งต่อไปนี้:

ยินดีด้วย เพียงไม่กี่บรรทัด คุณก็ได้สร้างหน้าต่างกราฟิกจริงขึ้นมาแล้ว! สามารถลาก ปรับขนาด ยุบ ขยาย และปิดได้ จริงอยู่ที่หน้าต่างของเราค่อนข้างจางลงถ้าพูดตรงๆ - "น่ากลัว" นอกจากนี้หน้าต่างจะแสดงที่มุมซ้ายบนของหน้าจอ แต่ฉันต้องการให้อยู่ตรงกลาง - สะดวกกว่าในการใช้งานและเอาต์พุตนี้ดูดีกว่า เลยมาขัดเกลากันสักหน่อย

ก่อนอื่นมาแก้ไขปัญหาที่สองกันก่อน - จัดหน้าต่างให้อยู่ตรงกลาง เราขอแนะนำให้หยุดและคิด - คุณจะทำเช่นนี้ได้อย่างไร?

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

สิ่งที่จำเป็นในการวางหน้าต่างไว้ตรงกลางคือการทราบขนาดของหน้าต่างเอง (โดยวิธีการระบุไว้ในโปรแกรมออกแบบและสร้างสี่เหลี่ยมขนาด 600 x 400 พิกเซล) และความละเอียดของหน้าจอจากนั้นใช้ เลขคณิตอย่างง่าย คำนวณพิกัดที่จำเป็นทางด้านซ้าย มุมบน- ทำได้โดยการใส่โค้ดต่อไปนี้

มิติข้อมูล sSize = Toolkit.getDefaultToolkit().getScreenSize(),

fSize = getSize();

ถ้า (fSize.height > sSize.height) (fSize.height = sSize.height;)

ถ้า (fSize.width > sSize.width) (fSize.width = sSize.width;)

setLocation((sSize.width - fSize.width)/2,

(sSize.height - fSize.height)/2);

ทันทีหลังบรรทัด setSize(new Dimension(600, 400)); ในตัวสร้าง ทำการเปลี่ยนแปลงซอร์สโค้ดที่จำเป็น คอมไพล์โปรแกรมและรัน หน้าต่างควรปรากฏขึ้นที่กึ่งกลางของหน้าจอมอนิเตอร์

ตอนนี้บางคำเกี่ยวกับรูปลักษณ์ของหน้าต่าง ลักษณะที่แปลกของมันอธิบายได้จากข้อเท็จจริงที่นักพัฒนา Java พยายามทำให้แน่ใจว่า โดยไม่คำนึงถึงแพลตฟอร์มฮาร์ดแวร์และซอฟต์แวร์ที่ "เติมเต็ม" องค์ประกอบกราฟิกทั้งหมด (หน้าต่าง ปุ่ม รายการ ฯลฯ) มีการเรนเดอร์เดียวและเป็นหนึ่งเดียว โทนสี- ด้วยเหตุนี้พวกเขาจึงพัฒนาสไตล์พิเศษที่เรียกว่า "METAL" หากนักพัฒนาไม่ได้ใช้ความพยายามเป็นพิเศษ องค์ประกอบอินเทอร์เฟซแบบกราฟิกในโปรแกรมของเขาจะมีลักษณะในลักษณะนี้อย่างแน่นอน โดยไม่คำนึงถึงลักษณะของคอมพิวเตอร์เฉพาะและซอฟต์แวร์ของพวกเขา ในบางกรณี สิ่งนี้ก็สมเหตุสมผล แต่ถึงกระนั้น คุณจะเห็นด้วยว่ามันจะดีกว่ามากหากโปรแกรมที่เปิดบน Windows คล้ายกับโปรแกรม Windows และอีกโปรแกรมหนึ่งที่เปิดตัวบน LINUX ก็คล้ายกับโปรแกรม Linux นี่เป็นเรื่องง่ายที่จะบรรลุผล สิ่งที่คุณต้องทำคือใส่โค้ดต่อไปนี้ในจุดเริ่มต้นก่อนสร้างอินสแตนซ์ของคลาส:

ลอง (UIManager.setLookAndFeel

(UIManager.getSystemLookAndFeelClassName());

จับ (ยกเว้น lfe) ()

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

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

ตรวจสอบว่าทุกอย่างทำงานได้ตามที่คาดไว้: หน้าต่างจะปรากฏขึ้นตรงกลางหน้าจอและดูเป็นไปตามที่คาดไว้

นี่เป็นการสรุปบทเรียนแรกของเราเกี่ยวกับอินเทอร์เฟซแบบกราฟิก ในนั้นเราได้แสดงให้เห็น "ส่วนหน้า" แต่ได้ละทิ้งประเด็นต่างๆ มากมายที่มีความสำคัญอย่างยิ่ง และหากไม่มีการเขียนโปรแกรมใน Java โดยทั่วไปและอินเทอร์เฟซแบบกราฟิกโดยเฉพาะก็เป็นไปไม่ได้ เราจะเริ่มจัดการกับปัญหาเหล่านี้ในบทเรียนถัดไป แต่สำหรับตอนนี้ ลองเล่นเรื่องนี้ก่อน ซอร์สโค้ดซึ่งก็คือ

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

แบบฝึกหัดอื่นทำได้ง่ายกว่า แต่คุณต้องใช้เอกสารประกอบ (คุณต้องเริ่มสักครั้งจริงๆ): ทำจนไม่สามารถปรับขนาดหน้าต่างได้เช่น ไปยังพื้นที่ ปุ่มระบบดูเหมือนในภาพ

(คำแนะนำ: ค้นหาคำหลัก javax และ JFrame) ดังนั้น พับแขนเสื้อขึ้นแล้วขอให้โชคดี!

ความคิดเห็น

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

เนื่องจากเราเปิดตัวโปรแกรมสำหรับการดำเนินการจาก FAR การขัดจังหวะการทำงานของโปรแกรม Java สามารถทำได้โดยการกดคีย์ผสม Control-C (ในที่นี้ "C" คือตัวอักษรละติน อย่าสับสนกับตัวอักษรซีริลลิกที่คล้ายกัน)

JFace เป็นเลเยอร์นามธรรมเพิ่มเติม ไลบรารีกราฟิก SWT ซึ่งมีความสามารถในการพัฒนาอินเทอร์เฟซแอปพลิเคชันแบบกราฟิกตามโมเดล MVC (Model View Controller) ส่วนประกอบหลักของ JFace ได้แก่ :

• ผู้ดู - คลาสสำหรับห่อหุ้มงานการจัดหาข้อมูลสำหรับการแสดงผล การกรอง การเรียงลำดับ ฯลฯ
• การดำเนินการและการมีส่วนร่วม - แนะนำความหมายสำหรับการอธิบายการกระทำของผู้ใช้และวิธีที่ผู้ใช้ควรใช้งานได้
• การลงทะเบียนรูปภาพและแบบอักษร - จัดเตรียมคลาสสำหรับการจัดการทรัพยากร เช่น รูปภาพและแบบอักษร
• กล่องโต้ตอบและวิซาร์ด - เฟรมเวิร์กสำหรับสร้างการโต้ตอบโต้ตอบที่ซับซ้อนกับผู้ใช้
• ความช่วยเหลือภาคสนาม—มีตัวเลือกในการใช้ฟังก์ชันช่วยเหลือสำหรับฟิลด์ เช่น การแสดงสถานะของฟิลด์หรือคำแนะนำเนื้อหา

ส่วนแรกจะกล่าวถึงการสร้างหน้าต่างอย่างง่ายโดยใช้ JFace โดยเพิ่มเมนู แถบสถานะ และแถบเครื่องมือลงไป

การตั้งค่าโครงการ

เพื่อที่จะพัฒนา แอปพลิเคชั่นกราฟิกเมื่อใช้ JFace ใน Eclipse คุณจะต้องรวมไฟล์ jar SWT และ JFace

• หากติดตั้ง PDE ใน Eclipse สามารถทำได้โดยการระบุในการตั้งค่าโปรเจ็กต์เพื่อใช้ไลบรารี SWT และทำเครื่องหมายที่ช่องสำหรับการสนับสนุน JFace
• หากไม่ได้ติดตั้ง PDE คุณต้องเชื่อมต่อไฟล์ jar กับโปรเจ็กต์ด้วยตนเอง คุณสามารถค้นหาได้ในไดเร็กทอรีปลั๊กอิน Eclipse ซึ่งเรียกว่า org.eclipse.swt_*.jar และ org.eclipse.jface_*.jar

การสร้างหน้าต่าง

หน้าต่างแอปพลิเคชันใน JFace สืบทอดมาจากคลาส ApplicationWindow ซึ่งมีความสามารถในการสร้างเมนู แผงควบคุม และแถบสถานะ

วิธีที่ง่ายที่สุดในการสร้างหน้าต่างมีดังต่อไปนี้:

นำเข้า org.eclipse.jface.window.ApplicationWindow; นำเข้า org.eclipse.swt.widgets.Display; MainWindow ระดับสาธารณะขยาย ApplicationWindow ( public static void main(String args) ( MainWindow window = new MainWindow(); // สร้างหน้าต่างของเรา window.setBlockOnOpen(true); // ตั้งค่าสถานะ - รอให้หน้าต่างปิด window.open (); / / เปิดหน้าต่าง Display.getCurrent().dispose(); // Release resources ) public MainWindow() ( super(null); // เรียก Constructor ของคลาส parent )

การสร้างเนื้อหาหน้าต่าง

ในการสร้างเนื้อหาหน้าต่างบางส่วน คุณต้องแทนที่เมธอด Control createContents(Composite parent) ของคลาส ApplicationWindow วิธีการจะต้องส่งคืนส่วนประกอบที่จะเป็นเนื้อหาของหน้าต่าง

ในวิธีเดียวกัน คุณสามารถตั้งชื่อหน้าต่างได้โดยการเรียกเมธอด setText(String text) ของเชลล์ ซึ่งสามารถเข้าถึงได้โดยการเรียก getShell()

ในตัวอย่างนี้ ส่วนประกอบดังกล่าวจะเป็น white label ใน การใช้งานจริงส่วนประกอบดังกล่าวเป็นส่วนประกอบชนิดหนึ่ง

จริงๆแล้วตัวอย่าง:

ป้องกันการควบคุม createContents (พาเรนต์คอมโพสิต) ( getShell (). setText ( "หน้าต่างของฉัน"); // ตั้งชื่อหน้าต่างป้ายกำกับ lbl = ป้ายกำกับใหม่ (พาเรนต์, SWT.NONE); // สร้าง องค์ประกอบใหม่ในกรณีของเรา - เพียงแค่ป้ายกำกับ lbl.setText("เนื้อหาหน้าต่าง"); // ตั้งค่าข้อความ lbl.setBackground(สีใหม่(Display.getCurrent(), 255, 255, 255)); // ติดตั้ง สีขาวพื้นหลังส่งคืน lbl; -

การเพิ่มบรรทัดสถานะ

การเพิ่มแถบสถานะลงในหน้าต่างแอปพลิเคชันไม่ใช่เรื่องง่าย แต่ง่ายมาก ในการดำเนินการนี้ คุณเพียงแค่ต้องเรียกใช้เมธอดที่มีการป้องกัน addStatusBar() อาจเป็นสถานที่ที่เหมาะสมที่สุดสำหรับการเรียกดังกล่าวคือตัวสร้างหน้าต่างหรือวิธีการบางอย่างในการเริ่มต้น

ในการแสดงข้อความในบรรทัดสถานะ คุณจะต้องเรียกใช้เมธอด setStatus(String status) ซึ่งเป็นอาร์กิวเมนต์ที่เป็นสตริงเดียวที่ต้องแสดง

การสร้างเมนู

หากต้องการสร้างแถบเมนูใน JFace คุณต้องเรียกใช้เมธอด addMenuBar() เช่นเดียวกับการสร้างแถบสถานะ
แต่คุณต้องเพิ่มรายการเมนูลงในแผงควบคุม ทำได้ดังนี้:

• ส่วนเมนูอธิบายโดยคลาส MenuManager ใน Constructor สามารถส่งผ่านสตริงได้ - ชื่อของส่วนโดยที่อักขระ "&" ​​หมายความว่าอักขระที่ตามมาจะเป็นคีย์เมื่อนำทางโดยใช้ ปุ่ม Alt- ส่วนเมนูจะถูกเพิ่มลงในพาเนลโดยใช้โครงสร้าง getMenuBar().add(menu)
• รายการเมนูอธิบายโดยคลาส Action คลาสนั้นเป็นนามธรรม รายการเมนูจะต้องสืบทอดจากคลาสนั้นและแทนที่เมธอด void run() ซึ่งเก็บโค้ดที่จะถูกดำเนินการเมื่อผู้ใช้เลือกรายการเมนู ที่จริงแล้ว ไม่จำเป็นต้องแทนที่เมธอด แต่เหตุใดจึงต้องมีรายการเมนูนี้ =) ชื่อของไอเท็มสามารถตั้งค่าได้โดยการส่งผ่านไปยังตัวสร้าง หรือโดยการเรียกเมธอด setText (ข้อความสตริง) เมื่อสร้างแล้ว รายการเมนูจะถูกเพิ่มไปยังส่วนโดยการเรียกวิธีการเพิ่มบนออบเจ็กต์ส่วนเมนู ตัวอย่างเช่น: menu.add(menuItem)
• เมนูย่อยถูกสร้างขึ้นอย่างง่ายดาย: คุณต้องเพิ่มส่วนอื่นให้กับส่วนหนึ่งของเมนูโดยใช้วิธีเพิ่ม แค่นั้นแหละ.

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

โมฆะส่วนตัว createMenu() ( addMenuBar(); // เพิ่มแถบเมนู MenuManager fileMenu = new MenuManager("&File"); // สร้างเมนูใหม่ getMenuBarManager().add(fileMenu); // เพิ่มเมนูลงในแผงควบคุม fileMenu.add( new Separator()); // เพิ่มตัวคั่นให้กับเมนู fileMenu.add(new Action("&Hello") ( // สร้างแอคชั่นใหม่, ระบุข้อความ @Override public void run() ( // รหัสดำเนินการเมื่อเปิดใช้งาน setStatus( "Hello world!!"); // เราเพียงแสดงค่าใหม่ในบรรทัดสถานะ ) )); // และเพิ่มการกระทำเป็นรายการเมนู)

การสร้างแถบเครื่องมือ

ในการสร้างแถบเครื่องมือในหน้าต่าง คุณต้องเรียกใช้เมธอด addToolBar(int style) ในตัวสร้างหน้าต่าง ซึ่งคุณส่งสไตล์ของส่วนประกอบพาเนลไป

ในการเข้าถึงแถบที่สร้างขึ้น จะใช้เมธอด getToolBarManager() หากต้องการเพิ่มการดำเนินการลงในแผง ให้ใช้วิธีการเพิ่มของแผงที่จะส่งการดำเนินการ

ในกรณีที่ง่ายที่สุด การสร้างแผงและเพิ่มปุ่มจะมีลักษณะดังนี้:

โมฆะส่วนตัว createToolBar() ( addToolBar(SWT.NONE); getToolBarManager().add(new Action("&Hello") ( // Create a new action, ระบุข้อความ @Override public void run() ( // Code Executed upon การดำเนินการเปิดใช้งาน setStatus("Hello world!!"); // เราเพียงแค่แสดงค่าใหม่ในบรรทัดสถานะ ) ));

การสร้างแถบเครื่องมือลอยหลายอัน

แทนที่จะสร้างแถบเครื่องมือเดียว คุณสามารถสร้างชุดแผงแบบเคลื่อนย้ายได้ (CoolBar) ในการทำเช่นนี้คุณต้องมี:

1. แทนที่จะใช้เมธอด addToolBar ให้เรียกเมธอด addCoolBar
2. หากต้องการเข้าถึงชุดของพาเนล ให้ใช้เมธอด getCoolBarManager()
3. สร้างแถบเครื่องมือที่คุณสามารถเพิ่มการดำเนินการได้ ในการดำเนินการนี้ คุณจะต้องสร้างอินสแตนซ์ใหม่ของคลาส ToolBarManager ซึ่งจะเป็นตัวแทนของพาเนลและเรียกใช้เมธอด CoolBarManager add โดยส่งพาเนลไปที่นั่น
4. คุณสามารถเพิ่มการกระทำลงในแผงที่สร้างขึ้นได้

โค้ดตัวอย่างที่สร้างแผงลอยสองแผง:

โมฆะส่วนตัว createCoolbar() ( addCoolBar(SWT.NONE); ToolBarManager tm = new ToolBarManager(); getCoolBarManager().add(tm); tm.add(helloAction); ToolBarManager tm2 = new ToolBarManager(); getCoolBarManager().add (tm2); (tm2.add(สวัสดีการกระทำ);

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

ปัญหาที่เป็นไปได้

นี่คือปัญหาบางอย่างที่คุณอาจพบ:

• เมื่อเพิ่มรายการเมนูหลังจากเปิดแอปพลิเคชัน รายการเหล่านั้นจะไม่ปรากฏขึ้น— เพื่อให้การเปลี่ยนแปลงเมนูปรากฏบนหน้าต่างหลังจากสร้างหน้าต่างแล้ว คุณต้องเรียกใช้เมธอด getMenuBarManager().อัพเดต(จริง)— ระบุเพื่ออัพเดตแถบเมนู

ลิงค์

ข้อมูลเพิ่มเติมเกี่ยวกับ JFace สามารถพบได้ที่ลิงค์ต่อไปนี้:

• บทความเบื้องต้นภาษารัสเซียบน ibm.com
• ชุดบทความภาษาอังกฤษบน ibm.com
• คำอธิบายของ Eclipse API - เหนือสิ่งอื่นใด มีแพ็คเกจที่เกี่ยวข้องกับ SWT และ JFace

Java มี 2 แพ็คเกจหลักสำหรับการสร้างส่วนต่อประสานกราฟิกกับผู้ใช้ เหล่านี้คือ Abstract Windows Toolkit (AWT) และ Swing AWT ใช้วิดเจ็ตระบบปฏิบัติการ ดังนั้นไลบรารีนี้จึงเร็วขึ้นเล็กน้อย แต่ในความคิดของฉัน Swing ออกแบบได้ดีกว่า

ในบทช่วยสอนนี้ เราจะดูองค์ประกอบพื้นฐานของไลบรารี Swing และสร้างอินเทอร์เฟซแบบง่าย (GUI) เป็นตัวอย่าง

คอนเทนเนอร์ถูกใช้เพื่อจัดกลุ่มส่วนประกอบอินเทอร์เฟซ ในการสร้างคอนเทนเนอร์หลักสำหรับแอปพลิเคชัน คอนเทนเนอร์ JFrame มักถูกใช้บ่อยที่สุด (ยังมี JWindows และ JApplet อีกด้วย) วิธีที่ง่ายที่สุดคือการสืบทอดจาก JFrame และด้วยเหตุนี้จึงสามารถเข้าถึงวิธีการต่างๆ ได้มากมาย เช่น:

setBounds(x, y, w, h) - ระบุพิกัดของจุดยอดซ้ายบนของหน้าต่าง รวมถึงความกว้างและความสูง

setResizable(bool) - ระบุว่าหน้าต่างสามารถปรับขนาดได้หรือไม่

setTitle(str) - ตั้งชื่อหน้าต่าง

setVisible(bool) - แสดงหน้าต่างจริง ๆ

setDefaultCloseOperation(operation) - ระบุการดำเนินการที่จะดำเนินการเมื่อปิดหน้าต่าง

การควบคุมหลัก:

• JLabel - องค์ประกอบสำหรับการแสดงข้อความคงที่
• JTextField - กล่องแก้ไขอย่างง่าย;
• JButton - ปุ่มปกติ (ปุ่ม);
• JCheckBox - องค์ประกอบการเลือก (คล้ายกับช่องทำเครื่องหมาย);
• JRadioButton - ปุ่มตัวเลือก

อย่างที่คุณเห็นทุกอย่างค่อนข้างเรียบง่ายและสมเหตุสมผล

เมื่อแสดงส่วนควบคุม จะใช้ผู้จัดการพิเศษ - LayoutManager LayoutManagers ทั้งหมดมีวิธีในการเพิ่มและลบองค์ประกอบ

FlowLayout - ใช้เพื่อแสดงองค์ประกอบตามลำดับ หากองค์ประกอบไม่พอดีกับบรรทัดใดบรรทัดหนึ่ง องค์ประกอบนั้นจะปรากฏในบรรทัดถัดไป

GridLayout - แสดงองค์ประกอบในรูปแบบของตารางที่มีขนาดเซลล์เท่ากัน

BorderLayout - ใช้เมื่อแสดงองค์ประกอบไม่เกิน 5 องค์ประกอบ องค์ประกอบเหล่านี้ตั้งอยู่ตามขอบของกรอบและตรงกลาง: เหนือ ใต้ ตะวันออก ตะวันตก ตรงกลาง

BoxLayout - แสดงองค์ประกอบในแถวหรือคอลัมน์

GridBagLayout - ช่วยให้คุณสามารถกำหนดตำแหน่งและขนาดของแต่ละวิดเจ็ตได้ นี่เป็นประเภทการแสดงผลที่ซับซ้อนที่สุด แต่ก็เป็นประเภทการแสดงผลที่มีประสิทธิภาพมากที่สุดด้วย

นอกจากนี้ยังควรให้ความสนใจกับการจัดการเหตุการณ์ด้วย สำหรับสิ่งนี้ จะใช้สิ่งที่เรียกว่า Event Listeners

เอาล่ะ ทฤษฎีเพียงพอแล้ว มาดูตัวอย่าง GUI กัน:

นำเข้า java.awt.*; นำเข้า java.awt.event.*; นำเข้า javax.swing.*; SimpleGUI คลาสสาธารณะขยาย JFrame (ปุ่ม JButton ส่วนตัว = JButton ใหม่ ("กด"); อินพุต JTextField ส่วนตัว = JTextField ใหม่ ("", 5); ป้ายกำกับ JLabel ส่วนตัว = JLabel ใหม่ ("อินพุต:"); ส่วนตัว JRadioButton radio1 = ใหม่ JRadioButton ("เลือกสิ่งนี้"); ส่วนตัว JRadioButton radio2 = ใหม่ JRadioButton("เลือกนั้น"); ส่วนตัว JCheckBox ตรวจสอบ = ใหม่ JCheckBox("ตรวจสอบ", false); สาธารณะ SimpleGUI() ( super("Simple Example"); this.setBounds (100,100,250,100); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); คอนเทนเนอร์คอนเทนเนอร์ = this.getContentPane(); radio2); radio1.setSelected(true); box.addActionListener(new ButtonEventListener()); คลาส ButtonEventListener ใช้ ActionListener ( public void actionPerformed(ActionEvent e) ( ข้อความสตริง = "";

ข้อความ += "กดปุ่มแล้ว\n";

ข้อความ += "ข้อความคือ " + input.getText() + "\n"; ข้อความ += (radio1.isSelected()?"Radio #1:"Radio #2") + " ถูกเลือก\n";ข้อความ += "ช่องทำเครื่องหมายคือ " + ((check.isSelected()) ?"checked":ไม่ถูกเลือก");

คลาสภายใน ButtonActionListener ใช้อินเทอร์เฟซ ActionListener ในการดำเนินการนี้ คุณจะต้องจัดเตรียมการใช้งานเมธอด actionPerformed

JOptionPane ใช้เพื่อแสดงกล่องโต้ตอบ

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