जावा में GUI ग्रिड कैसे बनाएं (चित्रों के साथ)

2024 लेखक: Gilbert Ryder | [email protected]. अंतिम बार संशोधित: 2023-12-16 17:32

ग्रिड इस स्तर पर कुछ खास नहीं करता है, लेकिन थोड़े से शोध के साथ, आप एक साधारण 2D गेम जैसे टिक-टैक-टो, या बैटलशिप जैसे अधिक जटिल गेम बनाने के लिए एक्शन श्रोताओं और थोड़ा तर्क जोड़ सकते हैं।

नोट: यह लेख सभी उदाहरणों के लिए एक्लिप्स का उपयोग करता है, इसलिए आपके आईडीई के आधार पर चीजें भिन्न हो सकती हैं। यह बहुत कुछ वैसा ही होना चाहिए जैसा आपको JCreator में चाहिए, लेकिन यह GUI आधारित IDE जैसे NetBeans के लिए बेकार है, हालांकि मुख्य रूप से NetBeans की ड्रैग एंड ड्रॉप विधि के कारण।

कदम

चरण 1. जावा प्रोजेक्ट बनाएं।

यह अपेक्षाकृत सरल है। अपना आईडीई चालू करें और एक नया प्रोजेक्ट बनाएं। इसे आप जो चाहें कॉल करें। उदाहरण बटनग्रिड होगा।

यह नाम वास्तव में बिल्कुल भी मायने नहीं रखता क्योंकि यह केवल फ़ाइल नाम है जो इसे दिया जाएगा।

चरण 2. मुख्य विधि के साथ जावा क्लास बनाएं।

एक नया वर्ग बनाएं और जो आप चाहते हैं उसे नाम दें। उदाहरण बटनग्रिड होगा। एक ग्रहण उपयोगकर्ता के लिए आप सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग args) नामक बॉक्स को टिक करना चाहेंगे, इसलिए जब आप शुरू करते हैं तो आपको इसे टाइप नहीं करना पड़ेगा।

यह नाम पिछले वाले की तुलना में अधिक महत्वपूर्ण है क्योंकि इसे एक शब्द के रूप में होना होगा अन्यथा यह प्रयोग करने योग्य नहीं होगा।

चरण 3. पुस्तकालयों को आयात करें।

यह वह सारी जानकारी लाता है जिसकी आपको इस कोड में अपना कोड लिखने की आवश्यकता होगी। आपको javax.swing. JFrame, javax.swing. JButton, और java.awt. Gridlayout आयात करना होगा। इन्हें कक्षा की शुरुआत से पहले रखा जाता है, कहीं 1 से 3 के बीच की रेखाओं पर, वे वहां किस क्रम में हैं, इससे कोई फर्क नहीं पड़ता।

चरण 4. एक कंस्ट्रक्टर बनाएं।

कंस्ट्रक्टर बटनग्रिड क्लास का एक नया उदाहरण बनाता है जिससे कई अलग-अलग बटन ग्रिड सभी को अलग-अलग जानकारी मिलती है। सभी कंस्ट्रक्टरों को उनकी कक्षा के समान ही नामित करने की आवश्यकता है। इसके पहले कंस्ट्रक्टर्स को कुछ भी नहीं चाहिए, लेकिन संदर्भ में आसानी के लिए अक्सर 'सार्वजनिक' रखा जाता है। कंस्ट्रक्टर्स को अक्सर कक्षा में पहली विधि के रूप में रखा जाता है, इसलिए यह कक्षा के नाम के ठीक बाद जाता है, हालांकि इसे कक्षा के भीतर रखा जाना चाहिए। बटनग्रिड कंस्ट्रक्टर को पैरामीटर की आवश्यकता होती है, जिसे कंस्ट्रक्टर के नाम के बाद ब्रैकेट में रखा जाता है। इस उदाहरण में पैरामीटर पूर्णांक 'x' और 'y' हैं।

चरण 5. फ़्रेम बनाएं:

फ्रेम का नाम होना चाहिए। यह सुनिश्चित करने के लिए कि इसे बटनग्रिड कन्स्ट्रक्टर विधि के बाहर संदर्भित किया जा सकता है, आप इसे उस विधि के बाहर रखते हैं, लेकिन कक्षा के भीतर। कंस्ट्रक्टर के ठीक पहले क्लास के टॉप पर ज्यादातर वेरिएबल्स का नाम दिया जाता है। एक नया फ्रेम बनाने के लिए आप टाइप करें: JFrame फ्रेम = नया JFrame ();
कंस्ट्रक्टर विधि के अंदर हमें यह सुनिश्चित करने की आवश्यकता है कि सभी बटन ग्रिड लेआउट में रखे गए हैं। ऐसा करने के लिए हम टाइप करके फ्रेम का लेआउट सेट करते हैं: frame.setLayout(new GridLayout(x, y));
अनिवार्य रूप से अनिवार्य नहीं है, लेकिन जब आप ऊपरी दाएं कोने में 'x' बटन दबाते हैं तो फ्रेम को बंद करने के लिए हमें लाइन जोड़ने की आवश्यकता होती है: frame.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE);
फ्रेम को एक उचित आकार बनाने के लिए ताकि सब कुछ फिट हो जाए, हमें पैक कमांड चलाने की जरूरत है: फ्रेम.पैक ();
अंत में फ्रेम के लिए हमें इसे बनाने की जरूरत है ताकि यह दिखाई दे: फ्रेम.सेट विजिबल (सच);

जावा चरण 6 में एक GUI ग्रिड बनाएं

चरण 6. बटन ग्रिड बनाएं:
1. उपयोगकर्ता जिन बटनों के साथ इंटरैक्ट करता है, उन्हें बनाने की आवश्यकता होती है, लेकिन चूंकि हम नहीं जानते कि हमें कितने की आवश्यकता है, इसलिए उन्हें पहले नाम देना होगा। तो उस रेखा के ठीक नीचे जहां आप फ्रेम बनाते हैं बटन बनाएं: जेबटन ग्रिड; स्क्वायर ब्रैकेट के दो सेट यह कहने के लिए हैं कि ग्रिड में जेबटन को दो-आयामी प्रारूप में रखा जाता है, यदि स्क्वायर ब्रैकेट का केवल एक सेट होता है तो यह केवल जेबटन की एक पंक्ति होगी, जो अभी भी काम करती है, यह बस है यह संदर्भित करना आसान है कि कौन सा बटन द्वि-आयामी होने पर बनाया या इंटरैक्ट किया जा रहा है।
2. JButton का नाम दिया गया है, लेकिन हमें अभी भी यह कहना है कि कितने बटन हैं। आपको कंस्ट्रक्टर में कोड की एक पंक्ति जोड़ने की आवश्यकता है जो राशि निर्धारित करती है: ग्रिड = नया जेबटन [चौड़ाई] [लंबाई];
3. अब जब यह निर्धारित हो गया है कि निश्चित संख्या में बटन होंगे, प्रत्येक को बनाया जाना चाहिए। ऐसा करने का सबसे आसान तरीका लूप के लिए दो, x-अक्ष के लिए एक, y-अक्ष के लिए एक है। दो छोरों के अंदर हम एक नया बटन बनाते हैं, और संदर्भ में आसानी के लिए उदाहरण प्रत्येक बटन के अंदर टेक्स्ट डालता है ताकि हम जान सकें कि द्वि-आयामी सरणी में कौन सा बटन है। एक बटन बनाने के लिए, लूप के अंदर आपको ग्रिड [x] [y] = नया जेबटन ("("+ x +", "+ y +")") डालना होगा;
  
  जावा चरण 7 में GUI ग्रिड बनाएं
  
  चरण 7. फ्रेम में बटन जोड़ें।
  
  लूप के अंदर हमें एक साधारण कमांड के साथ फ्रेम पर बटन लगाने की जरूरत है: फ्रेम। एड (ग्रिड [x] [y]);
  
  जावा चरण 8 में GUI ग्रिड बनाएं
  
  चरण 8. बटनग्रिड इंस्टेंस बनाएं।
  
  आपके मुख्य वर्ग के प्रकार में: नया बटनग्रिड (3, 3); दो थ्री मेक एक 3 बटा 3 ग्रिड है, और वहां कोई भी दो सकारात्मक संख्याएं डाली जा सकती हैं।
  
  जावा चरण 9 में GUI ग्रिड बनाएं
  
  चरण 9. प्रोग्राम चलाएँ।
  
  ग्रहण में ऐसा करने के लिए Ctrl+F11 दबाएं
  
  विधि १ का १: चरण कोड
  
  मुख्य वर्ग:
```
पब्लिक क्लास बटनग्रिड {सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) {}}
```
  आयात:
```
आयात javax.swing. JFrame; आयात javax.swing. JButton; आयात java.awt. GridLayout; पब्लिक क्लास बटनग्रिड {…
```
  कंस्ट्रक्टर कोड:
```
पब्लिक क्लास बटनग्रिड {सार्वजनिक बटनग्रिड (इंट चौड़ाई, इंट लेंथ) {}} …
```
  फ़्रेम कोड:
```
पब्लिक क्लास बटनग्रिड {जेएफआरएएम फ्रेम = नया जेफ्रेम (); सार्वजनिक बटनग्रिड (इंट चौड़ाई, इंट लेंथ) {फ्रेम.सेटलाउट (नया ग्रिडलाउट (चौड़ाई, लंबाई)); फ्रेम.सेटडिफॉल्टक्लोजऑपरेशन (जेफ्रेम. EXIT_ON_CLOSE); फ्रेम.पैक (); फ्रेम.सेटविजिबल (सच); } }…
```
  बटन ग्रिड कोड:
```
|जेएफआरएएम फ्रेम = नया जेएफआरएएम (); // फ्रेम JButton ग्रिड बनाता है; // बटन के ग्रिड का नाम सार्वजनिक बटनग्रिड (इंट चौड़ाई, इंट लेंथ) {// 2 पैरामीटर फ्रेम के साथ कंस्ट्रक्टर। सेटलेआउट (नया ग्रिडलाउट (चौड़ाई, लंबाई)); // फ्रेम ग्रिड का लेआउट सेट करें = नया जेबटन [चौड़ाई] [लंबाई]; // ग्रिड के आकार को आवंटित करें (int y = 0; y <लंबाई; y ++) {के लिए (int x = 0; x <चौड़ाई; x ++) {ग्रिड [x] [y] = नया जेबटन ("(" + एक्स+", "+वाई+")"); फ्रेम.एड (ग्रिड [एक्स] [वाई]); // ग्रिड में बटन जोड़ता है}} फ्रेम.सेटडिफॉल्टक्लोजऑपरेशन (JFrame. EXIT_ON_CLOSE); फ्रेम.पैक (); फ्रेम.सेटविजिबल (सच); } …
```
  फ़्रेम में बटन जोड़ना:
```
for(int y=0; y<length; y++){ for(int x=0; x<width; x++){ grid[x][y]=new JButton("("+x+", "+y+")"); फ्रेम.एड (ग्रिड [एक्स] [वाई]); } }…
```
  एक बटन ग्रिड उदाहरण बनाना:
```
सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) {नया बटनग्रिड (3, 3); // 2 पैरामीटर के साथ नया बटनग्रिड बनाता है} …
```
  अंतिम कोड:
```
आयात javax.swing. JFrame; // आयात JFrame पुस्तकालय आयात javax.swing. JButton; // आयात जेबटन पुस्तकालय आयात java.awt. GridLayout; // आयात GridLayout पुस्तकालय सार्वजनिक वर्ग ButtonGrid {JFrame फ्रेम = नया JFrame (); // फ्रेम JButton ग्रिड बनाता है; // बटन के ग्रिड का नाम सार्वजनिक बटनग्रिड (इंट चौड़ाई, इंट लंबाई) {// कंस्ट्रक्टर फ्रेम। सेटलेआउट (नया ग्रिडलाउट (चौड़ाई, लंबाई)); // सेट लेआउट ग्रिड = नया जेबटन [चौड़ाई] [लंबाई]; // ग्रिड के आकार को आवंटित करें (int y = 0; y <लंबाई; y ++) {के लिए (int x = 0; x <चौड़ाई; x ++) {ग्रिड [x] [y] = नया जेबटन ("(" + एक्स+", "+वाई+")"); // नया बटन फ्रेम बनाता है। जोड़ें (ग्रिड [x] [y]); // ग्रिड में बटन जोड़ता है}} फ्रेम.सेटडिफॉल्टक्लोजऑपरेशन (JFrame. EXIT_ON_CLOSE); फ्रेम.पैक (); // फ्रेम फ्रेम के लिए उपयुक्त आकार सेट करता है। सेट विजिबल (सच); // फ्रेम को दृश्यमान बनाता है} सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) {नया बटनग्रिड (3, 3); // 2 पैरामीटर के साथ नया बटनग्रिड बनाता है}}
```
  आयात javax.swing. JFrame; // आयात JFrame पुस्तकालय आयात javax.swing. JButton; // आयात जेबटन पुस्तकालय आयात java.awt. GridLayout; // ग्रिडलाउट लाइब्रेरी आयात करता है
  
  पब्लिक क्लास बटनग्रिड {
  
  जेएफआरएएम फ्रेम = नया जेएफआरएएम (); // फ्रेम JButton ग्रिड बनाता है; // बटन के ग्रिड को नाम दें
  
  सार्वजनिक बटनग्रिड (इंट चौड़ाई, इंट लंबाई) {// कंस्ट्रक्टर फ्रेम। सेटलेआउट (नया ग्रिडलाउट (चौड़ाई, लंबाई)); // सेट लेआउट ग्रिड = नया जेबटन [चौड़ाई] [लंबाई]; // ग्रिड के आकार को आवंटित करें (int y = 0; y <लंबाई; y ++) {के लिए (int x = 0; x <चौड़ाई; x ++) {ग्रिड [x] [y] = नया जेबटन ("(" + एक्स+", "+वाई+")"); // नया बटन फ्रेम बनाता है। जोड़ें (ग्रिड [x] [y]); // ग्रिड में बटन जोड़ता है}} फ्रेम.सेटडिफॉल्टक्लोजऑपरेशन (JFrame. EXIT_ON_CLOSE); फ्रेम.पैक (); // फ्रेम फ्रेम के लिए उपयुक्त आकार सेट करता है। सेट विजिबल (सच); // फ्रेम को दृश्यमान बनाता है} सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) {नया बटनग्रिड (3, 3); // 2 पैरामीटर के साथ नया बटनग्रिड बनाता है}