रॉक, पेपर, कैंची दो लोगों द्वारा खेला जाने वाला एक हाथ का खेल है। दोनों लोग "चट्टान, कागज, कैंची" कहेंगे और फिर एक साथ तीन वस्तुओं में से एक (चट्टान, कागज, या कैंची) एक फैला हुआ हाथ बनाते हैं। विजेता का निर्धारण हाथ की बनावट से होता है। कैंची कागज को पीटती है, कागज चट्टान को पीटता है और चट्टान कैंची को पीटती है। यदि दोनों खिलाड़ी एक ही हैंड फॉर्मेशन खेलते हैं, तो इसे टाई माना जाता है। हम रॉक, पेपर, कैंची का अनुकरण करने के लिए जावा में एक सरल गेम लिखेंगे जहां एक खिलाड़ी उपयोगकर्ता है और दूसरा खिलाड़ी कंप्यूटर है।
कदम
चरण 1. मुख्य वर्ग बनाएं और इसे कॉल करें
रॉक कागज कैंची
.
यह वह वर्ग होगा जहां हम खेल लिखेंगे। आप इसे कुछ और नाम देना चुन सकते हैं जैसे
खेल
या
मुख्य
. कंस्ट्रक्टर और मुख्य विधि के लिए विधि घोषणाओं में लिखें।
सार्वजनिक वर्ग रॉकपेपर कैंची {सार्वजनिक रॉकपेपर कैंची () { } सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग तर्क) { } }
चरण 2. हाथ के इशारों (चट्टान, कागज, या कैंची) के लिए एक गणना बनाएं।
हम रॉक, पेपर, या कैंची का प्रतिनिधित्व करने के लिए स्ट्रिंग्स का उपयोग कर सकते हैं, लेकिन एक एन्यूमरेशन हमें अपने स्थिरांक को पूर्वनिर्धारित करने की अनुमति देता है, जिसका अर्थ है कि एन्यूमरेशन का उपयोग करना एक बेहतर डिज़ाइन है। हम अपने एनम प्रकार को कॉल करेंगे
कदम
मूल्यों के साथ
चट्टान
कागज़
तथा
कैंची
निजी एनम मूव {रॉक, पेपर, कैंची}
चरण 3. दो निजी कक्षाएं बनाएं
उपयोगकर्ता
तथा
संगणक
.
ये कक्षाएं खेल में हमारे खिलाड़ियों का प्रतिनिधित्व करेंगी। आप इन कक्षाओं को सार्वजनिक करना चुन सकते हैं। NS
उपयोगकर्ता
वर्ग वह वर्ग होगा जो उपयोगकर्ता को रॉक, पेपर, या कैंची के लिए संकेत देता है, इसलिए हमें एक लिखना होगा
गेटमूव ()
तरीका। NS
संगणक
कक्षा को भी a. की आवश्यकता होगी
गेटमूव ()
विधि ताकि कंप्यूटर भी एक चाल चल सके। हम इन विधियों में प्लेसहोल्डर रखेंगे और बाद में उन्हें लागू करेंगे। NS
उपयोगकर्ता
क्लास को एक कंस्ट्रक्टर की आवश्यकता होगी जो सेट करता है
चित्रान्वीक्षक
उपयोगकर्ता इनपुट में लेने के लिए आपत्ति। हम डाल देंगे
चित्रान्वीक्षक
उपयोगकर्ता के लिए एक निजी क्षेत्र के रूप में और फिर इसे कंस्ट्रक्टर में आरंभ करें। चूंकि हम का उपयोग कर रहे हैं
चित्रान्वीक्षक
वर्ग, हमें अपने कोड के शीर्ष पर इसके लिए एक आयात विवरण लिखना होगा। NS
संगणक
क्लास को कंस्ट्रक्टर की आवश्यकता नहीं है, इसलिए हमें एक लिखने की आवश्यकता नहीं है; जब हम पहल करते हैं
संगणक
ऑब्जेक्ट, हम सिर्फ डिफॉल्ट कंस्ट्रक्टर को कॉल करेंगे। यहाँ क्या है हमारा
रॉक कागज कैंची
वर्ग अब जैसा दिखता है:
आयात java.util. Scanner; पब्लिक क्लास रॉकपेपर कैंची {निजी एनम मूव {रॉक, पेपर, कैंची} प्राइवेट क्लास यूजर {निजी स्कैनर इनपुट स्कैनर; सार्वजनिक उपयोगकर्ता () {इनपुट स्कैनर = नया स्कैनर (System.in); } सार्वजनिक ले जाएँ getMove () {// TODO: इस विधि को लागू करें वापसी शून्य; } } प्राइवेट क्लास कंप्यूटर { पब्लिक मूव गेटमोव () {// TODO: इस मेथड को लागू करें रिटर्न अशक्त; } } सार्वजनिक रॉकपेपर कैंची () { } सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग args) { } }
चरण 4. लिखें
गेटमूव ()
के लिए विधि
संगणक
कक्षा।
यह विधि एक यादृच्छिक लौटाएगी
कदम
. हम की एक सरणी प्राप्त कर सकते हैं
कदम
कॉल करके गणना
मान ()
तरीका:
मूव.वैल्यूज ()
. यादृच्छिक चुनने के लिए
कदम
इस मान सरणी में गणना, हमें एक यादृच्छिक अनुक्रमणिका उत्पन्न करने की आवश्यकता है जो 0 और हमारे मान सरणी की लंबाई के बीच एक पूर्णांक है। ऐसा करने के लिए, हम उपयोग कर सकते हैं
नेक्स्टइंट ()
की विधि
यादृच्छिक रूप से
जिस वर्ग से हमें आयात करने की आवश्यकता है
java.util
. यादृच्छिक सूचकांक प्राप्त करने के बाद, हम वापस कर सकते हैं
कदम
हमारे मान सरणी से उस अनुक्रमणिका का।
पब्लिक मूव गेटमोव () {मूव मूव्स = मूव। वैल्यू (); यादृच्छिक यादृच्छिक = नया यादृच्छिक (); int अनुक्रमणिका = random.nextInt (चाल लंबाई); वापसी चाल [सूचकांक]; }
चरण 5. लिखें
गेटमूव ()
के लिए विधि
उपयोगकर्ता
कक्षा।
यह विधि वापस आ जाएगी a
कदम
उपयोगकर्ता के पास इनपुट के अनुरूप है। हम उपयोगकर्ता से "रॉक", "पेपर" या "कैंची" लिखने की अपेक्षा करेंगे। सबसे पहले, हमें उपयोगकर्ता को इनपुट के लिए संकेत देना होगा:
System.out.print ("रॉक, पेपर, या कैंची?")
. फिर का उपयोग करें
अगली पंक्ति ()
की विधि
चित्रान्वीक्षक
उपयोगकर्ता इनपुट को स्ट्रिंग के रूप में प्राप्त करने के लिए ऑब्जेक्ट। हमें अब यह जांचने की आवश्यकता है कि क्या उपयोगकर्ता ने एक वैध चाल प्रस्तुत की है, लेकिन यदि उपयोगकर्ता ने किसी शब्द की गलत वर्तनी की है तो हम उदार हो सकते हैं। इसलिए हम केवल यह जांच करेंगे कि उपयोगकर्ता इनपुट का पहला अक्षर या तो "आर" (रॉक के लिए), "पी" (कागज के लिए), या "एस" (कैंची के लिए) है, और हम मामले की परवाह नहीं करेंगे क्योंकि हम सबसे पहले का उपयोग करेंगे
टू अपरकेस ()
की विधि
डोरी
उपयोगकर्ता इनपुट स्ट्रिंग को सभी अपरकेस बनाने के लिए कक्षा। यदि उपयोगकर्ता ने दूरस्थ रूप से सही इनपुट दर्ज नहीं किया है, तो हम उपयोगकर्ता को फिर से संकेत देंगे। फिर, उपयोगकर्ता ने जो डाला है उसके आधार पर, हम इसी चाल को वापस कर देंगे।
पब्लिक मूव गेटमोव () {// यूजर को प्रॉम्प्ट करें System.out.print ("रॉक, पेपर, या कैंची?"); // उपयोगकर्ता इनपुट प्राप्त करें स्ट्रिंग उपयोगकर्ता इनपुट = inputScanner.nextLine (); userInput = userInput.toUpperCase (); चार फर्स्टलेटर = userInput.charAt (0); अगर (फर्स्टलेटर == 'आर' || फर्स्टलेटर == 'पी' || फर्स्टलेटर == 'एस') {// यूजर ने एक वैध इनपुट स्विच (फर्स्टलेटर) दर्ज किया है {केस 'आर': रिटर्न मूव। रॉक; केस 'पी': वापसी मूव.पेपर; केस 'एस': वापसी मूव। कैंची; } } // उपयोगकर्ता ने एक मान्य इनपुट दर्ज नहीं किया है। फिर से संकेत करें। वापसी getMove (); }
चरण 6. एक लिखें
फिर से चालू करें()
के लिए विधि
उपयोगकर्ता
कक्षा।
उपयोगकर्ता को बार-बार गेम खेलने में सक्षम होना चाहिए। यह निर्धारित करने के लिए कि उपयोगकर्ता फिर से खेलना चाहता है या नहीं, हमें लिखना होगा a
फिर से चालू करें()
विधि जो एक बूलियन लौटाती है जो खेल को बताती है कि उपयोगकर्ता ने फिर से खेलने के लिए निर्धारित किया है या नहीं। इस विधि में, हम उपयोग कर रहे हैं
चित्रान्वीक्षक
कि हमने पहले उपयोगकर्ता से "हां" या "नहीं" प्राप्त करने के लिए कंस्ट्रक्टर में पहल की थी। उपयोगकर्ता फिर से खेलना चाहता है या नहीं यह निर्धारित करने के लिए हम केवल यह जांच करेंगे कि पहला अक्षर 'Y' है या नहीं। किसी अन्य इनपुट का मतलब यह होगा कि उपयोगकर्ता फिर से खेलना नहीं चाहता है।
सार्वजनिक बूलियन playAgain () { System.out.print ("क्या आप फिर से खेलना चाहते हैं?"); स्ट्रिंग उपयोगकर्ता इनपुट = inputScanner.nextLine (); userInput = userInput.toUpperCase (); वापसी userInput.charAt(0) == 'Y'; }
चरण 7. कनेक्ट करें
उपयोगकर्ता
तथा
संगणक
कक्षाओं में एक साथ
रॉक कागज कैंची
कक्षा।
अब जब हमने लिखना समाप्त कर दिया है
उपयोगकर्ता
तथा
संगणक
कक्षाएं, हम अपने वास्तविक खेल पर काम करने पर ध्यान केंद्रित कर सकते हैं। के लिए निजी फ़ील्ड बनाएं
उपयोगकर्ता
तथा
संगणक
में कक्षाएं
रॉक कागज कैंची
कक्षा। तक पहुँचने के लिए हमें इन क्षेत्रों तक पहुँचने की आवश्यकता होगी
गेटमूव ()
तरीके जब हम खेल खेल रहे होते हैं। कंस्ट्रक्टर में के लिए
रॉक कागज कैंची
वर्ग, इन क्षेत्रों को आरंभ करें। हमें स्कोर पर भी नज़र रखनी होगी
उपयोगकर्ता स्कोर
तथा
कंप्यूटर स्कोर
फ़ील्ड, जिसे हमें कंस्ट्रक्टर में 0 के रूप में आरंभ करने की आवश्यकता है। हमें खेलों की संख्या पर भी नज़र रखने की ज़रूरत है, जो कि 0 के रूप में शुरू किया गया क्षेत्र भी होगा।
निजी उपयोगकर्ता उपयोगकर्ता; निजी कंप्यूटर कंप्यूटर; निजी इंट यूजरस्कोर; निजी इंट कंप्यूटरस्कोर; निजी इंट नंबरऑफगेम्स; सार्वजनिक रॉकपेपर कैंची () {उपयोगकर्ता = नया उपयोगकर्ता (); कंप्यूटर = नया कंप्यूटर (); उपयोगकर्ता स्कोर = 0; कंप्यूटरस्कोर = 0; नंबरऑफगेम्स = 0; }
चरण 8. बढ़ाएँ
कदम
enum एक विधि शामिल करने के लिए जो हमें बताती है कि प्रत्येक मामले में कौन सी चाल जीतती है।
हमें a लिखना है
तुलना करें ()
यदि चालें समान हैं तो 0 लौटाती है, 1 यदि वर्तमान चाल दूसरी चाल को हरा देती है, और -1 यदि वर्तमान चाल दूसरी चाल से हार जाती है। यह खेल में विजेता का निर्धारण करने के लिए उपयोगी होगा। इस पद्धति को लागू करने के लिए, यदि चालें समान हैं तो हम पहले 0 लौटाएंगे और इसलिए हमारे पास एक टाई है। फिर 1 या -1 लौटने के लिए एक स्विच स्टेटमेंट लिखें।
निजी एनम मूव {रॉक, पेपर, कैंची; /** * इस चाल की तुलना एक टाई, जीत, या * हार का निर्धारण करने के लिए किसी अन्य चाल से की जाती है। * * @param otherMove * तुलना करने के लिए * @return 1 यदि यह चाल दूसरी चाल को हरा देती है, -1 यदि यह चाल * अन्य चाल से हार जाती है, 0 यदि ये चालें टाई हो जाती हैं */ public int तुलना करें (अन्य स्थानांतरित करें) {/ / टाई अगर (यह == अन्यमूव) वापसी 0; स्विच (यह) {केस रॉक: रिटर्न (अन्यमूव == कैंची? 1: -1); केस पेपर: रिटर्न (अन्यमूव == रॉक? 1: -1); केस कैंची: वापसी (अन्यमूव == पेपर? 1: -1); } // यहां कभी नहीं पहुंचना चाहिए वापसी 0; } }
चरण 9. एक बनाएँ
खेल शुरू()
में विधि
रॉक कागज कैंची
कक्षा।
यह तरीका खेल का खेल होगा। एक सिंपल लगाकर शुरुआत करें
System.out.println
विधि में।
सार्वजनिक शून्य startGame () { System.out.println ("रॉक, पेपर, कैंची!"); }
चरण 10. उपयोगकर्ता और कंप्यूटर से चालें प्राप्त करें।
में
खेल शुरू()
विधि, का उपयोग करें
गेटमूव ()
से तरीके
उपयोगकर्ता
कक्षा और
संगणक
उपयोगकर्ता और कंप्यूटर की चाल प्राप्त करने के लिए कक्षा।
ले जाएँ userMove = user.getMove (); कंप्यूटर ले जाएँ = कंप्यूटर। getMove (); System.out.println ("\ n आपने खेला" + userMove + "।"); System.out.println ("कंप्यूटर चलाया गया" + कंप्यूटरमूव + ".\ n");
चरण 11. दो चालों की तुलना करें और निर्धारित करें कि उपयोगकर्ता जीता या कंप्यूटर जीता।
उपयोग
तुलना करें ()
से विधि
कदम
enum यह निर्धारित करने के लिए कि उपयोगकर्ता जीता या नहीं। यदि उपयोगकर्ता जीता है, तो उपयोगकर्ता स्कोर को 1 से बढ़ाएँ। यदि उपयोगकर्ता हार गया है, तो कंप्यूटर स्कोर को 1 से बढ़ाएँ। यदि कोई टाई था, तो किसी भी स्कोर में वृद्धि न करें। फिर एक द्वारा खेले जाने वाले खेलों की संख्या में वृद्धि करें।
int तुलनामूव्स = userMove.compareMoves (कंप्यूटरमूव); स्विच (तुलना करें) {केस 0: // टाई System.out.println ("टाई!"); टूटना; केस 1: // उपयोगकर्ता जीतता है System.out.println (userMove + "बीट्स" + कंप्यूटरमूव + "। आप जीत गए!"); यूजरस्कोर++; टूटना; केस -1: // कंप्यूटर सिस्टम जीतता है। कंप्यूटरस्कोर++; टूटना; } नंबरऑफगेम++;
चरण 12. पूछें कि क्या उपयोगकर्ता फिर से खेलना चाहता है।
यदि उपयोगकर्ता फिर से खेलना चाहता है, तो कॉल करें
खेल शुरू()
फिर। नहीं तो कॉल करें
प्रिंटगेमस्टैट्स ()
जो खेल के आंकड़ों का प्रिंट आउट लेगा। इस विधि को हम अगले चरण में लिखेंगे।
अगर (user.playAgain ()) { System.out.println (); खेल शुरू(); } और {प्रिंटगेमस्टैट्स (); }
चरण 13. लिखें
प्रिंटगेमस्टैट्स ()
तरीका।
यह विधि खेल के आंकड़े प्रदर्शित करेगी: जीत की संख्या, हार की संख्या, संबंधों की संख्या, खेले गए खेलों की संख्या और उपयोगकर्ता द्वारा जीते गए खेलों का प्रतिशत। जीते गए खेलों के प्रतिशत की गणना (# जीत + (# संबंध/2))/(# खेले गए खेल) द्वारा की जाती है। यह विधि उपयोग करती है
System.out.printf
स्वरूपित पाठ का प्रिंट आउट लेने के लिए।
निजी शून्य प्रिंटगेमस्टैट्स () {इंट जीत = उपयोगकर्तास्कोर; इंट लॉस = कंप्यूटरस्कोर; int ties = numberOfGames - userScore - computerScore; डबल प्रतिशतवोन = (जीतता है + ((डबल) संबंध) / 2) / नंबरऑफगेम्स; // लाइन सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (68); System.out.println ("+"); // प्रिंट शीर्षक System.out.printf("| %6s | %6s | %6s | %12s | %14s |\n", "WINS", "LOSSES", "TIES", "Games PLAYED", "PERCENTAGE जीत लिया"); // लाइन सिस्टम.आउट.प्रिंट ("|"); प्रिंटडैश (10); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (10); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (10); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (16); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश(18); System.out.println ("|"); // प्रिंट मान System.out.printf ("|% 6d |% 6d |% 6d |% 12d |% 13.2f%% | / n", जीत, हार, संबंध, नंबरऑफगेम, प्रतिशत जीता * 100); // लाइन सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (68); System.out.println ("+"); }
चरण 14. खेल को मुख्य कक्षा में प्रारंभ करें।
मुख्य वर्ग में, का एक उदाहरण प्रारंभ करें
रॉक कागज कैंची
क्लास करें और कॉल करें
खेल शुरू()
तरीका।
सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग args) {रॉकपेपर कैंची खेल = नया रॉकपेपर कैंची (); गेम.स्टार्टगेम (); }
चरण 15. अपने खेल का परीक्षण करें।
अब जब हम रॉक, पेपर, कैंची गेम लिखने के सभी प्रयासों से गुजर चुके हैं, तो यह सब कुछ संकलित करने और परीक्षण करने का समय है!
नमूना कार्यक्रम
आयात java.util. Random; आयात java.util. Scanner; पब्लिक क्लास रॉकपेपर कैंची {निजी उपयोगकर्ता उपयोगकर्ता; निजी कंप्यूटर कंप्यूटर; निजी इंट यूजरस्कोर; निजी इंट कंप्यूटरस्कोर; निजी इंट नंबरऑफगेम्स; निजी एनम मूव {रॉक, पेपर, कैंची; /** * इस चाल की तुलना एक टाई, जीत, या * हार का निर्धारण करने के लिए किसी अन्य चाल से की जाती है। * * @param otherMove * की तुलना करने के लिए मूव करें * @return 1 अगर यह मूव दूसरे मूव को मात देता है, -1 अगर यह मूव * दूसरे मूव से हार जाता है, 0 अगर ये मूव्स टाई हो जाते हैं */ पब्लिक इंट कम्पेयरमूव्स (मूव अदरमूव) {/ / टाई अगर (यह == अन्यमूव) वापसी 0; स्विच (यह) {केस रॉक: रिटर्न (अन्यमूव == कैंची? 1: -1); केस पेपर: रिटर्न (अन्यमूव == रॉक? 1: -1); केस कैंची: वापसी (अन्यमूव == पेपर? 1: -1); } // यहां कभी नहीं पहुंचना चाहिए वापसी 0; } } निजी वर्ग उपयोगकर्ता { निजी स्कैनर इनपुट स्कैनर; सार्वजनिक उपयोगकर्ता () {इनपुट स्कैनर = नया स्कैनर (System.in); } पब्लिक मूव getMove() {// यूजर को प्रॉम्प्ट करें System.out.print ("रॉक, पेपर, या कैंची?"); // उपयोगकर्ता इनपुट प्राप्त करें स्ट्रिंग उपयोगकर्ता इनपुट = inputScanner.nextLine (); userInput = userInput.toUpperCase (); चार फर्स्टलेटर = userInput.charAt (0); अगर (फर्स्टलेटर == 'आर' || फर्स्टलेटर == 'पी' || फर्स्टलेटर == 'एस') {// यूजर ने एक वैध इनपुट स्विच (फर्स्टलेटर) दर्ज किया है {केस 'आर': रिटर्न मूव। रॉक; केस 'पी': वापसी मूव.पेपर; केस 'एस': वापसी मूव। कैंची; } } // उपयोगकर्ता ने एक मान्य इनपुट दर्ज नहीं किया है। फिर से संकेत करें। वापसी getMove (); } सार्वजनिक बूलियन playAgain() { System.out.print ("क्या आप फिर से खेलना चाहते हैं?"); स्ट्रिंग उपयोगकर्ता इनपुट = inputScanner.nextLine (); userInput = userInput.toUpperCase (); वापसी userInput.charAt(0) == 'Y'; } } प्राइवेट क्लास कंप्यूटर { पब्लिक मूव गेटमूव () {मूव मूव्स = मूव।वैल्यू (); यादृच्छिक यादृच्छिक = नया यादृच्छिक (); int अनुक्रमणिका = random.nextInt (चाल लंबाई); वापसी चाल [सूचकांक]; } } सार्वजनिक रॉकपेपर कैंची () { उपयोगकर्ता = नया उपयोगकर्ता (); कंप्यूटर = नया कंप्यूटर (); उपयोगकर्ता स्कोर = 0; कंप्यूटरस्कोर = 0; नंबरऑफगेम्स = 0; } public void startGame() { System.out.println ("रॉक, पेपर, कैंची!"); // चालें ले जाएँ userMove = user.getMove (); कंप्यूटर ले जाएँ = कंप्यूटर। getMove (); System.out.println ("\ n आपने खेला" + userMove + "।"); System.out.println ("कंप्यूटर चलाया गया" + कंप्यूटरमूव + ".\ n"); // चालों की तुलना करें और विजेता का निर्धारण करें स्विच (तुलना करें) {केस 0: // टाई System.out.println ("टाई!"); टूटना; केस 1: // उपयोगकर्ता जीतता है System.out.println (userMove + "बीट्स" + कंप्यूटरमूव + "। आप जीत गए!"); यूजरस्कोर++; टूटना; केस -1: // कंप्यूटर सिस्टम जीतता है। कंप्यूटरस्कोर++; टूटना; } नंबरऑफगेम++; // उपयोगकर्ता को फिर से खेलने के लिए कहें अगर (user.playAgain ()) {System.out.println (); खेल शुरू(); } और {प्रिंटगेमस्टैट्स (); } } /** * खेल के आँकड़ों को प्रिंट करता है। * जीत के प्रतिशत में 1/2 जीत के रूप में संबंधों की गणना करता है। */निजी शून्य प्रिंटगेमस्टैट्स () {इंट जीत = यूजरस्कोर; इंट लॉस = कंप्यूटरस्कोर; int ties = numberOfGames - userScore - computerScore; डबल प्रतिशतवोन = (जीतता है + ((डबल) संबंध) / 2) / नंबरऑफगेम्स; // लाइन सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (68); System.out.println ("+"); // प्रिंट शीर्षक System.out.printf("| %6s | %6s | %6s | %12s | %14s |\n", "WINS", "LOSSES", "TIES", "Games PLAYED", "PERCENTAGE जीत लिया"); // लाइन सिस्टम.आउट.प्रिंट ("|"); प्रिंटडैश (10); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (10); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (10); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (16); सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश(18); System.out.println ("|"); // प्रिंट मान System.out.printf ("|% 6d |% 6d |% 6d |% 12d |% 13.2f%% | / n", जीत, हार, संबंध, नंबरऑफगेम, प्रतिशत जीता * 100); // लाइन सिस्टम.आउट.प्रिंट ("+"); प्रिंटडैश (68); System.out.println ("+"); } निजी शून्य प्रिंटडैश (इंट नंबरऑफडैश) { के लिए (int i = 0; i <numberOfDashes; i++) {System.out.print("-"); } } सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग args) {रॉकपेपर कैंची गेम = नया रॉकपेपर कैंची (); गेम.स्टार्टगेम (); } }
