जावा में स्टोन, पेपर और कैंची गेम कैसे बनाएं

पत्थर, कागज और कैंची एक हाथ खेल है जो दो लोगों द्वारा खेला जाता है दो लोगों को एक ही समय में "पत्थर, कागज और कैंची" कहना चाहिए और फिर इन तीन वस्तुओं में से एक को एक हाथ से फैलाया जाना चाहिए। विजेता को हर एक के चुना के आधार पर निर्धारित किया जाता है। कैंची कागज से जीती, जो पत्थर से जीत जाती है, जो कैंची से जीतती है। यदि दोनों खिलाड़ी एक ही चीज़ चुनते हैं, तो परिणाम एक टाई होगा। यहां हम जावा में एक साधारण प्रोग्राम लिखेंगे जो इस गेम को सिम्युलेटेड करता है, ताकि उपयोगकर्ता एक खिलाड़ी हो और कंप्यूटर दूसरा हो।

सामग्री

चरणों
नमूना कार्यक्रम

चरणों

1
मुख्य वर्ग बनाएं और इसे कॉल करें PedraPapelTesoura. यह वह क्लास होगा जहां आप गेम को एन्कोड करेंगे। आप इसे एक और नाम दे सकते हैं, जैसे खेल या मुख्य. मुख्य विधि और बिल्डरों को घोषित करें
सार्वजनिक कक्षा PedraPapelTesoura {सार्वजनिक PedraPapelTesoura () {} सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग [] args) {}}
2
हाथ इशारों (पत्थर, कागज, या कैंची) के लिए एक गणन बनाएं हम इसके लिए स्ट्रिंग्स का उपयोग कर सकते हैं, लेकिन गणना करना हमें हमारे स्थिरांक को पूर्वनिर्धारित करने की अनुमति देता है, जिसका अर्थ है कि यह एक बेहतर तरीका है हम अपने फोन करेंगे चाल, मूल्यों के साथ स्टोन, पेपर, और कतरनी.
निजी एंमा ले जाएँ {स्टोन, पेपर, स्किस्सर}
3
दो निजी वर्ग बनाएँ उपयोगकर्ता और कंप्यूटर. ये कक्षाएं खेल में हमारे खिलाड़ियों का प्रतिनिधित्व करेंगे। आप इन सार्वजनिक कक्षाओं को छोड़ना भी चुन सकते हैं। कक्षा उपयोगकर्ता वह व्यक्ति होगा जो उपयोगकर्ता को पत्थर, काग़ज़ और कैंची के बीच चयन करने के लिए कहता है, फिर एक विधि बनाने के लिए आवश्यक होगा getMove (). कक्षा कंप्यूटर आपको एक विधि की भी आवश्यकता होगी getMove () ताकि वह अपनी पसंद भी कर सकें। हम इन तरीकों की जांच करेंगे और बाद में उन्हें लागू करेंगे। कक्षा उपयोगकर्ता आपको एक कन्स्ट्रक्टर की आवश्यकता होगी जो ऑब्जेक्ट को सेट करे स्कैनर उपयोगकर्ता इनपुट प्राप्त करने के लिए हम इसे छोड़ देंगे स्कैनर उपयोगकर्ता के लिए एक निजी क्षेत्र के रूप में और उसके बाद कन्स्ट्रक्टर में इसे प्रारंभ करें हम कक्षा का उपयोग कैसे कर रहे हैं स्कैनर, आपको इसे कोड की शुरुआत में आयात करना होगा कक्षा कंप्यूटर एक निर्माता की आवश्यकता नहीं है, इसलिए हमें एक लिखने की आवश्यकता नहीं होगी। हम एक वस्तु को प्रारंभ कर सकते हैं कंप्यूटर कॉलिंग डिफॉल्ट कन्स्ट्रक्टर के माध्यम से फिलहाल, हमारी कक्षा PedraPapelTesoura इस तरह दिखता है:
जावा आयात करते हैं सार्वजनिक-निजी वर्ग PedraPapelTesoura {{enum ले जाएँ रॉक, कागज, कैंची, निजी वर्ग} {उपयोगकर्ता निजी सार्वजनिक inputScanner स्कैनर उपयोगकर्ता () {inputScanner = नया स्कैनर (System.in) -} सार्वजनिक getMove ले जाएँ () {: इस methodreturn अशक्त लागू सार्वजनिक getMove ले जाएँ () {// TODO -} सार्वजनिक PedraPapelTesoura} () {} public static void (String [] args) {निजी वर्ग कंप्यूटर} -: {// TODO लागू इस methodreturn अशक्त} }}
4
विधि लिखें getMove () कक्षा के लिए कंप्यूटर. यह विधि एक यादृच्छिक पसंद लौटाएगी। हमारे पास एक सदिश हो सकता है जिसमें चाल विधि का उपयोग करना मान (): स्थानांतरित करें। गुण (). एक यादृच्छिक विकल्प चुनने के लिए, हमें 0 और मान के हमारे सदिश के आकार के बीच एक यादृच्छिक संख्या उत्पन्न करने की आवश्यकता है। ऐसा करने के लिए, इस का उपयोग करें nextInt () कक्षा का बिना सोचे समझे, जो भी से आयात करने की आवश्यकता होगी java.util. यादृच्छिक पूर्णांक उत्पन्न करने के बाद, हम वापस आ सकते हैं चाल जो उस नंबर से संबंधित स्थिति में है।
सार्वजनिक हटो मिलमॉ () [ले जाएँ] विकल्प = मूव। मूल () - यादृच्छिक यादृच्छिक = नया रैंडम () - इंट इंडेक्स = यादृच्छिक। एक्सएक्सआईटी (चालें। लम्बाई)
5
विधि लिखें getMove () कक्षा के लिए उपयोगकर्ता. यह विधि उस विकल्प को वापस देगा जो उपयोगकर्ता ने चुना। उपयोगकर्ता "पत्थर", "कागज" या "कैंची" चुनने के लिए हम इंतजार करेंगे पहले हमें उपयोगकर्ता के लिए एक एंट्री मांगना है: System.out.print ("स्टोन, पेपर, या कैंची?"). तब का उपयोग करें अगले लाइन () ऑब्जेक्ट का स्कैनर एक स्ट्रिंग के रूप में उपयोगकर्ता इनपुट प्राप्त करने के लिए अब हमें यह सत्यापित करने की आवश्यकता है कि उपयोगकर्ता ने एक वैध विकल्प बना दिया है, लेकिन अगर वह गलत शब्द की वर्तनी लिखे तो हम लचीला हो सकते हैं इसलिए हम उपयोगकर्ता इनपुट के केवल पहले दो अक्षर, पत्थर के लिए "पीई", कागजों के लिए "पीए" या कैंची के लिए "ते" की जांच कर सकते हैं। यह कोई फर्क नहीं पड़ता कि शब्द ऊपरी या लोअर केस है क्योंकि हम इस पद्धति का उपयोग पहले करेंगे toUpperCase () कक्षा का तार अपरकेस में प्रविष्टि के सभी अक्षरों को परिवर्तित करने के लिए यदि उपयोगकर्ता ने सही विकल्प दर्ज नहीं किया है, तो उन्हें फिर से संकेत दिया जाएगा फिर, इनपुट के आधार पर, हम चुने हुए हाथ आंदोलन को वापस देंगे।
सार्वजनिक getMove ले जाएँ () {// पूछो usuárioSystem.out.print ( "रॉक, कागज, कैंची?") - // रही entradaString userInput inputScanner.nextLine = () - userInput userInput.toUpperCase = () - चार = primeiraLetter userInput.charAt (0) = -char segundaLetra userInput.charAt (1) -यदि (primeiraLetter == `पी` (सेकंडफ़ाइल == `ई` || दूसरी फ़ाइल == `ए`) || firstLetter == `T`) {// उपयोगकर्ता ने एक मान्य इनपुट वॉच दर्ज किया है {case `P`: if (secondLetter == `E`) {return Move.PEDRA-} else {Return Move.PAPEL-} केस `टी`: वापसी हिल। TOOURSE -}} // उपयोगकर्ता ने कोई मान्य प्रविष्टि दर्ज नहीं की, पुनः प्रयास करें। Get get () -}
6
एक विधि लिखें खेलने के लिएनवीन () कक्षा के लिए उपयोगकर्ता. उपयोगकर्ता को जितनी बार वह चाहें उतना बार गेम खेलने के लिए चुनने में सक्षम होना चाहिए। यह निर्धारित करने के लिए कि उपयोगकर्ता फिर से खेलना चाहता है, आपको एक विधि लिखना होगा प्लेगेन () जो एक बूलियन चर देता है जो यह बताएगा कि उपयोगकर्ता फिर से खेलना चाहता है या नहीं इस पद्धति में, हम इस का उपयोग करेंगे स्कैनर जो पहले से ही "हाँ" या "नहीं" उपयोगकर्ता प्राप्त करने के लिए कंस्ट्रक्टर से पहले आरंभ किया जा चुका है हम केवल यह जांचेंगे कि क्या पहला अक्षर `एस` है, यह तय करने के लिए कि उपयोगकर्ता फिर से खेलना चाहता है या नहीं, कोई भी अन्य एंट्री का मतलब होगा कि उपयोगकर्ता अब खेलना चाहता है।
सार्वजनिक बूलियन PlayAgain () {System.out.print ( "आप फिर से खेलना चाहते हैं?") -String userInput inputScanner.nextLine = () - userInput userInput.toUpperCase = () - वापसी userInput.charAt (0) == `एस` -}
7
वर्गों में शामिल हों उपयोगकर्ता और कंप्यूटर कक्षा में PedraPapelTesoura. अब जब हम इन दो वर्गों को लिखना समाप्त कर चुके हैं, तो हम इस खेल पर ही ध्यान केंद्रित कर सकते हैं। कक्षा के लिए निजी फ़ील्ड बनाएं उपयोगकर्ता और के लिए कंप्यूटर कक्षा में PedraPapelTesoura. तरीकों का उपयोग करने के लिए हमें इन क्षेत्रों तक पहुंचने की आवश्यकता होगी getMove () जब हम खेल रहे हैं कॉस्टर में PedraPapelTesoura, इन क्षेत्रों को प्रारंभ करें आपको खेतों में स्कोर को बचाने की आवश्यकता होगी userScore और computerScore, जिसे कन्स्ट्रक्टर में 0 में प्रारंभ करने की आवश्यकता है। हमें भी खेले जाने वाले खेलों की संख्या को बचाने की आवश्यकता होगी, जो कि 0 पर भी शुरू हो जाएगी।
निजी उपयोगकर्ता उपयोगकर्ता के निजी कंप्यूटर कंप्यूटर-निजी पूर्णांक userScore-निजी पूर्णांक computerScore-निजी पूर्णांक numberOfGames-सार्वजनिक PedraPapelTesoura () {उपयोगकर्ता = नया उपयोगकर्ता () - कंप्यूटर = नए कंप्यूटर () - userScore = 0-computerScore = 0-numberOfGames = 0 -}
8
Enum विस्तार करें चाल एक ऐसी विधि को शामिल करने के लिए जो हमें बताता है कि प्रत्येक मामले में किस जीत का चलन है हमें एक विधि लिखना होगा तुलनामौव () जो 0 लौटाएगा यदि वरीयताएं एक समान हैं, 1 यदि वर्तमान विकल्प विजेता और -1 अगर यह हारने वाला है यह गेम के विजेता को निर्धारित करने में बहुत मददगार होगा। इस पद्धति को कार्यान्वित करने के लिए, हमें सबसे पहले 0 लौटने की ज़रूरत है अगर विकल्प समान हैं, जिसके परिणामस्वरूप एक टाई होती है। तो हमें 1 या -1 को वापस करने के लिए स्विच करना चाहिए
निजी enum {ले जाएँ स्टोन, कागज, कैंची -। / *** अन्य के साथ इस विकल्प की तुलना करें निर्धारित करने के लिए कौन जीता या एक ड्रॉ *** * @param otherMove पसंद तुलना करने के लिए * © वापसी 1 अगर एक और जीत की वर्तमान चुनाव , और -1 अगर यह खो देता है 0 एक टाई के मामले में लौटा दी जाएगी ** / सार्वजनिक पूर्णांक compareMoves (otherMove ले जाएँ) {// Tieif (इस == otherMove) वापसी 0-स्विच (इस) {मामले पत्थर: वापसी (otherMove == कैंची 1:।? - 1) - पेपर पेपर: रिटर्न (अन्य मूव == स्टोन? 1: -1) -केस एसआईआईएसएसओआर: रिटर्न (अन्य मूव == पेपर? 1: -1) -} रिटर्न 0-}}
9
एक विधि बनाएं startGame () कक्षा में PedraPapelTesoura. यह खेल शुरू कर देगा और खेलेंगे। एक सरल जोड़कर प्रारंभ करें System.out.println.
सार्वजनिक शून्य प्रारंभ करना () {System.out.println ("स्टोन, पेपर, स्किसर!") -}
10
उपयोगकर्ता और कंप्यूटर की गति प्राप्त करें विधि में startGame (), विधियों का उपयोग करें getMove () कक्षा का उपयोगकर्ता और कक्षा कंप्यूटर उपयोगकर्ता और कंप्यूटर की गतिविधियों को प्राप्त करने के लिए
चालें = userMove user.getMove () - Move computerMove = computer.getMove () - println ( " Nyou चयनित" userMove + + "।") - println ( "कंप्यूटर को चुन लिया है" + computerMove + "। n") -
11
कौन जीता निर्धारित करने के लिए दो चाल की तुलना करें विधि का उपयोग करें तुलनामौव () एनाम से चाल यह निर्धारित करने के लिए कि उपयोगकर्ता जीता है या नहीं यदि वह समाप्त हो गया है, तो 1 के अपने स्कोर में वृद्धि, अन्यथा कंप्यूटर स्कोर में वृद्धि टाई के मामले में, किसी भी स्कोर में वृद्धि नहीं करें इसके बाद 1 से खेल की संख्या में वृद्धि
पूर्णांक = compareMoves userMove.compareMoves (computerMove) स्विच (compareMoves) {मामले 0: // TieSystem.out.println ( "ड्रा") - तोड़-केस 1: // winsSystem.out.println उपयोगकर्ता (userMove + `जीत । के "+ + computerMove" तुम जीत लिया है! ") - userScore ++ - तोड़ने मामले -1: // winsSystem.out.println कंप्यूटर (computerMove +" धड़कता है "+ + userMove" तुम खो दिया है ") - computerScore ++ - तोड़ .. -} numberOfGames ++ -
12
खिलाड़ी से पूछें कि वह फिर से खेलना चाहता है। यदि हां, तो विधि कॉल करें startGame () फिर से। अन्यथा, विधि कॉल करें printGameStats () तो वह खेल के आंकड़े दिखा सकता है। हम इस पद्धति को अगले चरण में दिखाएंगे।
अगर (user.playAgain ()) {System.out.println () - startGame () -} अन्य {printGameStats () -}
13
विधि लिखें printGameStats (). यह विधि खेल के आंकड़े दिखाएगा: जीत की संख्या, नुकसान, ड्रॉ, प्रदर्शन किए जाने वाले खेलों की संख्या और उपयोगकर्ता की जीत का प्रतिशत। यह प्रतिशत इस रूप में गणना की जाती है: (जीत की संख्या + (संबंधों की संख्या / 2)) / (खेल खेला जाने वाला खेल) इस विधि का उपयोग करता है System.out.printf स्क्रीन पर पाठ मुद्रित करने के लिए
निजी शून्य प्रिंट गेमस्टैट्स ()% 12 एस

मुख्य कक्षा में खेल शुरू करें इसमें, कक्षा का एक उदाहरण प्रारंभ करें PedraPapelTesoura और विधि को बुलाओ startGame ().

सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] एल्ग्स) {पेड्रापेपलटॉसौरा गेम = नया पेड्रापेपलटेसौरा () - गेम.स्टार्टगेम () -}

15
अपने खेल का परीक्षण करें अब जब आपने पत्थर, कागज और कैंची की एक खेल बनाने के लिए हर संभव प्रयास किया है, तो सब कुछ संकलन और परीक्षण करने का समय है!

नमूना कार्यक्रम

java.util.Random आयात जावा आयात करते हैं-सार्वजनिक वर्ग उपयोगकर्ता {निजी PedraPapelTesoura उपयोगकर्ता के निजी कंप्यूटर कंप्यूटर-निजी पूर्णांक userScore-निजी पूर्णांक computerScore-निजी पूर्णांक numberOfGames-निजी enum {स्टोन, पेपर, ले जाएँ कैंची - / * ** अन्य के साथ इस विकल्प की तुलना करें निर्धारित करने के लिए कौन जीता या एक ड्रॉ। *** * तुलना करने के लिए @param otherMove विकल्प * © वापसी 1 यदि मौजूदा चुनाव एक और जीतने के लिए, और -1 अगर वह खो देता है। 0 एक टाई के मामले में लौटा दी जाएगी ** / सार्वजनिक पूर्णांक compareMoves (otherMove ले जाएँ) {// Empateif (इस == otherMove) वापसी 0-स्विच (इस) {मामले पत्थर: वापसी (otherMove == कैंची 1:।? - 1) -Case पेपर: वापसी (otherMove स्टोन == 1: -1) -Case कतरनी: वापसी (otherMove == 1 पेपर :? -1) -} वापसी 0 -}} निजी वर्ग उपयोगकर्ता {निजी सार्वजनिक स्कैनर inputScanner // user.system.out.print प्राप्त करें ("स्टोन, पेपर या कैंची?") - // उपयोगकर्ता इनपुट प्राप्त करें स्ट्रिंग उपयोगकर्ता इनपुट = inputScanner.nextLine () - = userInput userInput.toUpperCase () - = userInput.charAt firstLetter चार (0) -यदि (primeiraLetter == `पी` (सेकंडफ़ाइल == `ई` || दूसरी फ़ाइल == `ए`) || firstLetter == `t`) {// उपयोगकर्ता एक इनपुट válidaswitch (PrimeiraLetra) {मामले `पी` में प्रवेश किया: अगर (segundaLetra == `ई`) {Move.PEDRA- लौट} else {} मामले वापसी Move.PAPEL- `टी`: वापसी Move.TESOURA - सार्वजनिक बूलियन PlayAgain (System.out.print}) {( "आप फिर से खेलना चाहते हैं?") -String -}} // उपयोगकर्ता एक मान्य प्रविष्टि दर्ज नहीं किया, getMove () novamentereturn कोशिश userInput = inputScanner.nextLine () - = userInput userInput.toUpperCase () - userInput.charAt वापसी (0) == `एस` -}} निजी वर्ग कंप्यूटर {सार्वजनिक getMove ले जाएँ () {ले जाएं [] = चाल Move.values ( ) -Random यादृच्छिक = नई यादृच्छिक () - पूर्णांक सूचकांक = Random.nextInt (moves.length) -return चाल [सूचकांक] -}} सार्वजनिक PedraPapelTesoura () {उपयोगकर्ता = नया उपयोगकर्ता () - कंप्यूटर = नए कंप्यूटर () - userScore = 0 = 0-computerScore-numberOfGames = 0- startGame} सार्वजनिक शून्य () {println ( "रॉक, कागज, कैंची") - // जाओ movimentosMove userMove = user.getMove () - ले जाएँ = computerMove computer.getMove () - System.out.println (" n आपने खेला" + + यूज़रमव + "।") - System.out.pri ntln ( "। n" "कंप्यूटर खेला" + computerMove +) - // तुलना और निर्धारित करता है आंदोलनों vencedorint compareMoves = userMove.compareMoves (computerMove) स्विच (compareMoves) {मामले 0: // EmpateSystem.out.println ( "ड्रा!") - तोड़ने के मामले 1: // उपयोगकर्ता winsSystem.out.println (userMove + "धड़कता है" + computerMove + "। ! आप जीत ") - userScore ++ - तोड़ने मामले -1: // winsSystem.out.println कंप्यूटर (computerMove +" धड़कता है "+ userMove +" आप खो ") - computerScore ++ - ++ numberOfGames BREAK-} - // प्रश्न .. else {printGameStats () -} {- - startGame () println ()} अगर वे novamenteif खेलने के लिए (user.playAgain ()) इच्छा उपयोगकर्ता।} / *** खेल के आंकड़ों पर विचार करता है के रूप में ड्रॉ से पता चलता एक 1/2 * जीत का प्रतिशत निर्धारित करने के लिए जीतने के लिए। * / निजी शून्य printGameStats ()% 14s printDashes निजी शून्य (numberOfDashes पूर्णांक) {के लिए (int i = 0- मैं < numberOfDashes- i++) {System.out.print(";")-}}public static void main(String[] args) {PedraPapelTesoura game = new PedraPapelTesoura()-game.startGame()-}}

सामाजिक नेटवर्क पर साझा करें:

संबद्ध