Cum se creează jocul Sasso, Carta, Foarfece în Java

Piatra, hârtia, foarfecele este un joc care se joacă între doi oameni care folosesc mâinile. Ambii jucători vor trebui să pronunță formula „Rock, hârtie, foarfece“, apoi alegeți simultan și se vor face cu o singură mână unul dintre cele trei elemente disponibile în joc (de fapt rock, hârtie sau foarfece). Câștigătorul va fi determinat pe baza combinației de obiecte rezultate. Foarfecele au bătut hârtia, piatra bate foarfecele, iar cardul bate piatra. Dacă ambii jucători au ales același element, jocul este considerat legat. Acest tutorial arată cum să scrieți un program în Java care replică dinamica acestui joc. Un jucător va fi reprezentat de utilizator, în timp ce acesta va fi controlat de calculator.

conținut

Paşi
Program exemplu

paşi

Creați clasa principală a programului și denumiți-o RockPaperScissors. Aceasta va fi clasa principală în care vom introduce codul întregului program. Puteți alege un nume diferit pentru această clasă, cum ar fi joc sau principal. Scrieți declarația metodelor referitoare la producător și principala metodă "principală".

public class RockPaperScissors {public RockPaperScissors () {} public static void principal (String [] args) {}}

Creați o enumerare care descrie cele trei obiecte din joc (piatră, hârtie, foarfece). Am putea folosi trei șiruri simple pentru a reprezenta piatra, hârtie și foarfece, dar enumerare ne permite să definim constantă utilizarea anterioară enumerarea noastră este, prin urmare, o alegere mai bună în proiectarea nivelului de cod. Numărătoarea apelurilor noastre mutare va avea următoarele valori: ROCK (Rock) HÂRTIE (hârtie) e fOARFECE (foarfece).

private enum Mutare {ROCK, HAPPY, SCISSORS}

Creați două clase "private", un apel utilizator și celălalt calculator. Aceste clase reprezintă jucătorii care se confruntă reciproc în jocul real. Dacă doriți, puteți alege să declarați aceste clase drept "publice". Clasa utilizator este cel care va cere utilizatorului să aleagă obiectul mutarei sale între piatră, hârtie sau foarfece, atunci va trebui să scriem metoda getMove () pentru a executa mișcarea noastră. De asemenea, clasa calculator va trebui să aibă o metodă getMove (), deoarece chiar și computerul va trebui să-și facă mutarea. Codul acestor două metode va fi implementat mai târziu, pentru moment ne vom limita la declarația lor. Clasa utilizator cere unui constructor să creeze obiectul scaner folosit pentru citirea datelor introduse de utilizator. Câmpul scaner acesta va fi declarat privat pentru clasa "Utilizator" și va fi inițializat în cadrul constructorului de clasă. Deoarece folosim clasa Java implicită, scaner, va trebui să le importăm în programul nostru introducând linia "import" asociată la începutul codului nostru. Clasa calculator aceasta nu necesită utilizarea unui constructor, deci nu va trebui să scriem cod pentru acest element. Când inițializăm obiectul calculator, Java va folosi constructorul implicit. Mai jos este codul clasei noastre RockPaperScissors scrise până acum:

RockPaperScissors clasa import java.util.Scanner public-privat enum {{Move ROCK, HÂRTIE, SCISSORS} class privat User {inputScanner Scanner User public-privat () {inputScanner = new Scanner (System.in) -} getMove Mutare publică () {// cod metoda de a pune în aplicare în null seguitoreturn -}} clasa de computer privat {getMove Move publice () {// cod metoda de a pune în aplicare în null seguitoreturn -}} RockPaperScissors publice () {} public static void main (String [ ] args) {}}

Creați metoda getMove () referitoare la clasă calculator. Această metodă va returna valoarea unei mișcări aleatorii alese în cadrul enumerării mutare. Putem crea o "matrice" de enumerări mutare reamintind metoda valori () în acest fel: Move.values (). Pentru a alege o enumerare mutare întâmplare printre cei prezenți în „matrice“ nostru avem nevoie pentru a genera un indice aleatoriu, care va fi reprezentat de un număr întreg între 0 și numărul tuturor elementelor conținute în nostru „matrice“. Pentru aceasta putem folosi metoda nextInt () din clasă întâmplător pe care le putem importa din pachet java.util. După obținerea indexului aleatoriu, putem returna valoarea enumerării mutare corespunzătoare, prezente în "matricea" noastră.

public Mișcare getMove () [Mutare [] mutare = Mutare.value () - Random aleator = nou Random () - int index = random.nextInt (mutare moves.length)

Scrieți codul metodei getMove () pentru clasă utilizator. Această metodă trebuie să returneze valoarea corespunzătoare mișcării introduse de utilizator. Ne așteptăm ca utilizatorul să scrie una dintre următoarele valori: "piatră", "hârtie" sau "foarfece". Primul pas este să cereți utilizatorului să introducă o valoare. Pentru a face acest lucru folosim următorul cod: System.out.print ("Piatră, hârtie sau foarfece?"). Apoi vom folosi metoda nextLine () articol scaner pentru a citi intrarea utilizatorului și a-l păstra într-un obiect "șir". Acum trebuie să verificăm dacă utilizatorul a introdus o mutare validă, rămânând indulgent în cazul unei greșeli. Deci, vom verifica doar că prima literă tastat corespunde cu „S“ (în cazul „piatră“), „C“ (în cazul „hârtie“) sau „F“ (în cazul „foarfece“). Nu ne îngrijorează faptul că utilizatorul a scris o scrisoare de capital sau o scrisoare mică, deoarece vom folosi metoda toUpperCase () din clasă șir pentru a valorifica toate caracterele introduse de utilizator. Dacă utilizatorul nu a introdus o mișcare validă, îl vom întreba din nou să-și facă mutarea. Apoi, pe baza intrării de la utilizator, vom returna valoarea corespunzătoare mișcării alese.

public Mută getMove () {// Solicităm intrare de la utilizatorul System.out.print ("Piatră, hârtie sau foarfece? ") - // citit de intrare a intrat dall`utenteString UserInput = inputScanner.nextLine () - UserInput = userInput.toUpperCase () - char firstLetter = userInput.charAt (0) -dacă (firstLetter == `S` || firstLetter = = `C` || firstLetter == `F`) {// Validiamo intrare a intrat dall`utenteswitch (firstLetter) {caz `S`: întoarce Move.ROCK caz `C`: întoarce Move.PAPER-case F „: Move.SCISSORS întoarcere -}} // utilizatorul a introdus o mutare validă nu, ne cerem din nou pentru a introduce un mossareturn getMove () -}

Scrieți metoda playAgain () pentru clasă utilizator. Utilizatorul trebuie să poată juca pe termen nelimitat. Pentru a determina dacă utilizatorul vrea să redea, trebuie să scriem metoda playAgain () care va trebui să returneze o valoare booleană care poate dezvălui dacă utilizatorul dorește să continue jocul sau nu. În cadrul acestei metode, vom folosi obiectul scaner pe care am creat-o anterior în constructorul de clasă "Utilizator" pentru a obține un "Da" sau "Nu" de la utilizator. De asemenea, în acest caz, vom verifica numai dacă prima literă introdusă este "Y", pentru a determina dacă utilizatorul dorește să redea. Orice alt caracter, număr sau simbol introdus va corespunde dorinței jucătorului de a opri jocul.

public boolean playAgain () {System.out.print ("Doriți să jucați din nou? ") -String userInput = inputScanner.nextLine () - userInput = userInput.toUpperCase () - retur userInput.charAt (0) == `Y`-}

Legați clasele împreună utilizator și calculator în cadrul clasei RockPaperScissors. Acum că am terminat să scriem codul de clasă utilizator și calculator, ne putem concentra pe codul real al jocului. În interiorul clasei RockPaperScissors, declară două obiecte private, una de genul utilizator și unul de un fel calculator. În timpul executării jocului, va trebui să accesăm cele două metode getMove () din clasele respective "User" și "Computer". Aceste două obiecte vor fi inițializate în cadrul constructorului de clasă RockPaperScissors. De asemenea, va trebui să urmărim scorul. Pentru a face acest lucru, vom folosi câmpurile userScore și computerScore că vom inițializa la 0 în cadrul constructorului de clasă. În cele din urmă, vom avea nevoie în continuare de a urmări numărul de jocuri al căror domeniu numberOfGames acesta va fi inițializat la 0 în cadrul constructorului de clasă.

RockPaperScissors utilizator privat privat-user-computer privat int Computer-userScore privat int int computerScore-privat numberOfGames-publice () {utilizator = utilizator nou () - calculator = nou computer () - userScore = 0-computerScore = 0-numberOfGames = 0 -}

Extindeți enumerarea mutare astfel încât să includă metoda care ne spune ce mișcare câștigătoare a fiecărui joc este. Pentru a face acest lucru trebuie să scriem metoda compareMoves () care returnează valoarea 0 în cazul în care mișcările sunt egale, 1 dacă mutarea curentă depășește valoarea precedentă și -1 dacă mutarea anterioară depășește valoarea curentă. Această schemă este utilă pentru a determina cine va fi câștigătorul jocului. În implementarea acestei metode, mai întâi vom reveni la valoarea 0 dacă mișcările sunt egale și, prin urmare, suntem într-o situație de paritate. Apoi vom scrie blocul de cod referitor la returnarea valorilor 1 și -1.

enum privat {Mutare ROCK, hârtie, foarfeci - / *** Comparăm muta curent cu mutarea anterioară pentru a determina dacă acesta este un egal, în cazul în care * câștigă sau pierde @parametro otherMove ** * * @return pentru a efectua comparația 1 în cazul în care această mutare ia cealaltă, -1 dacă această mișcare este bătut pe celălalt * 0 dacă este o remiză * / compareMoves publice int (muta otherMove) {// a paritàif Case (acest == otherMove) return 0-comutator (aceasta) {caz ROCK: return (otherMove == SCISSORS 1: -1) -case PAPER: întoarcere (otherMove == ROCK 1: -1) -case SCISSORS: return (otherMove == PAPER 1: -1 ) -} // Programul nu trebuie să ajungă niciodată la acest puntoreturn 0-}}

În interiorul clasei RockPaperScissors, creați metoda startgame (). Aceasta este metoda care ne permite să ne jucăm jocul. Porniți codul metodei pur și simplu introducând următoarea linie System.out.println.

public void startGame () {System.out.println ("Piatră, hârtie, foarfece!") -}

Citiți mișcările efectuate de utilizator și de calculator. În cadrul metodei startgame (), reamintește metoda getMove () din clase utilizator și calculator. În acest fel veți face o mutare la utilizator și una la computer.

Deplasați userMove = user.getMove () - Deplasați computerMove = computer.getMove () - System.out.println (" nAți jucat " + userMove + ".") -System.out.println ("Computerul a jucat " + computerMove + ". N") -

Comparați cele două mutări alese pentru a determina cine a câștigat rândul dintre utilizator și computer. Pentru a face acest lucru, utilizați metoda compareMoves () enumerare mutare. Dacă utilizatorul câștigă, el își mărește scorul cu 1. Dacă utilizatorul a pierdut, crește scorul calculatorului cu 1. Dacă este o egalitate, nu schimbați scorurile jucătorilor. La sfârșitul comparației, creșteți numărul de jocuri jucate de 1.

int comparMoves = userMove.compareMoves (computerMove) -sincronizare (compareMoves) {caz 0: // PareggioSystem.out.println ("Desenați!") -călcare-caz 1: // câștigă userSystem.out.println (userMove + " bătăi " + computerMove + ". Ați câștigat!") -userScore ++ - break-case -1: // CalculatorulSystem.out.println (computerMove +) câștigă " bătăi " + userMove + ". Ai pierdut.") -computerScore ++ - ++ BREAK-} numberOfGames -

Întreabă-l pe utilizator dacă dorește să se mai joace din nou. Dacă da, apelați din nou metoda startgame (). În caz negativ, apelați metoda printGameStats () pentru a imprima statisticile meciurilor pe ecran. Vom crea această metodă în pasul următor.

dacă (user.playAgain ()) {System.out.println () - startGame () -} altceva {printGameStats () -}

Scrieți codul metodei printGameStats (). Această metodă trebuie să tipărească în statisticile de jocuri video: numărul de victorii, numărul de pierderi, numărul de remize, numărul de runde jucate și procentajul de runde câștigate de către utilizator. Procentajul de victorii se calculează în acest fel (numărul de victorii + (# numărul de remize / 2)) / (numărul de rânduri jucate). Această metodă utilizează codul System.out.printf pentru a afișa textul formatat.

private void printGameStats ()% 6s

În interiorul clasei "principale" scrieți codul pentru a începe jocul. În interiorul clasei "principale" va fi inițializată o instanță a clasei RockPaperScissors iar metoda va fi rechemată startgame ().

public static void principal (String [] args) {RockPaperScissors joc = nou RockPaperScissors () - game.startGame () -}

Rulați un test al programului dvs. Acum am terminat de scris tot codul legat de programul nostru care replică jocul "Piatră, hârtie, foarfece". Este timpul să finalizați și să verificați dacă totul funcționează corect.

Program exemplu

java.util.Random import-import utilizator clasa-java.util.Scanner publice {RockPaperScissors privat privat-user-computer privat int numberOfGames-privat de calculator userScore-privat int computerScore-privat int enum {Mutare ROCK, hârtie, foarfeci - / * ** comparăm muta curent cu mutarea anterioară pentru a determina dacă acesta este un egal, în cazul în care * câștigă sau pierde @parametro otherMove ** * * @return pentru a efectua comparația 1 în cazul în care această mișcare ia cealaltă, -1 dacă această mișcare celălalt este bătut * 0 dacă este o remiză * / compareMoves public int (Mutare otherMove) {// Pareggioif (acest == otherMove) return 0-comutator (aceasta) {caz ROCK: întoarcere (otherMove == SCISSORS? ? 1: -1) HÂRTIE -case: întoarcere (otherMove == ROCK 1: -1) -case SCISSORS: întoarcere (otherMove == CARTEA 1: -1) -} // programul ar trebui să nu ajungă la această puntoreturn 0 -}} utilizator privat de clasă {public-privat utilizator inputScanner Scanner () {inputScanner = new Scanner (System.in) -} getMove publice Move () {// cere utilizatorului să efectueze o la mossaSystem.out.print ("Piatră, hârtie sau foarfece? ") - // Citește intrare dell`utenteString UserInput inputScanner.nextLine = () - UserInput userInput.toUpperCase = () - char = firstLetter userInput.charAt (0) -dacă (== firstLetter firstLetter == `S` || `C` || firstLetter == `F`) {// utilizator a introdus o inputswitch valid (firstLetter) {caz `S`: întoarcere Move.ROCK caz `C`: întoarce Move.PAPER caz `F`: întoarcere Move.SCISSORS -}} // Utilizatorul nu a introdus o mutare validă. Solicitați o nouă mișcare de revenire getMove () -} public boolean playAgain () {System.out.print ("Doriți să jucați din nou? ") -String UserInput inputScanner.nextLine = () - UserInput userInput.toUpperCase = () - return userInput.charAt (0) == `Y` -}} Computer class privat {getMove publice Move () {Mutare [] = mută Mută .values () - aleatoare aleatoare = new aleatoare () - int index = random.nextInt (moves.length) mișcări -Return [index] -}} RockPaperScissors public () {user = new user () - = calculator nou calculator ( ) -userScore-computerScore = 0 = 0 = 0 - numberOfGames startgame} public void () {System.out.println ("SASSO, HÂRTIE, LUCRĂRI!") - // Rulați movesMove userMove = user.getMove () - Deplasați computerMove = computer.getMove () - System.out.println (" nAți jucat " + userMove + ".") -System.out.println ("Computerul a jucat " + computerMove + ". N") - // Compara miscarile facute pentru a determina vincitoreint compareMoves = userMove.compareMoves (computerMove) -switch (compareMoves) {caz 0: // PareggioSystem.out.println ("Desenați!") -călcare-caz 1: // câștigă userSystem.out.println (userMove + " bătăi " + computerMove + ". Ați câștigat!") -userScore ++ - break-case -1: // ComputerSystem.out.println (computerMove +) câștigă " bătăi " + userMove + ". Ai pierdut.") -computerScore ++ - ++ numberOfGames BREAK-} - // Întrebați utilizatorul în cazul în care doresc să joace ancoraif (user.playAgain ()) {System.out.println () - startgame () -} else {printGameStats () -}} / * ** Imprimați statisticile meciurilor. Procentul câștigător ține cont de extragerilor așa cum au fost * 1/2 punct. * / Private void printGameStats ()% 6s printDashes void privat (int numberOfDashes) {pentru (int i = i 0- < numberOfDashes- i ++) {System.out.print ("-") -}} public static void principal (String [] args) {RockPaperScissors joc = nou RockPaperScissors () - game.startGame () -}}

Distribuiți pe rețelele sociale:

înrudit