กระบวนการพัฒนาโปรแกรม GUI อย่างง่ายใน Java การสร้าง GUI ใน Java การสร้างแอปพลิเคชัน GUI ใน Java

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

จาวา AWT

ความพยายามครั้งแรกของซันที่จะสร้าง กุยมีห้องสมุดสำหรับ 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 ได้เป็นอย่างดี

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

หากต้องการสร้างแอปพลิเคชัน GUI คุณต้องใช้ส่วนประกอบไลบรารี 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เป็นคอนเทนเนอร์ที่สืบทอดมาจากคลาสฐาน Swing JComponent ในคอนเทนเนอร์นี้ ตัวจัดการโครงร่างพิเศษที่นำไปใช้ในคลาสภายใน RootPaneLayout มีหน้าที่รับผิดชอบในการจัดเรียงส่วนประกอบ เครื่องมือจัดการเลย์เอาต์นี้มีหน้าที่รับผิดชอบในการตรวจสอบให้แน่ใจว่าส่วนประกอบทั้งหมดของแผงรูทถูกวางตามที่ควรจะเป็น: แผงแบบเลเยอร์จะใช้พื้นที่หน้าต่างทั้งหมด เลเยอร์ FRAME_CONTENT_LAYER มีแถบเมนูและแผงเนื้อหา และเหนือสิ่งอื่นใดคือแผงโปร่งใส

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

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

JLayeredPane

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

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

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

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

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

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

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

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

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

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

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

นำเข้า javax.swing.*; นำเข้า java.awt.*; // คลาสสำหรับการวาดภาพสองประเภทด้วยคลาสข้อความ รูปภาพขยาย JComponent (ส่วนตัวแบบคงที่สุดท้ายแบบยาว serialVersionUID = 1L; ส่วนตัว สีสี- ประเภท int ส่วนตัว

ข้อความสตริงส่วนตัว เจเฟรม// พารามิเตอร์: สีและประเภทของรูป รูปภาพ(สีสี, ประเภท int, ข้อความสตริง) ( this.color = color; this.type = type; this.text = text; setOpaque(false); ) โมฆะสาธารณะ paintComponent(Graphics g ) ( // วาดรูป g.setColor(color); switch (type) ( case 0: g.fillOval(0, 0, 90, 90); break; case 1: g.fillRect(0, 0, 130) , 80 ); ) g.setColor(Color.yellow); g.drawString(ข้อความ, 10, 35); super("Example LayeredTest"); // ออกเมื่อปิดหน้าต่าง setDefaultCloseOperation(EXIT_ON_CLOSE); แผงแบบเลเยอร์ JLayeredPane lp = getLayeredPane(); // สร้างตัวเลขสามตัว รูปที่ 1 = รูปใหม่ (Color.red , 0, "ป๊อปอัปรูป"); ; รูปที่ 3 = รูปใหม่ (Color.cyan, 1, "รูปที่ 2"); // กำหนดตำแหน่งของตัวเลขในหน้าต่าง รูปที่ 1.setBounds (10, 40, 120, 120); รูปที่2.setBounds(60, 120, 160, 180);.

รูปที่3.setBounds(90, 55, 250, 180);

// เพิ่มรูปร่างให้กับเลเยอร์ต่างๆ lp.add(figure1, JLayeredPane.POPUP_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")); content.add (JButton ใหม่ ("School")); // การเปลี่ยนแผงเนื้อหา setContentPane (เนื้อหา); // การกำหนดขนาดหน้าต่าง setSize (200, 100); จริง); โมฆะสาธารณะคงที่ main (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; สาธารณะคงที่ขั้นสุดท้ายแบบอักษร FONT = แบบอักษรใหม่ ("Verdana", Font.PLAIN, 11); โมฆะคงที่สาธารณะ createGUI () ( JFrame frame = ใหม่ JFrame ("ทดสอบ 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) ( ตัวเลือกวัตถุ = ( "ใช่", "ไม่!" ); int rc = JOptionPane.showOptionDialog(event.getWindow(), "ปิดหน้าต่าง?", "ยืนยัน", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, ตัวเลือก, ตัวเลือก); if (rc == 0) ( event.getWindow().setVisible (เท็จ); System.exit (0);

ป้ายกำกับ JLabel = JLabel ใหม่ ("ใช้แผงโปร่งใสเมื่อปิดหน้าต่าง"); frame.getContentPane().add(ฉลาก); 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(); ) )); ) )

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

แถบเมนู JMenuBar

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

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

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

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

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

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

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

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

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

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

คลาสสาธารณะหลัก ( โมฆะสาธารณะคงที่ 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(new MyButtonListener()); เพื่อป้องกันไม่ให้ตัวจัดการของเราไร้ความหมาย ให้เพิ่มโค้ดต่อไปนี้ในเมธอด การกระทำที่ดำเนินการแล้ว():

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

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

คำอธิบายของการนำเสนอ การสร้างส่วนต่อประสานกราฟิกในไลบรารี Java Graphic สำหรับสไลด์

Java Graphics Libraries Java มีแพ็คเกจต่อไปนี้สำหรับการสร้างอินเทอร์เฟซแบบกราฟิก: Abstract Windows Toolkit (AWT) - มาพร้อมกับ JDK ส่วนประกอบ AWT แต่ละรายการมีองค์ประกอบภาพของตัวเอง (เพียร์) สำหรับระบบปฏิบัติการเฉพาะ ความสามารถในการพกพามีให้โดยแพ็คเกจ java เอาล่ะ เพื่อน; ชุดส่วนประกอบกราฟิกที่จำกัด ลักษณะที่ปรากฏขึ้นอยู่กับระบบปฏิบัติการ ชุดเครื่องมือวิดเจ็ตมาตรฐาน (SWT) - จัดหาแยกต่างหากสำหรับระบบปฏิบัติการเฉพาะ ซึ่งรวมอยู่ในสภาพแวดล้อม Eclipce โต้ตอบกับระบบปฏิบัติการโดยใช้อินเทอร์เฟซเพียร์ ซึ่งแตกต่างจาก AWT ตรงที่มีการขยายช่วงของส่วนประกอบ Swing – มาพร้อมกับ JDK ขยายคลาส AWT โดยไม่ขึ้นอยู่กับส่วนประกอบของระบบปฏิบัติการเพียร์ Java 3 D – กราฟิกสามมิติ

ส่วนประกอบที่มีน้ำหนักมากและน้ำหนักเบา ส่วนประกอบที่มีน้ำหนักมาก – แสดงผลโดยระบบปฏิบัติการ – ส่วนประกอบ AWT ส่วนใหญ่ ส่วนประกอบที่มีน้ำหนักเบา – แสดงผลโดยโค้ด java – ส่วนประกอบของ Swing ทั้งหมด ยกเว้นหน้าต่างระดับบนสุด (หน้าต่างแอปพลิเคชัน) ส่วนประกอบที่มีน้ำหนักมากจะถูกวาดไว้ด้านบนของส่วนที่มีน้ำหนักเบาเสมอ

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

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

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

ตัวอย่าง MVC โมเดลคลาสสาธารณะ ( private int int. Array = (1, 2, 3, 4, 5); public String get. String. Array() ( return "int. Array=" + Arrays. to. String(int. Array); ) ชุดโมฆะสาธารณะ Int. Array(int index, int value) ( ​​this.int. Array = value; ) ) public class Controller ( Model model = new Model(); ดูวิว= มุมมองใหม่(); Controller() ( update.View(); ) ชุดโมฆะ อาร์เรย์ ค่า (ดัชนี int, ค่า int) ( ​​model. set. Int. Array (ดัชนี, ค่า); update. View (); ) การอัปเดตเป็นโมฆะ View() ( view.show.Array(model.get.String.Array()); ) ) ดูคลาสสาธารณะ ( public void show. Array(String array. String)( System. out. println("View"); System.out.println(array.String.out) ) ผู้ใช้คลาสสาธารณะ ( public statc void main(String args) คอนโทรลเลอร์= คอนโทรลเลอร์ใหม่ (); ตัวควบคุม ชุด. อาร์เรย์ ค่า(1, 4); -

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

ปุ่มส่วนประกอบอินเทอร์เฟซ - ปุ่ม; เจเช็ค. กล่อง—ปุ่มช่องทำเครื่องหมาย เจคอมโบ. กล่อง - รายการแบบหล่นลง JLabel - ป้ายกำกับ, คำจารึก; JList - รายการ; Jรหัสผ่าน. สนาม — ช่องข้อความสำหรับการป้อนข้อมูลที่ซ่อนอยู่; เจโปรเกรส. Bar - ส่วนประกอบสำหรับแสดงตัวเลขในช่วงที่กำหนด เจเรดิโอ. ปุ่ม - ปุ่มตัวเลือก มักใช้กับส่วนประกอบปุ่ม กลุ่ม; JSLider - ส่วนประกอบที่ช่วยให้คุณสามารถเลือกค่าจากช่วงที่กำหนด JTable - โต๊ะ; เจเท็กซ์ สนาม - ช่องข้อความบรรทัดเดียว เจเท็กซ์ พื้นที่ - ช่องข้อความหลายบรรทัด เจทรี - ต้นไม้

คอนเทนเนอร์ส่วนต่อประสาน ส่วนของส่วนต่อประสานผู้ใช้ที่มีส่วนประกอบอื่น ๆ คอนเทนเนอร์ระดับบนสุด: Frame, JFrame - หน้าต่างแอปพลิเคชัน; JDialog - กล่องโต้ตอบแอปพลิเคชัน; เจคัลเลอร์. ตัวเลือก - กล่องโต้ตอบการเลือกสี เจไฟล์. ตัวเลือก - กล่องโต้ตอบสำหรับเลือกไฟล์และไดเร็กทอรี ไฟล์. กล่องโต้ตอบ - กล่องโต้ตอบสำหรับเลือกไฟล์และไดเร็กทอรี (ส่วนประกอบ awt) คอนเทนเนอร์อย่างง่าย: JPanel - แผงอย่างง่ายสำหรับการจัดกลุ่มองค์ประกอบ รวมถึงแผงที่ซ้อนกัน เจทูล. แถบ - แถบเครื่องมือ (โดยปกติจะเป็นปุ่ม) JScroll. บานหน้าต่าง - แผงเลื่อนที่ให้คุณเลื่อนเนื้อหาขององค์ประกอบลูก เจสก์ท็อป. Pane เป็นคอนเทนเนอร์สำหรับสร้างเดสก์ท็อปเสมือนหรือแอปพลิเคชันที่ใช้ MDI (อินเทอร์เฟซหลายเอกสาร) เจเอดิเตอร์. บานหน้าต่าง, JText. บานหน้าต่าง - คอนเทนเนอร์สำหรับแสดงเอกสารที่ซับซ้อนเป็น HTML หรือ RTF JTabbed. บานหน้าต่าง - คอนเทนเนอร์สำหรับจัดการบุ๊กมาร์ก

การสร้างหน้าต่างนำเข้าจาวา เอาล่ะ - คลาสด้วย เรียบง่าย. Frame ขยาย Frame( public statc void main(String args)( Frame fr = new Too. Simple. Frame(); fr. set. Size(400, 150); // ขนาดหน้าต่าง fr. set. Visible(true); / / การแสดงผลหน้าต่าง ) // ปุ่มปิดไม่ทำงาน ) สวิง

หน้าต่างพร้อมไอคอนนำเข้า javax ที่กำหนดเอง แกว่ง. - เฟรมคลาสสาธารณะ การปิดขยาย JFrame ( public Frame. Closing() ( super("Window Title"); // การดำเนินการเมื่อปิดชุดหน้าต่าง ค่าเริ่มต้น ปิด Operaton(EXIT_ON_CLOSE); // เมื่อปิดหน้าต่าง - ออก // ไอคอนสำหรับ ชุดหน้าต่าง Icon.Image(get.Toolkit().get.Image("icon.gif")); // C: /icons / icon.png set. Visible(true); // การสร้างภาพหน้าต่าง ) public statc void main(String args) ( new Frame. Closing(); ) ) Swing

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

อินพุตและข้อความ windows นำเข้า java เอาล่ะ - นำเข้า javax. แกว่ง. - Soluton คลาสสาธารณะ ( public static void main (String args) ( Jopton. Pane. show. Message. Dialog (null , "Hello, World"); String s = Jopton. Pane. show. Input. Dialog ("ป้อนชื่อของคุณ" ) ) สวิง

Java Linkers มาตรฐาน 1. Border Linker เค้าโครง (ตำแหน่งเชิงขั้ว) 2. นักแต่งเพลงโฟลว์ เค้าโครง (ตำแหน่งตามลำดับ) 3. ลิงค์เกอร์. กริด เค้าโครง (เค้าโครงตาราง) 4. สปริงลิงค์เกอร์ เค้าโครง (ตำแหน่งสัมพันธ์) 5. นักแต่งเพลงกล่อง เค้าโครง (การวางบล็อก)

Polar Layout (Border.Layout Composer) ค่าเส้นขอบ เค้าโครง NORTH หรือสตริง "North" - ส่วนประกอบตั้งอยู่ตามขอบด้านบน (ทางเหนือ) ของหน้าต่างและทอดยาวไปตามความกว้างทั้งหมด โดยปกติจะเป็นวิธีการวางแถบเครื่องมือ ความหมายของเส้นขอบ เค้าโครง SOUTH หรือสตริง "South" - ส่วนประกอบตั้งอยู่ตามขอบด้านล่าง (ทางใต้) และทอดยาวไปตามความกว้างทั้งหมดของหน้าต่าง ตำแหน่งนี้เหมาะสำหรับแถบสถานะ ความหมายของเส้นขอบ เค้าโครง WEST หรือสตริง "ตะวันตก" - ส่วนประกอบตั้งอยู่ตามขอบด้านซ้าย (ตะวันตก) ของหน้าต่างและทอดยาวไปจนถึงความสูงทั้งหมดอย่างไรก็ตามคำนึงถึงขนาดของส่วนประกอบทางเหนือและทางใต้ด้วย (มีลำดับความสำคัญ) ความหมายของเส้นขอบ เค้าโครง EAST หรือสตริง "ตะวันออก" - ส่วนประกอบตั้งอยู่ตามขอบด้านขวา (ตะวันออก) ของหน้าต่าง มิฉะนั้นเค้าโครงจะคล้ายกับองค์ประกอบตะวันตก ความหมายของเส้นขอบ เค้าโครง CENTER หรือสตริง "Center" - ส่วนประกอบวางอยู่ตรงกลางหน้าต่างโดยใช้พื้นที่มากที่สุด

ตัวอย่างการใช้ Border compositor เค้าโครงนำเข้า javax แกว่ง. - นำเข้าจาวา เอาล่ะ - ชายแดนชั้นเรียนสาธารณะ เค้าโครง ตัวอย่างขยาย JFrame ( public Border. Layout. Sample() ( super("Border. Layout. Sample"); set. Size(400, 300); set. Default. Close. Operaton(EXIT_ON_CLOSE); // รับเนื้อหาคลาส พาเนล JFrame Container c = get.Pane(); // โดยค่าเริ่มต้น Swing ใช้ตัวจัดการเค้าโครง // เพิ่มส่วนประกอบลงในพาเนลโดยใช้ค่าคงที่สตริง c. c. add(new JLabel("South"), "South"); // หรือค่าคงที่จาก class Border. Layout. WEST) ; c. add(new JLabel("East"), Border.Layout. EAST); // ถ้าคุณไม่ระบุพารามิเตอร์เลย, ส่วนประกอบจะถูกเพิ่มเข้าไปที่กึ่งกลาง c JButton("Center")); เพื่อตั้งค่าหน้าจอ Visible(true); public statc void main(String args) ( new Border. Layout.Sample(); ) ) Swing

เค้าโครงตามลำดับ (เค้าโครงเค้าโครงโฟลว์) เค้าโครงวางองค์ประกอบต่างๆ จากซ้ายไปขวา บนลงล่าง (ค่าเริ่มต้นใน Jpanels) นำเข้า javax. แกว่ง. - นำเข้าจาวา เอาล่ะ - กระแสชั้นเรียนสาธารณะ เค้าโครง ตัวอย่างขยาย JFrame ( public Flow. Layout. Sample() ( super("Flow. Layout 1"); set. Size(400, 200); set. Default. Close. Operaton(EXIT_ON_CLOSE); // รับคอนเทนเนอร์พาเนลเนื้อหา c. get.Content.Pane(); // ตั้งค่าส่วนประกอบให้อยู่ตรงกลาง c. เค้าโครง (Flow.Layout.CENTER)); c. เพิ่ม (JButton ใหม่) )); // แสดงชุดหน้าต่าง String args) ( new Flow.Layout.Sample(); ) ) นำเข้า java. เอาล่ะ - นำเข้า javax. แกว่ง. - Soluton คลาสสาธารณะ ( public static void main (String args) ( Jopton. Pane. show. Message. Dialog (null , "Hello, World"); ) ) สวิง

โครงร่างแบบตาราง (Grid. Layoutlayout) ส่วนประกอบทั้งหมดมีขนาดเท่ากัน พื้นที่ว่างจะถูกแบ่งออกเป็นเซลล์จำนวนเท่าๆ กัน ซึ่งแต่ละเซลล์จะมีส่วนประกอบอยู่ด้วย ส่วนประกอบทั้งหมดจะแสดงบนหน้าจอเสมอไม่ว่าพื้นที่ว่างจะใหญ่หรือเล็กก็ตาม นำเข้าจาวา เอาล่ะ - นำเข้า javax. แกว่ง. - นำเข้าจาวา ทั่วไป - คลาสกริด ทดสอบขยาย JFrame ( Grid. Test(String s)( super(s); Container c = get. Content. Pane(); // 4 แถว 4 คอลัมน์ ระยะห่างระหว่างแถวและคอลัมน์ในหน่วยพิกเซล c. set. เค้าโครง(new ​​Grid. เค้าโครง (4, 4, 5, 5)); String. Tokenizer st = new String. Tokenizer("7 8 9 / 4 5 6 * 1 2 3 - 0. = +"); ปุ่มใหม่ (st. next. Token())); set.

การจัดเรียงแบบตารางจะทำให้ปุ่มมีขนาดเท่ากัน และการจัดเรียงตามลำดับจะป้องกันไม่ให้ปุ่ม "เบลอ" และในขณะเดียวกันก็จัดตำแหน่งปุ่มเหล่านั้นไว้ที่ขอบด้านขวา ฉันนำเข้า java เอาล่ะ - นำเข้า javax. แกว่ง. - คำสั่งชั้นเรียนสาธารณะ ปุ่มขยาย JFrame ( public Command. Buttons() ( super("Command. Buttons"); set. Size(350, 250); set. Locaton(150, 100); set. Default. Close. Operaton(EXIT_ON_CLOSE); / / สร้างพาเนลที่มีเค้าโครงตารางเพื่อจัดเรียงขนาดของปุ่ม JPanel grid = new JPanel(new Grid.Layout(1, 2, 5, 0)); // 1 แถว, 2 คอลัมน์, 5 px ในแนวนอน, 0 แนวตั้ง . // เพิ่มตารางส่วนประกอบ add(new JButton("OK")); add(new JButton("Cancel")); // วางผลลัพธ์ไว้ในตำแหน่งตามลำดับโดยจัดแนวให้ตรงกับ JPanel ที่ถูกต้อง JPanel( new Flow.Layout(Flow.Layout.RIGHT)); // รับแผงเนื้อหา c = get. ปุ่ม(); ) ) สวิง

เค้าโครงบล็อก (Box. ตัวประกอบเค้าโครง) ตัวจัดการเค้าโครงบล็อกจะวางส่วนประกอบต่างๆ ในคอนเทนเนอร์เป็นบล็อก: คอลัมน์ (ตามแกน Y) หรือแถบ (ตามแกน X) และแต่ละองค์ประกอบสามารถจัดวางให้อยู่กึ่งกลาง ซ้าย หรือ ขวาตลอดจนตามด้านบนหรือด้านล่าง

ตัวอย่างเค้าโครงบล็อกนำเข้า Java เอาล่ะ - นำเข้า javax. แกว่ง. - คลาสสาธารณะ Box 1 ขยาย JFrame ( public Box 1() ( super("Box 1 - Y"); set. Size(400, 200); set. Default. Close. Operaton(EXIT_ON_CLOSE); // รับคอนเทนเนอร์พาเนลเนื้อหา c. รับ เนื้อหา บานหน้าต่าง (); // ตั้งค่าเค้าโครงแกน Y (ใหม่) JButton("สาม")); // แสดงชุดหน้าต่าง (จริง); statc คลาส Box 2 ขยาย JFrame ( public Box 2() ( super("Box 2 - X"); // กำหนดขนาดและตำแหน่งของ ชุดหน้าต่าง ขนาด (400, 200); set. ค่าเริ่มต้น ปิด. X_AXIS); // เพิ่มส่วนประกอบ c. เพิ่ม ("หนึ่ง")); . // แสดงชุดหน้าต่าง มองเห็นได้(จริง); ) ) public statc void main(String args) ( new Box 1(); new Box 2(); ) ) Swing 5 ตัวอย่างนี้จะสร้างสองหน้าต่าง หนึ่งในนั้นใช้โครงร่างบล็อกตามแนวแกน Y ส่วนอีกอันใช้โครงร่างบล็อกตามแนวแกน X

ดาวีดอฟ แอนตัน วาเลรีวิช
นักศึกษาที่ TSU รัสเซีย Tolyatti
หัวหน้างานด้านวิทยาศาสตร์: เอโรฟีวา อี.เอ.

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

ชุดเครื่องมือหน้าต่างนามธรรม

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

รูปที่ 1 – ตัวอย่างโปรแกรมที่เขียนโดยใช้ AWT ในสภาพแวดล้อม Windows

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

อย่างไรก็ตาม เนื่องจากความง่ายในการเรียนรู้และมีเอกสารประกอบที่กว้างขวาง Swing จึงกลายเป็น GUI ที่ได้รับความนิยมมากที่สุดใน Java มันได้สร้างส่วนขยายมากมาย เช่น SwingX และ JGoodies ซึ่งทำให้การสร้างแอปพลิเคชันที่ซับซ้อนทางสายตาง่ายยิ่งขึ้น สภาพแวดล้อมการเขียนโปรแกรม Java สมัยใหม่ทั้งหมดประกอบด้วย บรรณาธิการกราฟิกแกว่ง. แม้ว่าปัจจุบันจะมี Framework ที่ทันสมัยกว่านี้ แต่ Swing ก็ยังคงได้รับความนิยมมากที่สุด

รูปที่ 2 – ตัวอย่างโปรแกรมที่เขียนโดยใช้ Swing

ชุดเครื่องมือวิดเจ็ตมาตรฐาน

SWT เปิดตัวโดย IBM ในช่วงเวลาที่ Swing ยังคงช้า และเพื่อส่งเสริมสภาพแวดล้อมการเขียนโปรแกรม Eclipse เป็นหลัก เช่นเดียวกับ AWT SWT ใช้ส่วนประกอบของระบบปฏิบัติการ แต่ใช้อินเทอร์เฟซการทำงานร่วมกันที่แตกต่างกันสำหรับแพลตฟอร์มที่แตกต่างกัน ดังนั้นจึงต้องจัดเตรียมไลบรารี JAR แยกต่างหากสำหรับแต่ละระบบปฏิบัติการ สิ่งนี้ช่วยให้คุณใช้คุณสมบัติต่างๆ ที่เหมาะกับระบบปฏิบัติการที่แตกต่างกันได้อย่างเต็มที่มากขึ้น และส่วนประกอบที่ขาดหายไปก็ถูกรับรู้โดยใช้ 2D อย่างไรก็ตาม SWT กลับกลายเป็นว่าควบคุมได้ยากกว่าสวิง นอกจากนี้โปรแกรมเมอร์เองจะต้องดำเนินการเผยแพร่ทรัพยากรโดยแอปพลิเคชัน

รูปที่ 3 – ตัวอย่างโปรแกรมที่เขียนโดยใช้ Swing

JavaFX เปิดตัวในปี 2551 โดย Oracle มันถูกวางตำแหน่งเป็นแพลตฟอร์มสำหรับการสร้างแอปพลิเคชั่นอินเทอร์เน็ตที่หลากหลาย ไปป์ไลน์กราฟิกใช้สำหรับการเรนเดอร์ซึ่งจะเพิ่มความเร็วของแอปพลิเคชันอย่างมาก มีส่วนประกอบในตัวชุดใหญ่ นอกจากนี้ยังมีส่วนประกอบแยกต่างหากสำหรับการลงจุด มีการรองรับเนื้อหามัลติมีเดียแอนิเมชั่นและแม้แต่การสัมผัสหลายครั้ง รูปลักษณ์ของส่วนประกอบต่างๆ ได้รับการปรับแต่งโดยใช้สไตล์ CSS นอกจากนี้ ชุดยูทิลิตี้ JavaFX ยังรวมถึงความสามารถในการสร้างตัวติดตั้งดั้งเดิมสำหรับแพลตฟอร์มยอดนิยม: exe หรือ msi สำหรับ Windows, deb หรือ rpm สำหรับ Linux, dmg สำหรับ Mac มีเอกสารประกอบโดยละเอียดบนเว็บไซต์ของ Oracle และ จำนวนมากตัวอย่างสำเร็จรูป

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

รายชื่อแหล่งที่มาที่ใช้

Ryzhenko A. V. การเขียนโปรแกรมเชิงวัตถุ: ความซับซ้อนทางการศึกษาและระเบียบวิธีในสาขาวิชาเฉพาะทาง 010501 - "คณิตศาสตร์ประยุกต์และวิทยาการคอมพิวเตอร์" – 2550.

Khabibullin I. Sh. Java 7 (ฉบับที่ 4) – BHV-ปีเตอร์สเบิร์ก, 2012.

Clarke J., Connors J., Bruno E. J. JavaFX: การพัฒนาแอปพลิเคชันอินเทอร์เน็ตที่หลากหลาย – เพียร์สันเอ็ดดูเคชั่น, 2552.

Northover S., Wilson M. Swt: ชุดเครื่องมือวิดเจ็ตมาตรฐาน เล่มที่ 1 – Addison Wesley Professional, 2004

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

ชุดเครื่องมือหน้าต่างนามธรรม

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

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

ข้อดี:

• ส่วน JDK;
• ความเร็วในการทำงาน
• ส่วนประกอบกราฟิกมีความคล้ายคลึงกับองค์ประกอบมาตรฐาน

ข้อบกพร่อง:

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

บทสรุป:

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

แกว่ง

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

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

ข้อดี:

• เป็นส่วนหนึ่งของ JDK ไม่จำเป็นต้องติดตั้งไลบรารีเพิ่มเติม
• มีหนังสือเกี่ยวกับ Swing และคำตอบในฟอรัมอีกมากมาย Google ทราบปัญหาทั้งหมดโดยเฉพาะสำหรับผู้เริ่มต้นแล้ว
• เครื่องมือแก้ไขแบบฟอร์มในตัวในสภาพแวดล้อมการพัฒนาเกือบทั้งหมด
• มีส่วนขยายแบบสวิงมากมายเช่น SwingX;
• รองรับหลากหลายสไตล์ (รูปลักษณ์)

ข้อบกพร่อง:

• หน้าต่างที่มีส่วนประกอบมากมายเริ่มช้าลง
• การทำงานร่วมกับผู้จัดการเลย์เอาต์อาจเป็นฝันร้ายในอินเทอร์เฟซที่ซับซ้อน

บทสรุป:

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

ชุดเครื่องมือวิดเจ็ตมาตรฐาน

SWT ได้รับการพัฒนาโดย IBM ในช่วงเวลาที่ Swing ยังช้า และทำเพื่อส่งเสริมสภาพแวดล้อมการเขียนโปรแกรม Eclipse เป็นหลัก SWT เช่น AWT ใช้ส่วนประกอบของระบบปฏิบัติการ แต่มีอินเทอร์เฟซการโต้ตอบของตัวเองสำหรับแต่ละแพลตฟอร์ม ดังนั้นสำหรับทุกคน ระบบใหม่คุณจะต้องจัดหาไลบรารี JAR แยกต่างหากพร้อมกับ SWT เวอร์ชันที่เหมาะสม ทำให้สามารถใช้ฟังก์ชันการทำงานที่มีอยู่ของส่วนประกอบต่างๆ ในแต่ละแกนได้อย่างเต็มที่มากขึ้น คุณลักษณะและส่วนประกอบที่ขาดหายไปถูกนำมาใช้โดยใช้ 2D เช่นเดียวกับใน Swing SWT มีสมัครพรรคพวกมากมาย แต่จากใจจริง ใครๆ ก็อดไม่ได้ที่จะตกลงกันว่าทุกอย่างกลับกลายเป็นว่าไม่ง่ายอย่างที่เราต้องการ ผู้เริ่มต้นจะต้องใช้เวลาในการเรียนรู้ SWT มากกว่าการทำความคุ้นเคยกับ Swing นอกจากนี้ SWT ยังมอบหมายงานในการเพิ่มทรัพยากรให้กับโปรแกรมเมอร์ดังนั้นจึงจำเป็นต้องระมัดระวังเป็นพิเศษเมื่อเขียนโค้ดเพื่อไม่ให้ข้อยกเว้นโดยไม่ตั้งใจทำให้หน่วยความจำรั่ว

ข้อดี:

• ใช้ส่วนประกอบของระบบปฏิบัติการ - ความเร็วที่สูงกว่า
• Eclipse จัดให้ โปรแกรมแก้ไขภาพแบบฟอร์ม;
• เอกสารที่ครอบคลุมและตัวอย่างมากมาย
• สามารถใช้ส่วนประกอบ AWT และ Swing ได้

ข้อบกพร่อง:

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

บทสรุป:

เห็นได้ชัดว่า IBM พยายามแล้ว แต่กลับกลายเป็นว่าชำนาญมาก...

JavaFX

JavaFX สามารถเรียกได้ว่าเป็นความก้าวหน้าโดยไม่ต้องพูดเกินจริง ไปป์ไลน์กราฟิกใช้สำหรับการเรนเดอร์ซึ่งจะเพิ่มความเร็วของแอปพลิเคชันอย่างมาก ชุดส่วนประกอบในตัวนั้นกว้างขวางและยังมีส่วนประกอบแยกต่างหากสำหรับการวาดกราฟอีกด้วย รองรับเนื้อหามัลติมีเดียเอฟเฟกต์การแสดงผลภาพเคลื่อนไหวและแม้แต่มัลติทัช รูปลักษณ์ของส่วนประกอบทั้งหมดสามารถเปลี่ยนแปลงได้อย่างง่ายดายโดยใช้สไตล์ CSS และสิ่งที่ดีที่สุดคือ JavaFX มีชุดยูทิลิตี้ที่ช่วยให้คุณสามารถสร้างตัวติดตั้งแบบเนทีฟสำหรับแพลตฟอร์มที่ได้รับความนิยมสูงสุด: exe หรือ msi สำหรับ Windows, deb หรือ rpm สำหรับ Linux, dmg สำหรับ Mac บนเว็บไซต์ Oracle คุณจะพบเอกสารโดยละเอียดและตัวอย่างสำเร็จรูปจำนวนมาก ทำให้การเขียนโปรแกรมด้วย JavaFX เป็นเรื่องง่ายและสนุกสนาน

ข้อดี:

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

ข้อบกพร่อง:

• กรอบงานยังอยู่ระหว่างการพัฒนา ดังนั้นจึงเกิดข้อขัดข้องและข้อบกพร่องบางอย่างเกิดขึ้น
• JavaFX ยังไม่ได้ใช้กันอย่างแพร่หลาย

บทสรุป:

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

ห้องสมุดภาพในทางปฏิบัติ

SWT: วิดเจ็ตสภาพอากาศ

เพื่อสาธิตความสามารถของไลบรารีกราฟิกยอดนิยมและหลักการพื้นฐานของการทำงาน เราจะสร้างวิดเจ็ตขนาดเล็กหลายอันที่แสดงข้อมูลต่างๆ

และบางทีเรามาเริ่มกันที่วิดเจ็ตยอดนิยมที่สุดซึ่งแสดงสภาพอากาศปัจจุบันซึ่งเราจะเลือก SWT เพื่อนำไปใช้งาน

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

จอแสดงผล จอแสดงผล = จอแสดงผลใหม่ (); เปลือก = เชลล์ใหม่ (จอแสดงผล SWT.NO_TRIM);

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

กำลังอัพโหลดรูปภาพ:

รูปภาพ image = รูปภาพใหม่ (แสดง "images/bg.png#26759185");

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

ภูมิภาค ภูมิภาค = ภูมิภาคใหม่ (); ImageData imageData = image.getImageData(); ถ้า (imageData.alphaData != null) ( พิกเซลสี่เหลี่ยมผืนผ้า = สี่เหลี่ยมผืนผ้าใหม่ (0, 0, 1, 1); สำหรับ (int y = 0; y< imageData.height; y++) { for (int x = 0; x < imageData.width; x++) { if (imageData.getAlpha(x, y) == 255) { pixel.x = imageData.x + x; pixel.y = imageData.y + y; region.add(pixel); } } } } else { ImageData mask = imageData.getTransparencyMask(); Rectangle pixel = new Rectangle(0, 0, 1, 1); for (int y = 0; y < mask.height; y++) { for (int x = 0; x < mask.width; x++) { if (mask.getPixel(x, y) != 0) { pixel.x = imageData.x + x; pixel.y = imageData.y + y; region.add(pixel); } } } }

กำหนดรูปร่างของหน้าต่าง:

Shell.setRegion (ภูมิภาค);

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

Listener Listener = new Listener() ( int startX, startY; public void handleEvent(Event e) ( if (e.type == SWT.KeyDown && e.Character == SWT.ESC) ( shell.dispose(); ) ถ้า (e.type == SWT.MouseDown && e.button == 1) ( startX = e.x; startY = e.y; ) ถ้า (e.type == SWT.MouseMove && (e.stateMask & SWT.BUTTON1) != 0 ) ( Point p = shell.toDisplay(e.x, e.y); p.x -= startX; p.y -= startY; shell.setLocation(p); ) if (e.type == SWT.Paint) ( e.gc.drawImage( รูปภาพ, imageData.x, imageData.y);

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

มากำหนดผู้ฟังให้กับเหตุการณ์หน้าต่างที่เกี่ยวข้องกัน:

Shell.addListener (SWT.KeyDown ผู้ฟัง); shell.addListener (SWT.MouseDown ผู้ฟัง); shell.addListener (SWT.MouseMove ผู้ฟัง); shell.addListener (SWT.Paint, ผู้ฟัง);

ตั้งค่าขนาดหน้าต่างให้เท่ากับขนาดภาพ:

Shell.setSize(imageData.x + imageData.width, imageData.y + imageData.height);

เปิดหน้าต่างและเริ่มวนรอบเหตุการณ์:

เชลล์.เปิด(); ในขณะที่ (!shell.isDisposed()) ( ถ้า (!display.readAndDispatch()) display.sleep(); )

อย่าลืมเปิดเผยทรัพยากรที่ใช้แล้วในตอนท้าย:

ภูมิภาค.ทิ้ง(); รูปภาพ.ทิ้ง(); display.ทิ้ง();

เมื่อรันโปรแกรมในขั้นตอนนี้ เราจะได้สี่เหลี่ยมที่สามารถเลื่อนได้ด้วยเมาส์และปิดด้วย Esc

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

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

เค้าโครง GridLayout = GridLayout ใหม่ (2, เท็จ); เชลล์.setLayout(เค้าโครง);

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

// วาดภาพสถานะ Label imageLabel = new Label (shell, SWT.NONE); imageLabel.setLayoutData(GridData ใหม่ (SWT.LEFT, SWT.TOP, จริง, จริง, 1, 1));

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

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

สี bgColor = สีใหม่ (จอแสดงผล, 0x2b, 0x2b, 0x2b);

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

ImageLabel.setBackground(bgColor); สถานะรูปภาพรูปภาพ = รูปภาพใหม่ (แสดง "images/1.png#26759185"); imageLabel.setImage (ภาพสถานะ);

ตอนนี้เรามาเพิ่มป้ายกำกับที่มีอุณหภูมิปัจจุบันและวางไว้ที่ส่วนบนขวาของหน้าต่าง:

ป้ายกำกับ temperatureLabel = ป้ายกำกับใหม่ (เชลล์, SWT.NONE); temperatureLabel.setLayoutData (GridData ใหม่ (SWT.RIGHT, SWT.TOP, false, false, 1, 1));

มาตั้งอุณหภูมิกัน:

TemperatureLabel.setText("+1 \u2103");

ในการบันทึกอุณหภูมิเป็นเซลเซียส จะใช้หมายเลข Unicode ของอักขระที่สอดคล้องกันพร้อมอักขระบริการ \u

แบบอักษรเริ่มต้นสำหรับป้ายข้อความมีขนาดเล็กเกินไป เรามาสร้างอันใหม่ที่ใหญ่กว่ากันดีกว่า:

FontData fD = temperatureLabel.getFont().getFontData(); fD.setHeight(30); fD.setStyle(SWT.BOLD); แบบอักษร newFont = แบบอักษรใหม่ (จอแสดงผล, fD); temperatureLabel.setFont(แบบอักษรใหม่); แบบอักษร เช่นเดียวกับวัตถุทรัพยากรอื่นๆ จะต้องได้รับการปลดปล่อย ในการดำเนินการนี้ เราจะใช้ Listener เหตุการณ์การทำลายป้ายกำกับ:

TemperatureLabel.addDisposeListener (DisposeListener ใหม่ () ( โมฆะสาธารณะ widgetDisposed (DisposeEvent e) ( newFont.dispose (); ) ));

สุดท้ายนี้ ให้เพิ่มป้ายกำกับที่อธิบายสภาพอากาศ:

Label descriptionLabel = new Label(shell, SWT.WRAP); descriptionLabel.setLayoutData(GridData ใหม่ (SWT.FILL, SWT.CENTER, จริง, จริง, 2, 1)); descriptionLabel.setText("มีเมฆมาก มีฝนตกปรอยๆ"); descriptionLabel.setBackground(bgColor); descriptionLabel.setForeground(display.getSystemColor(SWT.COLOR_WHITE));

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

ตอนนี้คุณสามารถแนบบริการสภาพอากาศ สร้างตัวจับเวลาสำหรับการอัปเดตอัตโนมัติ - และวิดเจ็ตก็พร้อมใช้งาน

สวิง: ข่าวล่าสุดเสมอ

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

JFrame frame = JFrame ใหม่(); frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

ตารางเหมาะที่สุดสำหรับการนำเสนอข่าวสาร Swing สร้างขึ้นบนรูปแบบ Model-View-Controller (MVC) ในสถาปัตยกรรม MVC โมเดลจะให้ข้อมูล มุมมองมีหน้าที่ในการแสดงข้อมูล (เช่น ข้อความ ช่องป้อนข้อมูล) และตัวควบคุมจะจัดเตรียมการโต้ตอบระหว่างโมเดลและมุมมอง ตารางแสดงให้เห็นถึงแนวทางนี้ได้ดี ในการแสดงข้อมูล จะใช้คลาสที่ใช้อินเทอร์เฟซ TableModel

หากต้องการเก็บข้อมูลเกี่ยวกับข่าวที่มีอยู่ มาสร้างคลาส FeedMessage พร้อมช่องสำหรับชื่อบทความและวันที่ตีพิมพ์:

FeedMessage ระดับสาธารณะ (ชื่อสตริงสาธารณะ; วันที่สาธารณะpublicationDate; )

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

RssFeedTableModel คลาสสาธารณะขยาย AbstractTableModel ( private List รายการ = ArrayList ใหม่<>- โมฆะสาธารณะ updateData (List รายการ) ( this.entries = items; fireTableDataChanged(); ) public int getRowCount() ( return items.size(); ) public int getColumnCount() ( return 2; ) public Object getValueAt(int rowIndex, int columnIndex) ( switch (columnIndex) ( กรณีที่ 0: return items.get(rowIndex).title; กรณีที่ 1: return entry.get(rowIndex).publicationDate; ) ส่งคืน null;

เมธอด fireTableDataChanged จะบอกมุมมองว่าโมเดลข้อมูลมีการเปลี่ยนแปลงและจำเป็นต้องวาดใหม่

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

ตาราง JTable = JTable ใหม่ (RssFeedTableModel ใหม่ ()); table.setShowGrid(เท็จ); table.setIntercellSpacing (มิติใหม่ (0, 0)); table.setRowHeight(30); table.setTableHeader(null);

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

มากำหนดตัวสร้างภาพเซลล์ของเราให้กับข้อมูลประเภทสตริง มาเปลี่ยนสีตัวอักษรเริ่มต้นและเปลี่ยนสีพื้นหลังเพื่อให้อ่านง่ายขึ้น

Table.setDefaultRenderer(String.class, new DefaultTableCellRenderer() ( Color OddColor = new Color(0x25, 0x25, 0x25); ColorevenColor = new Color(0x1a, 0x1a, 0x1a); Color titleColor = new Color(0x3a, 0xa2, 0xd7) ); คอมโพเนนต์สาธารณะ getTableCellRendererComponent (ตาราง JTable, ค่าอ็อบเจ็กต์, isSelected บูลีน, hasFocus บูลีน, แถว int, คอลัมน์ int) ( super.getTableCellRendererComponent (ตาราง, ค่า, isSelected, hasFocus, แถว, คอลัมน์); setBackground (แถว % 2 == 0 ? OddColor:evenColor); setForeground(titleColor);

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

ชั้นเรียนสาธารณะgetColumnClass(int columnIndex) ( สวิตช์ (columnIndex) ( case 0: return String.class; case 1: return Date.class; ) return Object.class; )

อาจมีข่าวสารมากมาย ดังนั้นให้วางตารางบนแถบเลื่อนและทำให้มองไม่เห็นแถบเลื่อน เพื่อไม่ให้การออกแบบวิดเจ็ตเสีย:

JScrollPane scrollPane = JScrollPane ใหม่ (ตาราง); table.setFillsViewportHeight(จริง); scrollPane.getVerticalScrollBar().setPreferredSize(มิติข้อมูลใหม่ (0,0));

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

Frame.getContentPane().add(scrollPane, BorderLayout.CENTER);

เช่นเดียวกับครั้งที่แล้วเราจะลบกรอบหน้าต่างมาตรฐานออก และในฐานะชื่อของหน้าต่าง เราจะใช้ป้ายกำกับข้อความเก๋ๆ ซึ่งเราจะวางไว้ที่ด้านบนของหน้าต่าง

JLabel titleLabel = JLabel ใหม่ ("Xakep RSS"); ชื่อแบบอักษรFont = แบบอักษรใหม่ ("Arial", Font.BOLD, 20); titleLabel.setFont(titleFont); titleLabel.setHorizontalAlignment (SwingConstants.CENTER); titleLabel.setForeground(Color.WHITE); titleLabel.setPreferredSize (มิติข้อมูลใหม่ (0, 40)); frame.getContentPane().add(titleLabel, BorderLayout.NORTH);

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

เพิ่มตัวฟังเมาส์เพื่อให้สามารถย้ายหน้าต่างไปรอบๆ หน้าจอได้

MouseAdapter Listener = ใหม่ MouseAdapter() ( int startX; int startY; โมฆะสาธารณะ mousePressed(MouseEvent e) ( if (e.getButton() == MouseEvent.BUTTON1) ( startX = e.getX(); startY = e.getY( ) ) โมฆะสาธารณะ mouseDragged(MouseEvent e) ( จุด currCoords = e.getLocationOnScreen(); frame.setLocation(currCoords.x - startX, currCoords.y - startY); ) ); titleLabel.addMouseListener (ผู้ฟัง); titleLabel.addMouseMotionListener (ผู้ฟัง);

ทีนี้มาเปลี่ยนรูปร่างของหน้าต่างเป็นสี่เหลี่ยมผืนผ้าที่มีมุมโค้งมน วิธีที่ดีที่สุดคือทำเช่นนี้ใน Component Listener เนื่องจากหากขนาดหน้าต่างเปลี่ยนแปลง รูปร่างของหน้าต่างจะถูกคำนวณใหม่อย่างถูกต้อง:

Frame.addComponentListener (ใหม่ ComponentAdapter () ( โมฆะสาธารณะ elementResize (ComponentEvent e) ( frame.setShape (ใหม่ RoundRectangle2D.Double (0, 0, frame.getWidth (), frame.getHeight (), 20, 20)); ) ) );

กำหนดขนาดหน้าต่าง ถอดกรอบออก และทำให้หน้าต่างโปร่งแสง

Frame.setSize(520, 300); frame.setUndecorated (จริง); frame.setOpacity(0.85f);

ในที่สุด เราก็เปิดหน้าต่างในสตรีมกราฟิก SwingUtilities.invoidLater (Runnable ใหม่ () ( การรันโมฆะสาธารณะ () ( frame.setVisible (true); ) ));

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

JavaFX: มาฟังเพลงกันดีกว่า

และสุดท้าย ไฮไลท์ของฤดูกาลก็คือ JavaFX ลองใช้ความสามารถด้านมัลติมีเดียและส่วนประกอบในการวางแผนและสร้างอีควอไลเซอร์แบบง่ายๆ

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

การเริ่มต้นเป็นโมฆะสาธารณะ (Stage primaryStage) ( primaryStage.initStyle (StageStyle.TRANSPARENT); รูทกลุ่ม = กลุ่มใหม่ (); ฉากฉาก = ฉากใหม่ (รูท, 400, 200, Color.TRANSPARENT); primaryStage.setScene (ฉาก);

ในการแสดงอีควอไลเซอร์ เราใช้กราฟแท่งตามแกนที่เราจะแสดงความถี่และพลังเสียง:

CategoryAxis xAxis = CategoryAxis ใหม่(); NumberAxis yAxis = NumberAxis ใหม่ (0,50,10); BarChart bc = BarChart ใหม่ (แกนx,แกนy); bc.setPrefSize(400, 200); bc.setLegendVisible(เท็จ); bc.setAnimated(เท็จ); bc.setBarGap(0); bc.setCategoryGap(1); bc.setVerticalGridLinesVisible (เท็จ); bc.setHorizontalGridLinesVisible(เท็จ); xAxis.setLabel("ความถี่"); yAxis.setLabel("กำลัง"); yAxis.setTickLabelFormatter(NumberAxis.DefaultFormatter ใหม่(yAxis, null, "dB"));

เติมไดอะแกรมด้วยข้อมูลเริ่มต้น:

XYChart.ซีรี่ส์ series1 = XYChart.Series ใหม่ - series1Data = XYChart.Data ใหม่; หมวดหมู่สตริง = สตริงใหม่; สำหรับ (int i=0; i (หมวดหมู่[i], 50);

series1.getData().เพิ่ม(series1Data[i]); ) bc.getData().add(series1);

สร้างสี่เหลี่ยมผืนผ้าที่มีมุมมนเพื่อให้วิดเจ็ตมีรูปร่างที่เหมาะสม:

สี่เหลี่ยมผืนผ้า สี่เหลี่ยมผืนผ้า = สี่เหลี่ยมผืนผ้าใหม่ (0, 0, 400, 200); หยุด หยุด = หยุดใหม่ ( หยุดใหม่ (0, สีใหม่ (0, 0, 0, 0.8)), null); LinearGradient lg2 = LinearGradient ใหม่ (0, 0, 0, 0, เท็จ, CycleMethod.NO_CYCLE, หยุด); สี่เหลี่ยมผืนผ้า setFill (lg2); สี่เหลี่ยมผืนผ้า setArcHeight (20); สี่เหลี่ยมผืนผ้า setArcWidth (20);

เพิ่มองค์ประกอบทั้งสองลงในกลุ่ม:

Root.getChildren().addAll(สี่เหลี่ยมผืนผ้า, bc);

เรากำหนดผู้ฟังเมาส์ให้กับกลุ่มเพื่อย้ายหน้าต่างไปรอบๆ หน้าจอ: Root.setOnMousePressed (ตัวจัดการเหตุการณ์ใหม่ () ( ตัวจัดการโมฆะสาธารณะ(MouseEvent ฉัน) ( initX = me.getScreenX() - primaryStage.getX(); initY = me.getScreenY() - primaryStage.getY(); ) )); root.setOnMouseDragged (ตัวจัดการเหตุการณ์ใหม่

() ( ตัวจัดการโมฆะสาธารณะ(MouseEvent ฉัน) ( primaryStage.setX(me.getScreenX() - initX); primaryStage.setY(me.getScreenY() - initY); ) ));

โหลดเพลงลงในเครื่องเล่น:

ไฟล์ file = ไฟล์ใหม่ ("พาฉันออกไปจากที่นี่.mp3"); สื่อ audioMedia = null; audioMedia = สื่อใหม่ (file.toURI().toURL().toString()); audioMediaPlayer = MediaPlayer ใหม่ (audioMedia);

เพิ่มผู้ฟังที่จะอัปเดตแผนภูมิแท่ง:< series1Data.length; i++) { series1Data[i].setYValue(magnitudes[i] + 60); } } });

AudioMediaPlayer.setAudioSpectrumListener (AudioSpectrumListener ใหม่ () ( โมฆะสาธารณะ SpectrumDataUpdate (การประทับเวลาสองเท่า, ระยะเวลาสองเท่า, ขนาดโฟลต, เฟสโฟลต) ( สำหรับ (int i = 0; i

ทำให้มองเห็นฉากนั้นได้และเริ่มเพลง:

PrimaryStage.show(); audioMediaPlayer.play();

เปิดแอปพลิเคชัน:

โมฆะสาธารณะคงที่ main (String args) ( launch (args); )