การสร้างแอปพลิเคชัน GUI Java ใน NetBeans ส่วนติดต่อผู้ใช้แบบมีหน้าต่างในโปรแกรม Java

22.07.2019

บทความนี้จะอธิบายวิธีสร้างแอปพลิเคชันอย่างง่ายดังแสดงในรูปทางด้านขวา พร้อมด้วยซอร์สโค้ด

หากต้องการวางปุ่ม ป้ายข้อความ และส่วนประกอบอื่นๆ ในหน้าต่างโปรแกรม คุณต้องเข้าใจวิธีการทำงานของ JPanel มันเหมือนกับคอนเทนเนอร์ส่วนประกอบที่ใช้พื้นที่สี่เหลี่ยมของหน้าจอและแสดงส่วนประกอบต่างๆ เรียงกันด้วยวิธีง่ายๆ วิธีจัดวางส่วนประกอบต่างๆ อย่างแน่นอนนั้นขึ้นอยู่กับประเภทของเค้าโครงที่คุณได้ติดตั้งไว้สำหรับแผงควบคุม สำหรับงานเขียนโปรแกรมอย่างง่าย คุณควรทราบขั้นต่ำ BorderLayout ซึ่งวางส่วนประกอบไว้ที่ขอบและมีส่วนประกอบขนาดใหญ่หนึ่งชิ้นอยู่ตรงกลาง จากนั้น FlowLayout ซึ่งโดยทั่วไปจะจัดเรียงส่วนประกอบในแนวนอน และสุดท้ายคือ GridLayout ซึ่งจัดเรียงส่วนประกอบในตารางที่กำหนดเอง n* ม. มีประเภทอื่นๆ แต่ยากเกินไปสำหรับผู้เริ่มต้น แนวคิดหลักคือ "ส่วนประกอบ" อาจเป็นอย่างอื่นที่ไม่ใช่ปุ่มหรือช่องทำเครื่องหมาย เจพาเนล.คุณจะได้รับอินเทอร์เฟซผู้ใช้ที่ค่อนข้างซับซ้อนโดยเพียงแค่วางแผงซ้อนกันและเลือกเค้าโครงสำหรับแผงเหล่านั้น

หากคุณมีอินสแตนซ์วัตถุ เจพาเนลเรียกวิธีการ .setLayoutเพื่อตั้งค่าประเภทโครงร่าง จากนั้นใช้วิธี .add เพื่อเพิ่มส่วนประกอบลงในพาเนล ในกรณีที่ BorderLayoutคุณจะต้องผ่านตำแหน่งเป็นพารามิเตอร์ตัวที่สอง เช่น หากต้องการวางตำแหน่งปุ่มไว้ด้านบน ให้โทร myPanel.add(myButton, BorderLayout.North).

คอนเทนเนอร์ระดับสูงสุดที่ปรากฏบนหน้าจอที่แสดงถึงแอปพลิเคชัน Java คืออินสแตนซ์ เจเฟรม, ไม่ เจพาเนล- เพื่อเพิ่มแผงหลักของคุณไปยังอินสแตนซ์ เจเฟรมแค่โทร myJFrame.getContentPane().add(myJPanel, BorderLayout.Center).

เพื่อให้แอปพลิเคชันของคุณเป็นมากกว่าแค่รูปลักษณ์ คุณจะต้องเข้าใจอินเทอร์เฟซ ActionListener- ใดๆ ที่ไม่ใช่นามธรรม ActionListenerมีเพียงวิธีเดียวเท่านั้น การกระทำที่ดำเนินการแล้วซึ่งจะถูกเรียกเมื่อผู้ใช้ดำเนินการ "การกระทำ" บนส่วนประกอบที่ผู้ฟังลงทะเบียนไว้ (ตัวอย่างเช่น เห็นได้ชัดว่าการกระทำบนปุ่มกำลังกดอยู่) หากต้องการลงทะเบียน action Listener สำหรับปุ่มหรือส่วนประกอบอื่นๆ ให้เรียกใช้เมธอด .addActionListener -

ขั้นตอน

การสร้างเฟรมที่ใช้ร่วมกัน

สร้างชั้นเรียนที่ขยายชั้นเรียน เจเฟรม. คลาสนี้จะมีส่วนประกอบอินเทอร์เฟซแบบกราฟิก (GUI) ทั้งหมดของคุณ เช่น ปุ่มและช่องข้อความ

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

เขียน Constructor สำหรับชั้นเรียนของคุณนักออกแบบรายนี้ควรสร้างแผงและส่วนประกอบทั้งหมดที่คุณวางแผนไว้ จัดเรียงอย่างถูกต้อง และเพิ่มแผงสุดท้ายที่ "ยึดทุกอย่าง" เข้ากับเฟรมของคุณ (myFrame.getContentPane().add(myLargePanel, BorderLayout.Center)

เขียนวิธีการหลักที่จะเป็นจุดเริ่มต้นของโปรแกรมในวิธีนี้ ให้สร้างอินสแตนซ์ของเฟรม กำหนดขนาดและตำแหน่งเริ่มต้น (use. กำหนดขนาด(x,y)และ .setLocation(ความกว้าง,ความสูง)) และให้ปรากฏบนหน้าจอโดยการโทร .setVisible(จริง)

การเขียนโปรแกรมตอบสนองต่อการกระทำของผู้ใช้

ทำให้เฟรมของคุณใช้อินเทอร์เฟซ ActionListener. สิ่งนี้จะช่วยให้ชั้นเรียนของคุณ "ฟัง" การกระทำของส่วนประกอบต่างๆ

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

แทนที่วิธีการนามธรรมของคลาส ActionListener ที่เรียกว่า actionPerformed (เหตุการณ์ ActionEvent) ในวิธีนี้ คุณควรเพิ่มคำสั่ง "if" แบบมีเงื่อนไขเพื่อตรวจสอบว่าเหตุการณ์มาจากไหน คำสั่ง "if" แบบมีเงื่อนไขนี้ควรมีเงื่อนไขดังนี้: " ถ้า (event.getSource() == button1)" วิธีนี้จะตรวจสอบว่าเหตุการณ์มาจากไหนและมาจากปุ่มหรือไม่ ภายในคำสั่ง "if" ให้ดำเนินการตามที่คุณต้องการเมื่อคลิกปุ่ม

คุณ JTextAreaมีวิธีหนึ่ง .setText("myText")ซึ่งเป็นวิธีที่ดีในการตั้งโปรแกรมการตอบสนองที่มองเห็นได้ต่อการกระทำของคุณ

การใช้อินเทอร์เฟซไม่ใช่เรื่องยากอีกต่อไป MouseListenerและใช้ .addMouseListenerเพื่อลงทะเบียนสำหรับส่วนประกอบใดๆ
หากคุณต้องการแจ้งให้ผู้ใช้ป้อนสตริง ให้เรียกใช้เมธอด static J OptionPane.showInputDialog (นี่คือ "ข้อความของฉัน")พารามิเตอร์แรกควรเป็นกรอบแอปพลิเคชันของคุณหรือแผงบางประเภท (ช่องป้อนข้อมูลจะปรากฏตรงกลางองค์ประกอบหลัก) วิธีการส่งกลับค่าที่ผู้ใช้ป้อนในกล่องโต้ตอบ
ค่อนข้างเป็นไปได้ที่จะวางส่วนประกอบทั้งหมดไว้ในแผงเดียวโดยใช้ประเภทนั้น GridBagLayoutแต่คลาสนี้ควบคุมยากกว่า
หากคุณต้องการวาดวัตถุกราฟิกของคุณเอง (เช่น กระดานหมากรุก) โปรดอ่านเกี่ยวกับส่วนประกอบ Canvas สามารถวางลงในแอปพลิเคชันของคุณได้เหมือนกับส่วนประกอบอื่นๆ แต่คุณจะต้องเขียนวิธี .paint ที่รับผิดชอบในการลงสีแต่เพียงผู้เดียว
ในการใช้งานจริงหลายๆ รายการ องค์ประกอบ Swing ที่มีประโยชน์มากที่สุดคือ JTable หลังจากเรียนรู้พื้นฐานแล้ว ให้ดำเนินการต่อไป

คำเตือน

เครื่องมือพัฒนาบางอย่างมีความสามารถในการเขียน Swing GUI ในลักษณะที่ "เป็นมิตรต่อผู้ใช้" อย่างไรก็ตาม พวกเขามักจะล้มเหลวในการสร้างแผงที่มีคุณสมบัติขั้นสูงอย่างเหมาะสม คุณลักษณะเหล่านี้ได้แก่ แผนภูมิ ตาราง รายการ และกล่องคำสั่งผสมที่เปลี่ยนแปลงเนื้อหาในขณะที่โปรแกรมทำงาน ส่วนประกอบที่มีแบบจำลองข้อมูลผู้ใช้ และอื่นๆ โค้ดที่เขียนในลักษณะ "ใช้งานง่าย" นี้จะกลายเป็นฝันร้ายอย่างแท้จริงหากคุณจำเป็นต้องเพิ่มด้วยตนเองในภายหลัง ดังนั้นอย่าไปยึดติดกับ "นักออกแบบ GUI ที่เป็นมิตรกับผู้ใช้" เหล่านี้มากเกินไป เพราะมันจะจำกัดตัวเลือกของคุณเนื่องจากความสามารถที่จำกัด
Swing เป็นแอปพลิเคชั่นแบบเธรดเดียว หากการกระทำของคุณใช้เวลาในการประมวลผลนานเกินไป การกระทำนั้นจะหยุดทำงานจนกว่าเมธอดจะออก .action ดำเนินการแล้ว- เรียนรู้และใช้ Java Multithreading เพื่อให้ Swing ยังคงอยู่ในขณะที่กระบวนการที่ใช้เวลานานกำลังทำงานอยู่
วิธีการส่วนประกอบ Swing ส่วนใหญ่สามารถเรียกได้อย่างปลอดภัยจากเธรดการจัดส่งเหตุการณ์เท่านั้น (method .action ดำเนินการแล้วและวิธีการฟังอื่นที่คล้ายคลึงกัน) หากคุณต้องการโทรหาพวกเขาจากเธรดอื่น (เช่น เพื่ออัปเดตแถบความคืบหน้าหรือแสดงผลลัพธ์ของกระบวนการที่ใช้เวลานาน) โปรดอ่านเกี่ยวกับ SwingUtils.inurgeLater.

แหล่งที่มา

ซอร์สโค้ด

นำเข้า java.awt.BorderLayout ; นำเข้า java.awt.FlowLayout ;นำเข้า java.awt.event.ActionEvent ; นำเข้า java.awt.event.ActionListener ;นำเข้า javax.swing.JButton ; นำเข้า javax.swing.JCheckBox ;นำเข้า javax.swing.JFrame ; นำเข้า javax.swing.JPanel ;นำเข้า javax.swing.JTextArea ; /** * แอปพลิเคชัน Java Swing ที่ง่ายมาก*ประกอบด้วยปุ่มและช่องทำเครื่องหมาย ตอบสนอง * ต่อการเปลี่ยนแปลงการควบคุมเหล่านี้ * โดยการเปลี่ยนข้อความในช่องข้อความหลัก * * @author audriusa */ WikiHow คลาสสาธารณะขยาย JFrame ใช้งาน ActionListener ( /** * Button. */ JButton myButton = new JButton ("Button" ) ; /** * Checkbox. */ JCheckBox myCheckBox = new JCheckBox ( "Check" ) ; /** * ช่องข้อความ- JTextArea myText = ใหม่ JTextArea ("ข้อความของฉัน" ) ;/** * แผงด้านล่างมีปุ่ม - JPanel BottomPanel = JPanel ใหม่();

/** * แผงหลักที่มีทุกอย่าง

สภาพแวดล้อมที่อนุญาตให้คุณวางส่วนประกอบบนแบบฟอร์มแบบโต้ตอบและตั้งค่าพารามิเตอร์ระหว่างการพัฒนาแอปพลิเคชันเรียกว่าสภาพแวดล้อม RAD RAD ย่อมาจาก Rapid Application Development - การพัฒนาแอปพลิเคชั่นอย่างรวดเร็ว

ใน NetBeans และสภาพแวดล้อมการพัฒนาสมัยใหม่อื่นๆ กระบวนการนี้อิงตามโมเดลออบเจ็กต์คอมโพเนนต์ ซึ่งเป็นสาเหตุที่เรียกว่าการออกแบบเชิงวัตถุ (OOD)

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

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

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

ตัวอย่างการเปิดโครงการด้วยซอร์สโค้ดที่มีอยู่

NetBeans 5.0 มีแอปพลิเคชัน GUI ตัวอย่างที่ดี แต่ NetBeans 5.5 ไม่มี ดังนั้นเพื่อดำเนินการต่อไปจึงควรคัดลอกตัวอย่างที่คล้ายกันจากเว็บไซต์ของผู้เขียนหรือเว็บไซต์ที่ลงหลักสูตรอบรมนี้ ตัวอย่างนี้เรียกว่า JavaApplicationGUI_example

ขั้นแรก คุณควรแตกไฟล์ zip และแยกโฟลเดอร์ที่มีไฟล์โปรเจ็กต์ที่อยู่ในนั้นไปยังโฟลเดอร์ที่มีโปรเจ็กต์ของคุณ (เช่น C:\Documents and Settings\User) จากนั้นเริ่มต้นสภาพแวดล้อม NetBeans หากยังไม่ได้ทำงานอยู่ และปิดโปรเจ็กต์ที่เปิดอยู่เพื่อป้องกันไม่ให้เกิดปัญหา จากนั้นเลือกไฟล์/เปิดโครงการจากเมนู หรือไอคอนที่มีโฟลเดอร์สีม่วงเปิดบนแถบเครื่องมือ หรือกดปุ่มผสม ++โอ ในกล่องโต้ตอบที่เปิดขึ้น ให้เลือกโฟลเดอร์ JavaApplicationGUI_example(ไม่ควรเข้าไปเลย แต่เพียงตั้งค่าส่วนที่เลือกไว้ในโฟลเดอร์นี้) จากนั้นคลิกปุ่มเปิดโฟลเดอร์โครงการ

ในกรณีนี้ หากคุณไม่ยกเลิกการเลือกช่องทำเครื่องหมาย "เปิดเป็นโครงการหลัก" โครงการจะกลายเป็นโครงการหลักโดยอัตโนมัติ

ข้อความต่อไปนี้ปรากฏในหน้าต่างตัวแก้ไขซอร์สโค้ด:

* GUI_application.java

แพ็คเกจ java_gui_example;

* @ผู้เขียน วาดิม โมนาคอฟ

GUI_application คลาสสาธารณะขยาย javax.swing.JFrame (

* สร้างรูปแบบใหม่ GUI_application

GUI_application สาธารณะ () (

initComponents();

/** วิธีการนี้ถูกเรียกจากภายในตัวสร้างถึง

* เริ่มต้นแบบฟอร์ม

* คำเตือน: ห้ามแก้ไขโค้ดนี้ เนื้อหาของวิธีนี้ก็คือ

* สร้างใหม่โดยตัวแก้ไขแบบฟอร์มเสมอ

โมฆะส่วนตัว exitMenuItemActionPerformed (java.awt.event.ActionEvent evt)

* @param args อาร์กิวเมนต์บรรทัดคำสั่ง

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

java.awt.EventQueue.invoidLater(ใหม่ Runnable() (

โมฆะสาธารณะวิ่ง() (

ใหม่ GUI_application().setVisible(จริง);

// การประกาศตัวแปร - ห้ามแก้ไข

javax.swing.JMenuItem ส่วนตัว aboutMenuItem;

javax.swing.JMenuItem ส่วนตัว contentsMenuItem;

javax.swing.JMenuItem ส่วนตัว copyMenuItem;

javax.swing.JMenuItem ส่วนตัว cutMenuItem;

javax.swing.JMenuItem ส่วนตัว DeleteMenuItem;

javax.swing.JMenu แก้ไขเมนูส่วนตัว;

javax.swing.JMenuItem ส่วนตัว exitMenuItem;

ไฟล์ javax.swing.JMenu ส่วนตัว

javax.swing.JMenu ส่วนตัวเมนูช่วยเหลือ;

ส่วนตัว javax.swing.JMenuBar แถบเมนู;

javax.swing.JMenuItem ส่วนตัว openMenuItem;

javax.swing.JMenuItem ส่วนตัว pasteMenuItem;

javax.swing.JMenuItem ส่วนตัว saveAsMenuItem;

javax.swing.JMenuItem ส่วนตัว saveMenuItem;

// สิ้นสุดการประกาศตัวแปร

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

GUI_application คลาสสาธารณะขยาย javax.swing.JFrame

หมายความว่ามีการกำหนด GUI_application คลาสสาธารณะ ซึ่งเป็นลูกหลานของคลาส JFrame ที่กำหนดในแพ็คเกจ swing ซึ่งซ้อนอยู่ในแพ็คเกจ javax คำว่าขยายแปลว่า "ขยาย" (คลาสที่สืบทอดจะขยายความสามารถของคลาสบรรพบุรุษเสมอ)

ตัวสร้าง GUI_application() สาธารณะสร้างอ็อบเจ็กต์แอปพลิเคชันและเริ่มต้นส่วนประกอบทั้งหมดโดยใช้เมธอด initComponents() ซึ่งสร้างขึ้นโดยอัตโนมัติโดยสภาพแวดล้อมการพัฒนาและซ่อนอยู่ในซอร์สโค้ดโดยโหนด +Generated Code

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

โมฆะส่วนตัว exitMenuItemActionPerformed

จะมีการหารือในภายหลังเล็กน้อย วิธี

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

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

กำลังเรียกใช้แอปพลิเคชัน แอปพลิเคชันพร้อมเมนูแบบขยาย

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

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

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

โปรแกรมแก้ไขหน้าจอ

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

การแก้ไขแบบฟอร์มหน้าจอ

แทนที่จะแสดงซอร์สโค้ด ลักษณะที่ปรากฏของรูปแบบหน้าจอและส่วนประกอบที่อยู่บนนั้นจะปรากฏขึ้น ทางด้านขวาของหน้าต่างที่แสดงรูปแบบหน้าจอในโหมดแก้ไข จะมีหน้าต่าง Palette สำหรับแผงส่วนประกอบและหน้าต่าง Properties สำหรับการแสดงและแก้ไขคุณสมบัติของส่วนประกอบปัจจุบัน

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

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

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

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

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

ป้อน "ตกลง" บนปุ่ม - ใช้ปุ่มนี้เพื่อออกจากโปรแกรม

การแก้ไขคุณสมบัติของส่วนประกอบ

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

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

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

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

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

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

ชื่อคุณสมบัติ	มันถามอะไร?
พื้นหลัง	สีพื้นหลัง
ส่วนประกอบ PopupMenu	ช่วยให้คุณกำหนดเมนูป๊อปอัปที่ปรากฏขึ้นเมื่อคุณคลิกขวาในพื้นที่ส่วนประกอบ
แบบอักษร	แบบอักษรที่ใช้เขียนบนส่วนประกอบ
เบื้องหน้า	สีของแบบอักษรที่ใช้สำหรับคำจารึกบนส่วนประกอบ
ไอคอน	รูปภาพที่วาดบนส่วนประกอบถัดจากข้อความ
ข้อความ	ข้อความ (ฉลาก) บนส่วนประกอบ
toolTipText	คำแนะนำเครื่องมือที่ปรากฏขึ้นหลังจากผ่านไประยะหนึ่งเมื่อคุณวางเมาส์ไว้เหนือส่วนประกอบ
ชายแดน	ประเภทของเฟรมรอบส่วนประกอบ
เส้นขอบทาสี	มีการวาดเส้นขอบรอบๆ ส่วนประกอบหรือไม่
เนื้อหาAreaFilled	มีการเติมสีสำหรับพื้นที่ภายในของส่วนประกอบ (สำหรับปุ่ม จะสร้างเอฟเฟกต์สามมิติ หากไม่มีการเติม ปุ่มจะดูแบน)
defaultCapable	ปุ่มสามารถเป็น "ปุ่มเริ่มต้น" ได้หรือไม่: เมื่อกด “ปุ่มเริ่มต้น” จะถูกกดโดยอัตโนมัติ (ควรมีปุ่มดังกล่าวหนึ่งปุ่มบนหน้าจอ)
เปิดใช้งาน	ไม่ว่าส่วนประกอบจะพร้อมใช้งานหรือไม่ ตามค่าเริ่มต้น ส่วนประกอบทั้งหมดที่สร้างขึ้นบนแบบฟอร์มจะพร้อมใช้งาน ส่วนประกอบที่ไม่สามารถเข้าถึงได้จะถูกทาสีด้วยสีที่เข้มกว่า

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

สุดท้ายนี้ เรามาตั้งค่าการกระทำที่จะดำเนินการเมื่อมีการคลิกปุ่ม - ตัวจัดการเหตุการณ์(ตัวจัดการเหตุการณ์) คลิกปุ่ม เมื่อต้องการทำเช่นนี้ ขั้นแรกให้เลือกปุ่ม จากนั้นคลิกขวาที่ปุ่ม และในเมนูป๊อปอัปที่ปรากฏขึ้น ให้เลือกเหตุการณ์/การดำเนินการ/การดำเนินการที่ดำเนินการ

การกำหนดตัวจัดการเหตุการณ์

เหตุการณ์ หมายถึง "เหตุการณ์" การกระทำ หมายถึง "การกระทำ" การกระทำที่ดำเนินการ หมายถึง "การกระทำที่ดำเนินการ"

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

// TODO เพิ่มรหัสการจัดการของคุณที่นี่:

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

ถัดจากตัวจัดการ jButton1ActionPerformed จะมีตัวจัดการเหตุการณ์ที่มีอยู่ซึ่งจะถูกทริกเกอร์เมื่อมีการคลิกรายการเมนู "ออก":

โมฆะส่วนตัว exitMenuItemActionPerformed (java.awt.event.ActionEvent evt) (

มาแทนที่บรรทัดด้วยความคิดเห็นในตัวจัดการเหตุการณ์ของเราด้วยโค้ดที่ทำให้โปรแกรมออก:

โมฆะส่วนตัว jButton1ActionPerformed (java.awt.event.ActionEvent evt) (

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

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

javax.swing.JOptionPane.showMessageDialog(null,"ฉันถูกคลิก");

หากนำเข้าคลาสแพ็กเกจ javax.swing ไม่จำเป็นต้องใช้คำนำหน้า javax.swing เมื่อเรียกใช้คลาสเหล่านั้น

ลักษณะการสมัคร

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

ลักษณะที่ปรากฏของแอปพลิเคชันที่ทำงานอยู่พร้อมอินเทอร์เฟซผู้ใช้ที่ไม่ขึ้นกับแพลตฟอร์มที่ตั้งค่าไว้ตามค่าเริ่มต้น

นอกจากนี้ แอปพลิเคชันของเราจะปรากฏที่มุมซ้ายบนของหน้าจอ แต่เราต้องการให้ปรากฏที่กึ่งกลาง

ในการแสดงแอปพลิเคชันในรูปแบบเฉพาะแพลตฟอร์ม (นั่นคือ ในรูปแบบที่ใช้ส่วนประกอบและการตั้งค่าของระบบปฏิบัติการ) คุณต้องเปลี่ยนโค้ดตัวสร้างแอปพลิเคชันโดยการแทรกประเภทอินเทอร์เฟซผู้ใช้ (อินเทอร์เฟซผู้ใช้ ย่อว่า UI) ก่อนที่จะเรียกใช้เมธอด initComponents:

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

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

GUI_application สาธารณะ () (

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

)จับ(ข้อยกเว้น e)();

initComponents();

ขนาด screenSize = Toolkit.getDefaultToolkit().getScreenSize();

ขนาด frameSize = getSize();

setLocation (จุดใหม่ ((screenSize.width-frameSize.width)/2,

(screenSize.height-frameSize.width)/2)

ลักษณะที่ปรากฏของแอปพลิเคชันที่ทำงานอยู่พร้อมอินเทอร์เฟซผู้ใช้ที่เน้นแพลตฟอร์มในระบบปฏิบัติการ Windows ® ประสบการณ์

รหัสที่ตามหลังการเรียก initComponents() คือการตั้งค่าหน้าต่างแอปพลิเคชันให้อยู่ตรงกลางหน้าจอ

คุณสามารถระบุแอปพลิเคชันประเภทอื่นที่ไม่ขึ้นกับแพลตฟอร์มได้ - ในรูปแบบ Motiff ที่ใช้ในระบบปฏิบัติการ Solaris ® ให้ตั้งค่าประเภทนี้แทนการโทร

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()

ควรจะเขียน

UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");

ลักษณะที่ปรากฏของแอปพลิเคชันที่ทำงานอยู่พร้อมอินเทอร์เฟซผู้ใช้ที่ไม่ขึ้นกับแพลตฟอร์มในสไตล์ Motiff

โครงสร้างที่ใช้จะชัดเจนต่อผู้อ่านหลังจากศึกษาส่วนเพิ่มเติมของคู่มือ

การจัดการโครงการ

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

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

· เมื่อสร้างโปรเจ็กต์ใหม่ สภาพแวดล้อมการพัฒนาจะแจ้งให้คุณป้อนชื่อโฟลเดอร์ที่จะจัดเก็บ - คุณควรระบุชื่อของโฟลเดอร์เก็บถาวร คุณยังได้รับแจ้งให้ป้อนชื่อโครงการด้วย NetBeans จะใช้ชื่อนี้เพื่อสร้างทั้งโฟลเดอร์โครงการและชื่อแอปพลิเคชันของคุณ เพื่อให้ใบสมัครของคุณทำงานในประเทศต่างๆ ได้ง่ายขึ้น ขอแนะนำให้ตั้งชื่อนี้เป็นภาษาอังกฤษ ในโฟลเดอร์โปรเจ็กต์ สภาพแวดล้อมการพัฒนาจะสร้างระบบโฟลเดอร์ย่อยสำหรับโปรเจ็กต์และไฟล์ทั้งหมดโดยอัตโนมัติ โครงสร้างโฟลเดอร์โครงการ NetBeans ได้รับการอธิบายไว้ก่อนหน้านี้

· หากใช้โปรเจ็กต์ที่มีซอร์สโค้ดที่มีอยู่ โฟลเดอร์ของโปรเจ็กต์จะถูกคัดลอกไปยังโฟลเดอร์เก็บถาวรของเราด้วยตนเองหรือโดยการเลือกลำดับการดำเนินการที่เหมาะสมใน NetBeans Project Creation Wizard

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

การสร้างสำเนาการทำงานของโครงการ

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

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

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

นโยบายต่างประเทศของสหภาพโซเวียตในช่วงปีสงคราม ให้ยืม-เช่า การประชุมเตหะราน การประชุมยัลตาและพอทสดัม พ.ศ. 2488 การสร้างสหประชาชาติ

นโยบายต่างประเทศของสหภาพโซเวียตในช่วงสงคราม การประชุมเตหะราน การประชุมยัลตาและพอทสดัม พ.ศ. 2488 การสร้างสหประชาชาติ

การกลับมาดำเนินกิจกรรมของ BSG อีกครั้ง การก่อตั้งพรรคและองค์กร Belnats

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

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

อันดับแรก ควรให้ความสนใจกับไลบรารี GTK+

มีให้บริการไม่เฉพาะสำหรับ Java เท่านั้น แต่ยังใช้ได้กับภาษาอื่น ๆ อีกมากมาย: C++, C และอื่น ๆ

ควรใช้การเขียนแอปพลิเคชันเดสก์ท็อปโดยใช้ GTK หากแอปพลิเคชันได้รับการออกแบบให้ทำงานภายใต้สภาพแวดล้อม GNOME

GTK+ ถือเป็นหนึ่งในไลบรารีที่ง่ายที่สุดสำหรับ Jav ในการเรียนรู้

พื้นฐานการทำงานกับห้องสมุด:

ก่อนอื่นคุณต้องเชื่อมต่อไลบรารีกับผลที่ตามมาทั้งหมด:

นำเข้า org.gnome.gdk.Event ;
นำเข้า org.gnome.gtk.Gtk ;
นำเข้า org.gnome.gtk.Widget ;
นำเข้า org.gnome.gtk.Window ;
นำเข้า org.gnome.gtk.WindowPosition ;

หากเกิดข้อผิดพลาด เป็นไปได้มากว่าคุณไม่ได้ติดตั้งไลบรารี่ไว้

หากคุณใช้ระบบเช่น Debian หรือ Ubuntu คำสั่งง่ายๆ จากเทอร์มินัลจะช่วยคุณ:
apt-get ติดตั้ง libjava-gnome-java

หลังจากนี้ไม่น่าจะมีปัญหา

DesktopExample ระดับสาธารณะขยายหน้าต่าง (
DesktopExample สาธารณะ () (
ชื่อเรื่อง( "หน้าต่างตัวอย่างบน GTK และ Gnome") ; // ชื่อแอปพลิเคชัน
เชื่อมต่อ (หน้าต่างใหม่ .DeleteEvent() (
บูลีนสาธารณะ onDeleteEvent (แหล่งที่มาของวิดเจ็ต เหตุการณ์กิจกรรม) (
Gtk.mainQuit();
กลับเท็จ;
}
} ) ;
ตั้งค่าขนาดเริ่มต้น(250, 150);
// ขนาด setPosition(หน้าต่างตำแหน่ง.CENTER);
//ตำแหน่งเมื่อเปิดตัว ในกรณีนี้คืออยู่ตรงกลาง
}

แสดง() ;
Gtk.init(args);
DesktopExample ใหม่ () ;
}
}

Gtk.main();

เราจบลงด้วยหน้าต่างว่างเปล่า
AWT ถือเป็นระบบดั้งเดิมสำหรับการพัฒนาส่วนต่อประสานกราฟิกและถูกวิพากษ์วิจารณ์เนื่องจากข้อเท็จจริงที่ว่า
มันไม่ได้ทำงานได้อย่างเสถียรบนแพลตฟอร์มที่แตกต่างกันเสมอไป แต่ตอนนี้ดูเหมือนว่าจะไม่มีปัญหาดังกล่าวแล้ว และสะดวกที่จะใช้งานด้วย
IMHO นี่คือตัวเลือกของฉัน
SWT เป็นผลงานของ IBM ซึ่งเป็นระบบที่ได้รับการขัดเกลาและซ้ำซาก ซึ่งโดยทั่วไปมีลักษณะการทำงานที่เสถียรและเรียนรู้ได้ง่าย
แต่ SWT หนักกว่า AWT มีฟังก์ชันการทำงานมากกว่า และผลที่ตามมาก็คือซับซ้อนกว่า AWT

แต่ฉันจะไม่ใช้มันบ่อยถึงแม้ว่ามันจะค่อนข้างเป็นที่นิยมและเป็นของตัวเองก็ตาม

นี่คือตัวอย่างหน้าต่างบน AWT:
// เราเชื่อมโยงคุณสมบัติทุกประเภท แม้ว่าการแกว่งจะไม่จำเป็นที่นี่ แต่ฉันได้เพิ่มสิ่งนี้ลงในแอปพลิเคชันของฉัน
// นี่เป็นเพียงตัวอย่างโค้ด
นำเข้า java.awt.EventQueue ;
นำเข้า javax.swing.* ;
นำเข้า java.awt.* ;
นำเข้า java.awt.event.* ;
นำเข้า javax.swing.JFrame ;
ชั้นเรียนสาธารณะ Main(
/**
เฟรม JFrame ส่วนตัว
*/
* การเปิดแอปพลิเคชัน บางอย่างเช่น การตั้งค่าเริ่มต้น การสร้างหน้าต่าง และอะไรทำนองนั้น
โมฆะคงสาธารณะหลัก (String args) (
EventQueue.inurgeLater (เรียกใช้ใหม่ () (
โมฆะสาธารณะวิ่ง() (
พยายาม (
หน้าต่างหลัก = หลักใหม่ () ;
window.frame.setVisible (จริง);
) จับ (ข้อยกเว้น e) (
}
}
} ) ;
}
/**
e.printStackTrace();
*/
* เรียกการเริ่มต้นเอง
สาธารณะหลัก () (
}
/**
เริ่มต้น() ;
*/
* การเริ่มต้นหน้าต่าง
โมฆะส่วนตัวเริ่มต้น () ( เฟรม = JFrame ใหม่ () ; "ล้างหน้าต่างที่สร้างผ่าน Eclipse"
// สร้างหน้าต่างใหม่ด้วยชื่อ
frame.setBounds(100, 100, 450, 300);
frame.setSize(800, 800);
}

// ขนาด

frame.setDefaultCloseOperation (JFrame .EXIT_ON_CLOSE ) ;
นี่คือตัวอย่างหน้าต่างบน SWT:
//เราเชื่อมโยงฟีเจอร์ทุกประเภทเพื่อชีวิตที่สนุกสนาน นำเข้า org.eclipse.swt.SWT ;;
นำเข้า
org.eclipse.swt.widgets.Display
นำเข้า org.eclipse.swt.widgets.Shell ;
นำเข้า org.eclipse.swt.widgets.Text ;
ExampleApp คลาสสาธารณะ (
โมฆะคงสาธารณะหลัก (String args) (
เชลล์.แพ็ค(); //การเตรียมตัว (ประถมศึกษา)
เชลล์.เปิด(); //เตรียมตัว
ในขณะที่ (! shell.isDisposed () ) ( //Launch
ถ้า (! display.readAndDispatch()) display.sleep(); //ขอตัวไปนอนก่อนนะครับ.
}
display.ทิ้ง();
}
}

โดยหลักการแล้วมันไม่ซับซ้อนและมีหลายแพลตฟอร์ม มันมีคุณสมบัติจำนวนมากและปลั๊กอินเพิ่มเติมจำนวนเล็กน้อย

นี่คือตัวอย่างของหน้าต่างที่มีการแกว่ง:

นำเข้า java.awt.event.* ;
นำเข้า javax.swing.SwingUtilities ;
ตัวอย่างคลาสสาธารณะขยาย JFrame (
ตัวอย่างสาธารณะ () (
ตั้งชื่อเรื่อง( “ตัวอย่างการใช้งานกับ Swinga”) ;
กำหนดขนาด(300, 200);
setLocationRelativeTo(null) ;
setDefaultCloseOperation(EXIT_ON_CLOSE) ;
}
* การเปิดแอปพลิเคชัน บางอย่างเช่น การตั้งค่าเริ่มต้น การสร้างหน้าต่าง และอะไรทำนองนั้น
SwingUtilities.inurgeLater (เรียกใช้ใหม่ () (
EventQueue.inurgeLater (เรียกใช้ใหม่ () (
ตัวอย่าง เช่น = ใหม่ ตัวอย่าง() ;
อดีตsetVisible(จริง);
}
} ) ;
}
}

นี่คือรายการหลักของสภาพแวดล้อมแบบกราฟิกใน Java “สิ่งของ” เกือบทั้งหมดที่นำเสนอที่นี่มีหลายแพลตฟอร์ม
และทำงานบนคอมพิวเตอร์เครื่องใดก็ได้ - Win, Linux, Mac

แท็ก: Java, ไลบรารี Java, ส่วนต่อประสานกราฟิก Java

สวิงคืออะไร?

Java Swing เป็นชุดเครื่องมือ Graphical User Interface (GUI) น้ำหนักเบาที่มีวิดเจ็ตมากมาย ประกอบด้วยแพ็คเกจที่ให้คุณสร้างส่วนประกอบ GUI สำหรับแอปพลิเคชัน Java ของคุณและเป็นแพลตฟอร์มอิสระ

ไลบรารี Swing ถูกสร้างขึ้นบน Java Abstract Widget Toolkit ( เอ.ดับบลิว.ที.) ชุดเครื่องมือ GUI รุ่นเก่าที่ขึ้นกับแพลตฟอร์ม คุณสามารถใช้ส่วนประกอบ Java GUI เช่น ปุ่ม กล่องข้อความ ฯลฯ จากไลบรารีและไม่ต้องสร้างส่วนประกอบตั้งแต่ต้น

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้-

ไดอะแกรมลำดับชั้นของคลาส Java Swing

ส่วนประกอบทั้งหมดในการแกว่งคือ JComponent ซึ่งสามารถเพิ่มลงในคลาสคอนเทนเนอร์ได้

คลาสคอนเทนเนอร์คืออะไร?

คลาสคอนเทนเนอร์คือคลาสที่สามารถมีส่วนประกอบอื่นอยู่ได้ ดังนั้นในการสร้าง GUI เราจำเป็นต้องมีออบเจ็กต์คอนเทนเนอร์อย่างน้อยหนึ่งรายการ ภาชนะมี 3 ประเภท

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

ตัวอย่าง Java GUI

ตัวอย่าง: เพื่อเรียนรู้การออกแบบ GUI ใน Java
ขั้นตอนที่ 1)คัดลอกโค้ดต่อไปนี้ลงในโปรแกรมแก้ไข

นำเข้า javax.swing.*; คลาส gui ( โมฆะสาธารณะคงที่ main (String args) ( JFrame frame = new JFrame ("My First GUI"); frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); frame.setSize (300,300); ปุ่ม JButton = ใหม่ JButton ("กด" ); frame.getContentPane().add(button); // เพิ่มปุ่มลงในบานหน้าต่างเนื้อหา frame.setVisible(true) );

ขั้นตอนที่ 2)บันทึก คอมไพล์ และรันโค้ด
ขั้นตอนที่ 3)ตอนนี้เรามาเพิ่มปุ่มลงในเฟรมของเรา

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

คลาส gui ( โมฆะสาธารณะคงหลัก (สตริง args) ( JFrame frame = ใหม่ JFrame ("My First GUI"); frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); frame.setSize (300,300); JButton button1 = ใหม่ JButton ("กด" ); frame.getContentPane().add(button1); frame.setVisible(จริง);ขั้นตอนที่ 4)

ดำเนินการรหัส คุณจะได้รับปุ่มใหญ่ขั้นตอนที่ 5)

แล้วจะเพิ่มสองปุ่มล่ะ? คัดลอกโค้ดต่อไปนี้ลงในโปรแกรมแก้ไข

นำเข้า javax.swing.*; คลาส gui ( โมฆะสาธารณะคงหลัก (สตริง args) ( JFrame frame = ใหม่ JFrame ("My First GUI"); frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); frame.setSize (300,300); JButton button1 = ใหม่ JButton ("ปุ่ม 1 "); JButton button2 = ใหม่ JButton("ปุ่ม 2"); frame.getContentPane().add(button1); frame.getContentPane().add(button2); frame.setVisible(true); ) )ขั้นตอนที่ 6)
บันทึก คอมไพล์ และรันโปรแกรมขั้นตอนที่ 7)

ผลลัพธ์ที่ไม่คาดคิด =? ปุ่มต่างๆ ซ้อนทับกัน

ผู้จัดการเค้าโครง Java

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

Java BorderLayout

BorderLayout วางส่วนประกอบต่างๆ ไว้สูงสุดห้าส่วน: บน ล่าง ซ้าย ขวา และกึ่งกลาง เป็นตัวจัดการโครงร่างเริ่มต้นสำหรับ Java JFrame ทุกตัว

Java FlowLayout

FlowLayout เป็นตัวจัดการเค้าโครงเริ่มต้นสำหรับ JPanel ทุกตัว โดยจะวางส่วนประกอบต่างๆ ไว้ในแถวเดียวเรียงกัน

Java GridBagLayout

มันมีความซับซ้อนมากกว่าเลย์เอาต์ทั้งหมด โดยจะจัดองค์ประกอบต่างๆ โดยการวางไว้ภายในตารางของเซลล์ ทำให้ส่วนประกอบต่างๆ ขยายได้มากกว่าหนึ่งเซลล์ขั้นตอนที่ 8)

ลองสร้างกรอบแชทแบบด้านล่างนี้ดูไหม?

//โดยปกติคุณจะต้องใช้ทั้งแพ็คเกจ swing และ awt //แม้ว่าคุณจะทำงานแค่การแกว่งก็ตาม นำเข้า javax.swing.*; นำเข้า java.awt.*; class gui ( public static void main (String args) ( // การสร้างเฟรม JFrame frame = new JFrame ("Chat Frame"); frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE); frame.setSize (400, 400); // การสร้าง MenuBar และการเพิ่มส่วนประกอบ JMenuBar(); m11 = new JMenuItem("Open"); JPanel(); // แผงควบคุมไม่สามารถมองเห็นได้ในเอาต์พุต JLabel label = new JLabel("Enter Text"); ); // ยอมรับได้มากถึง 10 ตัวอักษร JButton send = new JButton("Send") ; JButton Reset = new JButton("Reset"); // Components Added using Flow Layout panel.add(send); เพิ่ม(รีเซ็ต); // พื้นที่ข้อความตรงกลาง JTextArea ta = new JTextArea();

//เพิ่มส่วนประกอบให้กับเฟรม

frame.getContentPane().add(BorderLayout.SOUTH, แผง);

frame.getContentPane().add(BorderLayout.NORTH, mb);

frame.getContentPane().add(BorderLayout.CENTER, ta);

frame.setVisible(จริง);

-

เรียบเรียงโดย Saleem Gul และ Tomas Pavek

เลือกไฟล์ > โปรเจ็กต์ใหม่ คุณยังสามารถคลิกไอคอนโครงการใหม่บนแถบเครื่องมือ IDE
ในพื้นที่หมวดหมู่ เลือกโหนด Java ในพื้นที่ "โครงการ" เลือก "แอปพลิเคชัน Java" คลิกปุ่ม "ถัดไป"
ป้อน NumberAddition ในช่องชื่อโปรเจ็กต์ และระบุพาธ เช่น โฮมไดเร็กทอรีของคุณ เป็นที่ตั้งโปรเจ็กต์
เลือกช่องทำเครื่องหมาย "ใช้โฟลเดอร์แยกต่างหากเพื่อจัดเก็บไลบรารี" และระบุตำแหน่งของโฟลเดอร์ไลบรารี (ไม่บังคับ) สำหรับข้อมูลเพิ่มเติม ให้ดูที่การแชร์ไลบรารีกับผู้อื่นในเอกสาร การพัฒนาแอพพลิเคชั่นด้วย NetBeans IDE.
ลบช่องทำเครื่องหมาย "สร้างคลาสหลัก" หากทำเครื่องหมายไว้
คลิกปุ่ม "เสร็จสิ้น"

แบบฝึกหัดที่ 2: การสร้างส่วนหน้า

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

การสร้างคอนเทนเนอร์ JFrame

ในหน้าต่างโปรเจ็กต์ คลิกขวาที่โหนด NumberAddition และเลือกใหม่ > อื่นๆ
ในกล่องโต้ตอบสร้างไฟล์ ให้เลือกหมวดหมู่แบบฟอร์ม Swing GUI และประเภทไฟล์แบบฟอร์ม JFrame คลิกปุ่ม "ถัดไป"
ป้อน NumberAdditionUI เป็นชื่อคลาส
เลือกแพ็คเกจ my.numberaddition
คลิกปุ่ม "เสร็จสิ้น"

IDE จะสร้างแบบฟอร์ม NumberAdditionUI และคลาส NumberAdditionUI ในแอปพลิเคชัน NumberAddition และเปิดแบบฟอร์ม NumberAdditionUI ในตัวสร้าง GUI แพ็คเกจ my.NumberAddition แทนที่แพ็คเกจเริ่มต้น

การเพิ่มองค์ประกอบ: การสร้างส่วนหน้า

จากนั้น เมื่อใช้หน้าต่าง "Palette" อินเทอร์เฟซภายนอกของแอปพลิเคชันจะเต็มไปด้วย JPanel หลังจากนี้ องค์ประกอบ JLabel สามรายการ (ป้ายกำกับข้อความ) องค์ประกอบ JTextField สามรายการ (ฟิลด์ข้อความ) และองค์ประกอบ JButton สามรายการ (ปุ่ม) จะถูกเพิ่ม หากคุณไม่เคยทำงานร่วมกับนักออกแบบ GUI มาก่อน โปรดดูการออกแบบ Swing GUI ใน NetBeans IDE สำหรับข้อมูลเกี่ยวกับการจัดวางส่วนประกอบ

หลังจากลากและวางองค์ประกอบด้านบนแล้ว องค์ประกอบ JFrame ควรมีลักษณะเหมือนภาพด้านล่าง

หากไม่มีหน้าต่าง Palette ที่มุมขวาบนของ IDE ให้เลือก Window > Palette

ในการเริ่มต้น ให้เลือกพาเนลจากหมวดหมู่ Swing Containers ในพาเล็ตแล้วลากไปยัง JFrame
JPanel จะถูกเน้น ไปที่หน้าต่างคุณสมบัติแล้วคลิกปุ่มจุดไข่ปลา (...) ถัดจากช่องเส้นขอบเพื่อเลือกสไตล์เส้นขอบ
ในกล่องโต้ตอบ เส้นขอบ ให้เลือก TitledBorder จากรายการ และป้อน Number Addition ในฟิลด์ Title คลิก "ตกลง" เพื่อบันทึกการเปลี่ยนแปลงและปิดกล่องโต้ตอบ
ตอนนี้หน้าจอควรแสดงองค์ประกอบ "JFrame" ที่ว่างเปล่าพร้อมชื่อ "การบวกหมายเลข" ดังที่แสดงในภาพ ตามรูปภาพ ให้เพิ่ม JLabels สามอัน JTextFields สามอัน และ JButtons สามอันลงไป

การเปลี่ยนชื่อองค์ประกอบ

ขั้นตอนนี้จะเปลี่ยนชื่อองค์ประกอบที่เพิ่มเข้าไปในองค์ประกอบ JFrame

ดับเบิลคลิก jLabel1 และเปลี่ยน ntrcn (คุณสมบัติ "text") เป็น First Number
ดับเบิลคลิก jLabel2 และเปลี่ยนข้อความเป็น Second Number
ดับเบิลคลิก jLabel3 และเปลี่ยนข้อความเป็นผลลัพธ์
ลบข้อความเริ่มต้นออกจาก jTextField1 ข้อความที่แสดงสามารถแปลงเป็นข้อความที่แก้ไขได้ โดยคลิกขวาที่ช่องข้อความแล้วเลือก "แก้ไขข้อความ" จากเมนูป๊อปอัป คุณอาจต้องคืนค่า jTextField1 ให้เป็นขนาดดั้งเดิม ทำซ้ำขั้นตอนนี้สำหรับฟิลด์ jTextField2 และ jTextField3
เปลี่ยนข้อความที่แสดงของ jButton1 เป็น Clear (หากต้องการเปลี่ยนข้อความของปุ่ม ให้คลิกขวาที่ปุ่มแล้วเลือกแก้ไขข้อความ หรือคุณสามารถคลิกปุ่ม หยุดชั่วคราว แล้วคลิกอีกครั้ง)
เปลี่ยนข้อความที่แสดงของ jButton2 เป็น Add
เปลี่ยนข้อความที่แสดงของ jButton3 เป็น Exit

ตอนนี้ GUI ที่เสร็จแล้วควรมีลักษณะเหมือนภาพด้านล่าง:

แบบฝึกหัดที่ 3: การเพิ่มฟังก์ชันการทำงาน

แบบฝึกหัดนี้จะเพิ่มฟังก์ชันการทำงานที่จำเป็นให้กับปุ่มเพิ่ม ล้าง และออก ฟิลด์ jTextField1 และ jTextField2 จะถูกใช้สำหรับการป้อนข้อมูลของผู้ใช้ และ jTextField3 จะถูกใช้เพื่อแสดงผลลัพธ์ของโปรแกรม โปรแกรมที่สร้างขึ้นเป็นเครื่องคิดเลขอย่างง่าย มาเริ่มกันเลย!

การเพิ่มฟังก์ชันการทำงานให้กับปุ่มออก

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

คลิกขวาที่ปุ่ม "ออก" จากเมนูป๊อปอัป ให้เลือกเหตุการณ์ > การดำเนินการ > การดำเนินการที่ดำเนินการ โปรดทราบว่าเมนูประกอบด้วยกิจกรรมอื่น ๆ อีกมากมายที่โปรแกรมสามารถตอบสนองได้! เมื่อคุณเลือกเหตุการณ์ actionPerformed IDE จะเพิ่ม ActionListener ให้กับปุ่มออกโดยอัตโนมัติ และสร้างเมธอดตัวจัดการเพื่อจัดการกับเมธอด actionPerformed Listener
IDE จะเปิดหน้าต่าง "ซอร์สโค้ด" โดยอัตโนมัติ โดยแสดงตำแหน่งที่จะแทรกการกระทำที่คุณต้องการให้ปุ่มดำเนินการเมื่อคุณคลิก (ด้วยเมาส์หรือแป้นพิมพ์) หน้าต่าง "ซอร์สโค้ด" ควรมีบรรทัดต่อไปนี้: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO เพิ่มโค้ดการจัดการของคุณที่นี่: )
ตอนนี้เรามาเพิ่มโค้ดสำหรับการดำเนินการที่ปุ่ม "ออก" ควรทำ แทนที่บรรทัด TODO ด้วย System.exit(0); - โค้ดที่เสร็จสิ้นแล้วสำหรับปุ่ม "ออก" ควรมีลักษณะดังนี้: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

การเพิ่มฟังก์ชันการทำงานให้กับปุ่ม "ล้าง"

คลิกขวาที่ปุ่ม "ล้าง" (jButton1) จากเมนูที่ปรากฏขึ้น ให้เลือก "เหตุการณ์ > การดำเนินการ > การดำเนินการที่ดำเนินการ"
การคลิกปุ่ม "ล้าง" ข้อความทั้งหมดจะถูกลบออกจากช่องข้อความ "jTextField" ทั้งหมด เมื่อต้องการทำเช่นนี้ ให้เพิ่มโค้ดที่คล้ายกับโค้ดด้านบน ซอร์สโค้ดที่เสร็จแล้วควรมีลักษณะดังนี้: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

โค้ดนี้จะลบข้อความออกจาก JTextFields ทั้งสามรายการ โดยปล่อยว่างไว้

การเพิ่มฟังก์ชันการทำงานให้กับปุ่ม "เพิ่ม"

ปุ่ม "เพิ่ม" ควรทำสามสิ่ง

ก่อนอื่นจะใช้อินพุตของผู้ใช้ในฟิลด์ jTextField1 และ jTextField2 และแปลงจากประเภท "String" เป็นประเภท "Float"
จากนั้นจะทำการบวกเลขสองตัวนั้น
สุดท้ายมันจะแปลงผลรวมเป็น String และวางไว้ใน jTextField3

เริ่มกันเลย!

คลิกแท็บออกแบบที่ด้านบนของพื้นที่ทำงานเพื่อกลับไปที่หน้าจอการออกแบบแบบฟอร์ม
คลิกขวาที่ปุ่ม "เพิ่ม" (jButton2) จากเมนูป๊อปอัป ให้เลือกเหตุการณ์ > การดำเนินการ > การดำเนินการที่ดำเนินการ
เพิ่มโค้ดสำหรับการดำเนินการที่ปุ่ม "เพิ่ม" ควรทำ ซอร์สโค้ดที่เสร็จแล้วควรมีลักษณะดังนี้: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // ก่อนอื่นเรากำหนดตัวแปร float. float num1, num2, result; // เราต้องแยกวิเคราะห์ข้อความเป็นประเภท float . num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // ตอนนี้เราสามารถดำเนินการเพิ่ม = num1+num2; // ในเวลาเดียวกัน เราจะ // เปลี่ยนค่าของผลลัพธ์จาก float เป็นสตริง jTextField3.setText(String.valueOf(result));

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

แบบฝึกหัดที่ 4: การรันโปรแกรม

หากต้องการรันโปรแกรมใน IDE ให้ทำตามขั้นตอนเหล่านี้:

เลือก รัน > รันโปรเจ็กต์หลัก (หรือกด F6)
บันทึก.หากคุณเปิดหน้าต่างที่ระบุว่า Project NumberAddition ไม่ได้ระบุคลาสหลัก คุณควรเลือก my.NumberAddition.NumberAdditionUI เป็นคลาสหลักในหน้าต่างเดียวกัน และคลิก ตกลง

หากต้องการรันโปรแกรมภายนอก IDE ให้ทำตามขั้นตอนเหล่านี้:

หลังจากนั้นไม่กี่วินาที แอปพลิเคชันจะเปิดขึ้น

บันทึก.หากการดับเบิลคลิกไฟล์ JAR ไม่เปิดแอปพลิเคชัน โปรดดูการเชื่อมโยงไฟล์ JAR บนระบบปฏิบัติการของคุณสำหรับข้อมูลเพิ่มเติม

คุณยังสามารถเรียกใช้แอปพลิเคชันได้จากบรรทัดคำสั่ง

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

เปิดพรอมต์คำสั่งหรือหน้าต่างเทอร์มินัล
ที่พรอมต์คำสั่ง เปลี่ยนไดเร็กทอรีปัจจุบันเป็นไดเร็กทอรี NumberAddition/dist
ที่พร้อมต์คำสั่ง ให้ป้อนคำสั่งต่อไปนี้: java -jar NumberAddition.jar
บันทึก.ตรวจสอบให้แน่ใจว่า my.NumberAddition.NumberAdditionUI ได้รับการตั้งค่าเป็นคลาสหลักก่อนเรียกใช้แอปพลิเคชัน หากต้องการตรวจสอบสิ่งนี้ ให้คลิกขวาที่โหนดโปรเจ็กต์ NumberAddition ในแผงโปรเจ็กต์ เลือก Properties จากเมนูป๊อปอัป และเลือกหมวด Run ในกล่องโต้ตอบ Project Properties ฟิลด์ Main Class ควรแสดง my.numberaddition.NumberAdditionUI

เครื่องมือประมวลผลเหตุการณ์

บทช่วยสอนนี้เน้นที่การตอบสนองต่อเหตุการณ์การคลิกปุ่มง่ายๆ มีเหตุการณ์มากมายที่แอปพลิเคชันสามารถตอบสนองได้ ใน IDE คุณสามารถดูรายการเหตุการณ์ที่มีอยู่ซึ่งสามารถประมวลผลโดยองค์ประกอบ GUI ได้ดังต่อไปนี้:

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

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

กลับไปที่ไฟล์ NumberAdditionUI.java ในเอดิเตอร์ คลิกแท็บ "แหล่งที่มา" เพื่อดูซอร์สโค้ด GUI
เลื่อนลงเพื่อดูวิธีการใช้งาน jButton1ActionPerformed() , jButton2ActionPerformed() และ jButton3ActionPerformed() วิธีการเหล่านี้เรียกว่าตัวจัดการเหตุการณ์
ตอนนี้ไปที่เมธอด initComponents() หากวิธีนี้หายไป ให้ค้นหาบรรทัด Generated Code แล้วคลิกเครื่องหมาย + ถัดจากบรรทัดนั้นเพื่อแสดงเมธอด initComponents() ที่ซ่อนอยู่
สังเกตบล็อกสีน้ำเงินที่ล้อมรอบเมธอด initComponents() รหัสนี้ถูกสร้างขึ้นโดยอัตโนมัติโดย IDE และผู้ใช้ไม่สามารถแก้ไขได้
ตอนนี้ดูที่วิธีการ initComponents() เอง เหนือสิ่งอื่นใด มันมีโค้ดที่เริ่มต้นองค์ประกอบ GUI และวางไว้บนแบบฟอร์ม รหัสนี้ถูกสร้างขึ้นและอัปเดตโดยอัตโนมัติเมื่อคุณวางและเปลี่ยนแปลงองค์ประกอบในโหมดการออกแบบ
ในเมธอด initComponents() ให้ค้นหาตัวอย่างต่อไปนี้: jButton3.setText("Exit"); jButton3.addActionListener(ใหม่ java.awt.event.ActionListener() ( โมฆะสาธารณะ actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));
ณ จุดนี้ ออบเจ็กต์ Listener เหตุการณ์ "ActionListener" จะถูกเพิ่มให้กับองค์ประกอบ GUI ในกรณีนี้คือ jButton3 อินเทอร์เฟซ "ActionListener" มีเมธอด "actionPerformed" บนอ็อบเจ็กต์ "ActionEvent" ซึ่งใช้งานได้โดยการเรียกตัวจัดการเหตุการณ์ jButton3ActionPerformed ปุ่มนี้ตอบสนองต่อเหตุการณ์การดำเนินการแล้ว แต่ละครั้งที่คลิกปุ่ม "ActionEvent" จะถูกสร้างขึ้นและส่งผ่านไปยังเมธอด "actionPerformed" ของอินเทอร์เฟซตัวฟังเหตุการณ์ ซึ่งจะรันโค้ดที่นักพัฒนาระบุไว้สำหรับเหตุการณ์นั้นในตัวจัดการเหตุการณ์
การ์ดการเรียนรู้แอปพลิเคชัน Java GUI