Ռոքը, թուղթը, մկրատը ձեռքով խաղ է, որը խաղում են երկու հոգի: Երկուսն էլ կասեն «ժայռ, թուղթ, մկրատ», այնուհետև միաժամանակ երեք ձեռքերից մեկը (ժայռ, թուղթ կամ մկրատ) մեկնած ձեռքով կկազմեն մեկը: Հաղթողը որոշվում է ձեռքի կազմավորումներով: Մկրատը ծեծում է թուղթ, թուղթը `ռոք, իսկ ժայռը` մկրատ: Եթե երկու խաղացողներն էլ խաղում են նույն ձեռքի ձևավորմամբ, ապա դա համարվում է ոչ -ոքի: Մենք Java- ում կգրենք մի պարզ խաղ ՝ Rock, Paper, Scissors մոդելավորելու համար, որտեղ խաղացողներից մեկը օգտվող է, իսկ մյուս խաղացողը ՝ համակարգիչ:
Քայլեր
Քայլ 1. Ստեղծեք հիմնական դասարան և զանգահարեք այն
RockPaperScissors
.
Սա կլինի այն դասարանը, որտեղ մենք կգրենք խաղը: Դուք կարող եք ընտրել այն այլ անուն տալը, օրինակ
Խաղ
կամ
Հիմնական
. Մեթոդի հայտարարագրերում գրեք կոնստրուկտորի համար և հիմնական մեթոդը:
հանրային դաս RockPaperScissors {public RockPaperScissors () {} public static void main (String args) {}}
Քայլ 2. Ստեղծեք թվարկում ձեռքի շարժումների համար (ժայռ, թուղթ կամ մկրատ):
Մենք կարող ենք օգտագործել տողեր `քար, թուղթ կամ մկրատ ներկայացնելու համար, բայց թվարկումը թույլ է տալիս կանխորոշել մեր հաստատունները, ինչը նշանակում է, որ թվարկումը օգտագործելն ավելի լավ ձև է: Մենք կանվանենք մեր enum տիպը
Տեղափոխել
արժեքների հետ
ՌՈՔ
Թուղթ
և
Մկրատ
մասնավոր հաշվառում Տեղափոխել {ROCK, PAPER, SCISSORS}
Քայլ 3. Ստեղծեք երկու մասնավոր դասարան
Օգտվող
եւ
Համակարգիչ
.
Այս դասերը կներկայացնեն մեր խաղացողներին խաղի մեջ: Դուք կարող եք ընտրել, որ այս դասերը հրապարակվեն: The
Օգտվող
դասը կլինի այն դասը, որը օգտագործողին հուշում է ժայռ, թուղթ կամ մկրատ, ուստի մենք պետք է գրենք
getMove ()
մեթոդը: The
Համակարգիչ
դասը պետք է ունենա նաև ա
getMove ()
մեթոդ, որպեսզի համակարգիչը նույնպես կարողանա քայլ կատարել: Այս մեթոդների մեջ մենք կդնենք տեղապահներ և դրանք կիրականացնենք ավելի ուշ: The
Օգտվող
դասը կպահանջի կոնստրուկտոր, որը ստեղծում է
Սկաներ
օբյեկտ, որը պետք է ընդունի օգտվողի մուտքը: Մենք կդնենք
Սկաներ
որպես օգտագործողի մասնավոր դաշտ, այնուհետև այն նախաձեռնել կոնստրուկտորում: Քանի որ մենք օգտագործում ենք
Սկաներ
class, մենք պետք է դրա համար վերևում գրենք ներմուծման հայտարարություն: The
Համակարգիչ
դասը կոնստրուկտոր չի պահանջում, ուստի մեզ պետք չէ գրել: երբ մենք նախաձեռնում ենք
Համակարգիչ
օբյեկտ, մենք պարզապես կանչելու ենք կանխադրված կոնստրուկտոր: Ահա թե ինչ է մեր
RockPaperScissors
դասը այժմ նման է.
ներմուծել java.util. Scanner; հանրային դաս RockPaperScissors {private enum Move {ROCK, PAPER, SCISSORS} մասնավոր դաս User {private Scanner inputScanner; public User () {inputScanner = նոր սկաներ (System.in); } public Move getMove () {// TODO: Իրականացնել այս մեթոդը return null; }} մասնավոր դասի համակարգիչ {public Move getMove () {// TODO: Իրականացնել այս մեթոդը return null; }} public RockPaperScissors () {} public static void main (String args) {}}
Քայլ 4. Գրեք
getMove ()
մեթոդը ՝
Համակարգիչ
դասարան:
Այս մեթոդը կվերադառնա պատահական
Տեղափոխել
. Մենք կարող ենք ստանալ զանգված
Տեղափոխել
թվարկումները ՝ զանգահարելով
արժեքներ ()
մեթոդ:
Move.values ()
. Պատահական ընտրելու համար
Տեղափոխել
այս արժեքների զանգվածում հաշվելը, մենք պետք է գեներացնենք պատահական ինդեքս, որը ամբողջ թիվ է 0 -ի և մեր արժեքների զանգվածի միջև: Դա անելու համար մենք կարող ենք օգտագործել
nextInt ()
-ի մեթոդը
Պատահական
դաս, որից մենք պետք է ներմուծենք
java.util
. Պատահական ինդեքսը ստանալուց հետո կարող ենք վերադարձնել
Տեղափոխել
այդ ցուցանիշի մեր արժեքների զանգվածից:
հրապարակային Տեղափոխել getMove () {Տեղափոխել տեղափոխել = Տեղափոխել. արժեքներ (); Պատահական պատահական = նոր Պատահական (); int index = random.nextInt (moves.length); վերադարձի շարժումներ [ցուցիչ]; }
Քայլ 5. Գրեք
getMove ()
մեթոդը ՝
Օգտվող
դասարան:
Այս մեթոդը կվերադարձնի ա
Տեղափոխել
համապատասխանում է օգտագործողի մուտքին: Մենք ակնկալում ենք, որ օգտագործողը կգրի կամ «ռոք», «թուղթ», կամ «մկրատ»: Նախ, մենք պետք է օգտագործողին հուշենք մուտքագրման համար.
System.out.print («Rockայռ, թուղթ, թե՞ մկրատ»)
. Այնուհետեւ օգտագործեք
հաջորդ տող ()
-ի մեթոդը
Սկաներ
օբյեկտ ՝ օգտագործողի մուտքը որպես տող ստանալու համար: Այժմ մենք պետք է ստուգենք, արդյոք օգտվողը ներկայացրել է վավեր քայլ, բայց մենք կարող ենք մեղմ լինել, եթե օգտագործողը սխալ է գրել մի բառ: Այսպիսով, մենք միայն կստուգենք, արդյոք օգտվողի մուտքի առաջին տառը կա՞մ «R» (ռոքի համար), «P» (թղթի համար), կա՛մ «S» (մկրատի համար), և գործը մեզ չի մտահոգի, քանի որ մենք նախ կօգտագործենք
toUpperCase ()
-ի մեթոդը
Լարային
դաս ՝ օգտվողի մուտքագրման տողը մեծատառ դարձնելու համար: Եթե օգտվողը չի մուտքագրել հեռակա ճիշտ մուտքագրում, մենք նորից կհուշենք օգտվողին: Այնուհետեւ, կախված այն բանից, թե ինչ է դրել օգտվողը, մենք կվերադարձնենք համապատասխան քայլ:
public Move getMove () {// Տեղեկացրեք օգտվողին System.out.print («Rockայռ, թուղթ, թե՞ մկրատ»); // Ստացեք օգտվողի մուտքագրում String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); եթե (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// Օգտվողը մուտքագրել է մուտքի վավեր անջատիչ (firstLetter) {case 'R': return Move. ROCK; դեպք 'P'. վերադարձ Move. PAPER; գործ 'S': վերադարձ Տեղափոխել. SCISSORS; }} // Օգտագործողը վավեր մուտքագրում չի մուտքագրել: Կրկին հուշեք: վերադարձ getMove (); }
Քայլ 6. Գրեք ա
կրկին խաղալ()
մեթոդը ՝
Օգտվող
դասարան:
Օգտագործողը պետք է կարողանա խաղը անընդհատ խաղալ: Որոշելու համար, արդյոք օգտագործողը ցանկանում է նորից խաղալ, մենք պետք է գրենք a
կրկին խաղալ()
մեթոդ, որը վերադարձնում է բուլյան ՝ խաղին պատմելով ՝ օգտվողը որոշել է նորից խաղալ, թե ոչ: Այս մեթոդով մենք օգտագործում ենք
Սկաներ
որ մենք նախապես նախաձեռնել էինք կոնստրուկտորում օգտվողից ստանալ «Այո» կամ «Ոչ»: Մենք միայն կստուգենք, արդյոք առաջին տառը «Y» է ՝ որոշելու, թե արդյոք օգտվողը ցանկանում է նորից խաղալ: Otherանկացած այլ մուտք կնշանակի, որ օգտվողը չի ցանկանում նորից խաղալ:
public boolean playAgain () {System.out.print («Ուզու՞մ ես նորից խաղալ»); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); վերադարձնել userInput.charAt (0) == 'Y'; }
Քայլ 7. Միացրեք
Օգտվող
եւ
Համակարգիչ
դասերը միասին
RockPaperScissors
դասարան:
Հիմա, երբ մենք ավարտեցինք գրելը
Օգտվող
եւ
Համակարգիչ
դասեր, մենք կարող ենք կենտրոնանալ մեր իրական խաղի վրա աշխատելու վրա: Ստեղծեք մասնավոր դաշտեր
Օգտվող
եւ
Համակարգիչ
դասարաններում,
RockPaperScissors
դասարան: Մենք պետք է մուտք գործենք այս դաշտեր ՝ մուտք գործելու համար
getMove ()
մեթոդները, երբ մենք խաղում ենք խաղը: Համար կոնստրուկտորում
RockPaperScissors
դաս, նախաձեռնել այս դաշտերը: Մենք նաև պետք է հետևենք հաշվի մեջ հաշիվին
userScore
եւ
համակարգչային միավոր
դաշտեր, որոնք մենք պետք է սկսենք որպես 0 կոնստրուկտորում: Մենք պետք է հետևենք նաև խաղերի քանակին, որոնք նույնպես կլինեն 0 -ի նախաձեռնած դաշտ:
մասնավոր օգտագործող; մասնավոր համակարգչային համակարգիչ; մասնավոր int userScore; մասնավոր int computerScore; մասնավոր int numberOfGames; հանրային RockPaperScissors () {user = նոր օգտվող (); համակարգիչ = նոր Համակարգիչ (); userScore = 0; համակարգչային միավոր = 0; numberOfGames = 0; }
Քայլ 8. Երկարացրեք
Տեղափոխել
enum ներառել մի մեթոդ, որը մեզ ասում է, թե որ շարժումն է հաղթում յուրաքանչյուր դեպքում:
Մենք պետք է գրենք ա
համեմատելՇարժվում է ()
մեթոդը, որը վերադարձնում է 0 -ը, եթե շարժումները նույնն են, 1 -ը, եթե ընթացիկ շարժումը հաղթում է մյուսին, և -1, եթե ընթացիկ շարժումը պարտվում է մյուս քայլին: Սա օգտակար կլինի խաղի հաղթողին որոշելու համար: Այս մեթոդը կյանքի կոչելու համար մենք նախ կվերադարձնենք 0, եթե շարժումները նույնն են, և, հետևաբար, մենք ունենք ոչ -ոքի: Այնուհետև գրեք անջատիչ հայտարարություն 1 կամ -1 վերադարձնելու համար:
private enum Տեղափոխել {ROCK, PAPER, SCISSORS; /** * Այս քայլը համեմատում է ոչ -ոքի, հաղթանակ կամ * պարտություն որոշելու մեկ այլ քայլի հետ: * * @param otherMove * տեղափոխել ՝ համեմատելու * @վերադարձ 1 -ի հետ, եթե այս քայլը հաղթում է մյուս քայլին, -1, եթե այս քայլը պարտվում է * մյուս քայլին, 0, եթե այս շարժումները կապեն * / public int compareMoves (Տեղափոխել այլ շարժում) { / / Կապել, եթե (սա == otherMove) վերադարձնել 0; switch (this) {case ROCK: return (otherMove == SCISSORS 1: -1); պատյան Թուղթ. վերադարձ (այլՇարժել == ՌՈՔ? 1: -1); պատյան ՄԱՇԻՆՉԵՐ. վերադարձ (այլՇարժել == ԹԱՐԹ. 1: -1); } // Երբեք չպետք է հասնի այստեղ վերադարձ 0; }}
Քայլ 9. Ստեղծեք ա
սկսել խաղը()
մեթոդը մեջ
RockPaperScissors
դասարան:
Այս մեթոդը կլինի խաղի խաղը: Սկսեք ՝ պարզ բան դնելով
System.out.println
մեթոդի մեջ:
public void startGame () {System.out.println ("ROCK, PAPER, SCISSORS!"); }
Քայլ 10. Ստացեք շարժումներ օգտվողից և համակարգչից:
Մեջ
սկսել խաղը()
մեթոդ, օգտագործել
getMove ()
մեթոդներից ՝
Օգտվող
դասարանը և
Համակարգիչ
դաս `օգտվողին և համակարգչի քայլերը ստանալու համար:
Տեղափոխել userMove = user.getMove (); Տեղափոխել computerMove = computer.getMove (); System.out.println ("\ n Դուք խաղացել եք" + userMove + "."); System.out.println ("Համակարգիչը խաղացել է" + computerMove + ". / N");
Քայլ 11. Համեմատեք երկու քայլերը և որոշեք ՝ շահեց օգտվողը, թե՞ համակարգիչը:
Օգտագործեք ՝
համեմատելՇարժվում է ()
մեթոդից ՝
Տեղափոխել
enum ՝ որոշելու ՝ օգտվողը շահե՞լ է, թե՞ ոչ: Եթե օգտվողը հաղթեց, ավելացրեք օգտվողի միավորը 1. Եթե օգտվողը պարտվեց, բարձրացրեք համակարգչի միավորը 1. Եթե ոչ -ոքի է եղել, մի ավելացրեք հաշիվներից որևէ մեկը: Այնուհետեւ ավելացրեք խաղերի քանակը մեկով:
int compareMoves = userMove.compareMoves (համակարգչային շարժում); անջատիչ (համեմատել շարժումները) {case 0: // Tie System.out.println («Կապել»); ընդմիջում; դեպք 1: // Օգտվողը շահում է System.out.println (userMove + "beats" + computerMove + ". Դուք հաղթել եք"); userScore ++; ընդմիջում; դեպք -1: // Համակարգիչը հաղթում է System.out.println (computerMove + "beats" + userMove + ". Դուք պարտվել եք:"); computerScore ++; ընդմիջում; } numberOfGames ++;
Քայլ 12. Հարցրեք, արդյոք օգտվողը ցանկանում է նորից խաղալ:
Եթե օգտվողը ցանկանում է կրկին խաղալ, զանգահարեք
սկսել խաղը()
կրկին. Հակառակ դեպքում զանգահարեք
printGameStats ()
որը տպելու է խաղի վիճակագրությունը: Այս մեթոդը մենք կգրենք հաջորդ քայլին:
if (user.playAgain ()) {System.out.println (); սկսել խաղը(); } else {printGameStats (); }
Քայլ 13. Գրեք
printGameStats ()
մեթոդը:
Այս մեթոդը կցուցադրի խաղի վիճակագրությունը. Հաղթանակների թիվը, կորուստների թիվը, ոչ -ոքիների թիվը, խաղերի քանակը և օգտագործողի շահած խաղերի տոկոսը: Հաղթած խաղերի տոկոսը հաշվարկվում է (# հաղթանակ + (# խաղ/2))/(# խաղացած խաղերով): Այս մեթոդը օգտագործում է
System.out.printf
տպել ձևաչափված տեքստը:
private void printGameStats () {int հաղթում է = userScore; int կորուստներ = computerScore; int կապեր = numberOfGames - userScore - computerScore; կրկնակի տոկոս Հաղթեց = (հաղթում է + ((կրկնակի) ոչ -ոքի) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // Տիտղոսաթերթեր System.out.printf ("| %6s | %6s | %6s | %12s | %14s | / n", "WINS", "LOSSES", "TIES", "GAMES PLAYED", "PERCENTAGE ՀԱONԹԵ "»); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // Տպման արժեքներ System.out.printf ("| %6d | %6d | %6d | %12d | %13.2f %% | / n", հաղթանակներ, կորուստներ, կապեր, numberOfGames, տոկոսային Հաղթանակ * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); }
Քայլ 14. Խաղը սկսեք հիմնական դասից:
Հիմնական դասում նախաստորագրեք օրինակ
RockPaperScissors
դասարան և զանգահարեք
սկսել խաղը()
մեթոդը:
public static void main (String args) {RockPaperScissors խաղ = նոր RockPaperScissors (); game.startGame (); }
Քայլ 15. Փորձարկեք ձեր խաղը:
Այժմ, երբ մենք անցել ենք Rock, Paper, Scissors խաղը գրելու բոլոր ջանքերը, ժամանակն է կազմել և փորձարկել ամեն ինչ:
Նմուշի ծրագիր
ներմուծել java.util. Random; ներմուծել java.util. Scanner; հանրային դաս RockPaperScissors {մասնավոր օգտագործող; մասնավոր համակարգչային համակարգիչ; մասնավոր int userScore; մասնավոր int computerScore; մասնավոր int numberOfGames; private enum Տեղափոխել {ROCK, PAPER, SCISSORS; /** * Այս քայլը համեմատում է մեկ այլ քայլի հետ `ոչ -ոքի, հաղթանակ կամ * պարտություն որոշելու հետ: * * @param otherMove * տեղափոխել ՝ համեմատելու * @վերադարձ 1 -ի հետ, եթե այս քայլը հաղթում է մյուս քայլին, -1, եթե այս քայլը պարտվում է * մյուս քայլին, 0, եթե այս շարժումները կապեն * / public int compareMoves (Տեղափոխել այլ շարժում) { / / Կապել, եթե (սա == otherMove) վերադարձնի 0; switch (this) {case ROCK: return (otherMove == SCISSORS 1: -1); պատյան Թուղթ. վերադարձ (այլՇարժել == ՌՈՔ? 1: -1); պատյան ՄԱՇԻՆՉԵՐ. վերադարձ (այլՇարժել == ԹԱՐԹ. 1: -1); } // Երբեք չպետք է հասնի այստեղ վերադարձ 0; }} մասնավոր դաս User {private Scanner inputScanner; public User () {inputScanner = նոր սկան (System.in); } public Move getMove () {// Հարցրեք օգտվողին System.out.print («Rockայռ, թուղթ, թե՞ մկրատ»); // Ստացեք օգտվողի մուտքագրում String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); եթե (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// Օգտվողը մուտքագրել է մուտքի վավեր անջատիչ (firstLetter) {case 'R': return Move. ROCK; գործ 'P'. վերադարձ Move. PAPER; գործ 'S': վերադարձ Տեղափոխել. SCISSORS; }} // Օգտվողը վավեր մուտքագրում չի մուտքագրել: Կրկին հուշեք: վերադարձ getMove (); } public boolean playAgain () {System.out.print («Ուզու՞մ ես նորից խաղալ»); String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); վերադարձնել userInput.charAt (0) == 'Y'; }} մասնավոր դաս համակարգիչ {public Move getMove () {Տեղափոխել move = Move.values (); Պատահական պատահական = նոր Պատահական (); int index = random.nextInt (moves.length); վերադարձի շարժումներ [ցուցիչ]; }} public RockPaperScissors () {user = new User (); համակարգիչ = նոր Համակարգիչ (); userScore = 0; համակարգչային միավոր = 0; numberOfGames = 0; } public void startGame () {System.out.println ("ROCK, PAPER, SCISSORS!"); // Տեղափոխել Տեղափոխել userMove = user.getMove (); Տեղափոխել computerMove = computer.getMove (); System.out.println ("\ n Դուք խաղացել եք" + userMove + "."); System.out.println ("Համակարգիչը խաղացել է" + computerMove + ". / N"); // Համեմատեք քայլերը և որոշեք հաղթողին int compareMoves = userMove.compareMoves (computerMove); switch (compareMoves) {case 0: // Tie System.out.println («Կապել»); ընդմիջում; դեպք 1: // Օգտվողը շահում է System.out.println (userMove + "beats" + computerMove + ". Դուք հաղթել եք"); userScore ++; ընդմիջում; դեպք -1: // Համակարգիչը հաղթում է System.out.println (computerMove + "beats" + userMove + ". Դուք պարտվել եք:"); computerScore ++; ընդմիջում; } numberOfGames ++; // Խնդրեք օգտվողին կրկին խաղալ, եթե (user.playAgain ()) {System.out.println (); սկսել խաղը(); } else {printGameStats (); }} /*** Տպում է խաղի վիճակագրությունը: Հաշվարկում է ոչ -ոքի արդյունքները 1/2 -ի հաշվով հաղթանակի * տոկոսով: */ private void printGameStats () {int հաղթում է = userScore; int կորուստներ = computerScore; int կապեր = numberOfGames - userScore - computerScore; կրկնակի տոկոս Հաղթեց = (հաղթում է + ((կրկնակի) ոչ -ոքի) / 2) / numberOfGames; // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); // Տիտղոսաթերթեր System.out.printf ("| %6s | %6s | %6s | %12s | %14s | / n", "WINS", "LOSSES", "TIES", "GAMES PLAYED", "PERCENTAGE ՀԱONԹԵ "»); // Line System.out.print ("|"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (10); System.out.print ("+"); printDashes (16); System.out.print ("+"); printDashes (18); System.out.println ("|"); // Տպման արժեքներ System.out.printf ("| %6d | %6d | %6d | %12d | %13.2f %% | / n", հաղթանակներ, կորուստներ, կապեր, numberOfGames, տոկոսային Հաղթանակ * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); } private void printDashes (int numberOfDashes) {for (int i = 0; i <numberOfDashes; i ++) {System.out.print ("-"); }} public static void main (String args) {RockPaperScissors խաղ = նոր RockPaperScissors (); game.startGame (); }}
