Hur man skapar spelet Sasso, Carta, sax i Java

Sten, papper, sax är ett spel som spelas mellan två personer som använder sina händer. Båda spelarna måste man uttalar formeln "Rock, papper, sax", sedan samtidigt välja och de kommer att göra med en hand en av de tre exemplar i spelet (i själva verket sten, papper eller sax). Vinnaren bestäms utifrån den resulterande kombinationen av objekt. Saxen slog papperet, stenen slår saken och kortet slår stenen. Om båda spelarna har valt samma föremål anses spelets turnering vara bunden. Denna handledning visar hur man skriver ett program i Java som replikerar dynamiken i detta spel. En spelare kommer att representeras av användaren, medan den senare kommer att styras av datorn.

steg

Skapa huvudklassen av programmet och namnge det RockPaperScissors. Detta kommer att vara huvudklassen där vi kommer att ange koden för hela programmet. Du kan välja ett annat namn för den här klassen, till exempel spel eller Huvudsaklig. Skriv deklarationen av metoderna för tillverkaren och huvudmetoden "huvud".

offentlig klass RockPaperScissors {public RockPaperScissors () {} statisk statisk tomt huvud (String [] args) {}}

Skapa en uppräkning som beskriver de tre objekten i spelet (sten, papper, sax). Vi skulle kunna använda tre enkla strängar för att representera rock, papper och sax, men uppräkning tillåter oss att definiera vår ständiga tidigare användning uppräkning är därför ett bättre val i utformningen av koden nivån. Vår anropsräkning Move kommer att ha följande värden: STEN (Rock) PAPPER (papper) e SAX (sax).

privat flytta {ROCK, PAPER, SCISSORS}

Skapa två "privata" klasser, ett samtal användare och den andra dator. Dessa klasser representerar de spelare som möter varandra i det riktiga spelet. Om du önskar kan du välja att deklarera dessa klasser som "offentliga". Klassen användare är den som kommer att be användaren att välja föremålet för hans rörelse mellan sten, papper eller sax, då måste vi skriva metoden getMove () att utföra vårt drag. Även klassen dator kommer att behöva ha en metod getMove (), för att även datorn måste göra sitt drag. Koden för dessa två metoder kommer att implementeras senare, för tillfället kommer vi att begränsa oss till deras deklaration. Klassen användare kräver att en konstruktör skapar objektet skanner brukade läsa användarinmatning. Fältet skanner Den kommer att deklareras som privat för klassen "Användare" och kommer att initieras inuti klasskonstruktorn. Eftersom vi använder standard Java-klassen, skanner, Vi måste importera det till vårt program genom att infoga den relevanta "import" -raden i början av vår kod. Klassen dator det kräver ingen användning av en konstruktör, så vi behöver inte skriva kod för detta element. När vi initierar objektet dator, Java kommer att använda standardkonstruktorn. Nedan finns koden i vår klass RockPaperScissors skrivit fram till nu:

import java.util.Scanner-public class RockPaperScissors privat enum {{Flytta ROCK, PAPPER, SAX} privat klass Användaren {privat-offentlig inputScanner skannern () {inputScanner = new Scanner (System.in) -} public getMove Flytta () {// metod kod för att implementera i seguitoreturn null -}} privat klass Dator {public getMove Flytta () {// metod kod för att implementera i seguitoreturn null -}} offentliga RockPaperScissors () {} public static void main (String [ ] args) {}}

Skapa metoden getMove () relaterade till klassen dator. Denna metod returnerar värdet av ett slumpmässigt drag som valts inom uppräkningen Move. Vi kan skapa en "array" av uppräkningar Move återkallar metoden värden () på så sätt: Move.values (). Att välja en uppräkning Move slumpmässigt bland de som finns i vår "array" måste vi generera ett slumpmässigt index som representeras av ett heltal mellan 0 och antalet av alla element som ingår i vår "array". För att göra detta kan vi använda metoden nextInt () av klassen Random som vi kan importera från paketet java.util. Efter att ha erhållit det slumpmässiga indexet kan vi returnera värdet på uppräkningen Move motsvarande, närvarande inom vår "array".

public Move getMove () {Flytta [] flyttar = Move.values () - Slumpmässig slumpmässig = ny Slumpmässig () - int index = random.nextInt (flytta moves.length) -return moves [index] -}

Skriv metodkoden getMove () för klassen användare. Den här metoden bör returnera värdet som motsvarar det drag som användaren angett. Vi förväntar oss att användaren skriver ett av följande värden: "sten", "papper" eller "sax". Det första steget är att be användaren att ange ett värde. För att göra detta använder vi följande kod: System.out.print ("Sten, papper eller sax?"). Då använder vi metoden nextLine () Punkt skanner att läsa användarinmatning och lagra den i ett "sträng" -objekt. Nu måste vi kontrollera om användaren har gått in i ett giltigt flytta, medan den fortfarande är övergiven vid ett typsnitt. Så vi ska bara kontrollera att den första bokstaven som skrivs motsvarar "S" (i fråga om "sten"), "C" (i fråga om "papper") eller "F" (vid "sax"). Vi oroar dig inte för att användaren har skrivit en stor bokstav eller en liten bokstäver, eftersom vi använder metoden toUpperCase () av klassen String för att aktivera alla tecken som användaren har angett. Om användaren inte har angett ett giltigt flytt kommer vi att fråga honom igen för att göra sitt drag. Då, baserat på användarinmatning, returnerar vi värdet som motsvarar det valda flyget.

public Move getMove () {// Vi begär inmatning från användaren System.out.print ("Sten, papper eller sax? ") - // läsa ingångs trädde dall`utenteString Userinput = inputScanner.nextLine () - Userinput = userInput.toUpperCase () - char first = userInput.charAt (0) -Om (first == `S` || first = = `C` || first == `F`) {// Validiamo ingång trädde dall`utenteswitch (first) {case `S`: retur Move.ROCK-case `C`: återvända Move.PAPER-hem F `: retur Move.SCISSORS -}} // användaren angett ett giltigt drag inte ber vi igen för att ange en mossareturn getMove () -}

Skriv metoden playAgain () för klassen användare. Användaren måste kunna spela på obestämd tid. För att bestämma om användaren vill spela igen, måste vi skriva metoden playAgain () som måste återge ett booleskt värde som kan avslöja om användaren vill fortsätta spelet eller inte. Inom denna metod kommer vi att använda objektet skanner som vi tidigare skapat i "User" -konstruktionen för att få en "Ja" eller "Nej" från användaren. Också i det här fallet kommer vi endast att kontrollera om den första bokstaven är en "Y", för att bestämma om användaren vill spela igen. Vilket annat tecken, nummer eller symbol som helst kommer att motsvara spelarens vilja att stoppa spelet.

offentliga booleanska playAgain () {System.out.print ("Vill du spela igen? ") -String Userinput inputScanner.nextLine = () - Userinput userInput.toUpperCase = () - återgå userInput.charAt (0) == `} Y`-

Länka klasserna tillsammans användare och dator inom klassen RockPaperScissors. Nu när vi har skrivit klasskoden användare och dator, vi kan fokusera på den aktuella spelkoden. Inne i klassen RockPaperScissors, förklarar två privata objekt, en av ett slag användare och en av ett slag dator. Under genomförandet av spelet måste vi komma åt de två metoderna getMove () av respektive "Användare" och "Dator" klasser. Dessa två objekt kommer att initieras inom klasskonstruktorn RockPaperScissors. Vi måste också hålla koll på poängen. För att göra detta använder vi fälten userScore och computerScore att vi kommer att initiera till 0 inom klasskonstruktören. Slutligen kommer vi att ha det ytterligare behovet att hålla koll på antalet spel vars vall numberOfGames det kommer att initieras till 0 inom klasskonstruktorn.

privata användaranvändar privata dator privata dator int userScore privata int computerScore privata int numberOfGames offentliga RockPaperScissors () {user = ny användare () - dator = new Computer () - userScore = 0-computerScore = 0-numberOfGames = 0 -}

Utöka uppräkningen Move så att den innehåller metoden som berättar för oss vad det vinnande rörelsen i varje spelomgång är. För att göra detta måste vi skriva metoden compareMoves () som returnerar värdet 0 om rörelserna är lika, 1 om det aktuella draget slår den föregående och -1 om föregående drag slår den aktuella. Detta schema är användbart för att bestämma vem som kommer att bli vinnare av spelet. Vid genomförandet av denna metod kommer vi först att returnera värdet 0 om rörelserna är desamma och då är vi i en situation med paritet. Då skriver vi kodblocket i samband med retur av värdena 1 och -1.

privata enum {Move ROCK, papper, sax - / *** Vi jämför den nuvarande flytta med föregående drag för att avgöra om det är oavgjort, om * vinner eller förlorar @parametro otherMove ** * * @ return att utföra jämförelsen 1 om detta drag tar den andra, -1 om detta drag är slagen på den andra * 0 om det är oavgjort * / public int compareMoves (flytta otherMove) {// av paritàif Case (detta == otherMove) avkastning 0-omkopplare (detta) {case ROCK: avkastning (otherMove == SAX 1:? -1) -Mål PAPPER: retur (otherMove == ROCK 1:? -1) -Mål SAX: avkastning (otherMove == PAPPER 1:? -1 ) -} // Programmet bör aldrig nå denna punktoreturn 0-}}

Inne i klassen RockPaperScissors, skapa metoden startgame (). Detta är den metod som tillåter oss att spela vårt spel. Starta metodkoden genom att ange följande rad System.out.println.

public void startGame () {System.out.println ("Sten, papper, sax!") -}

Läs de rörelser som användaren och datorn gjort. Inom metoden startgame (), återkalla metoden getMove () av klasserna användare och dator. På så sätt kommer du att flytta till användaren och en till datorn.

Flytta userMove = user.getMove () - Flytta computerMove = computer.getMove () - System.out.println (" nDu spelade " + userMove + ".") -System.out.println ("Datorn har spelat " + computerMove + ". N") -

Jämför de två valda rören för att bestämma vem som vann vridningen mellan användaren och datorn. För att göra detta, använd metoden compareMoves () uppräkning Move. Om användaren vinner höjer han sin poäng med 1. Om användaren har förlorat, öka datorns poäng med 1. Om det är ett slips ändra inte spelarnas poäng. I slutet av jämförelsen, öka antalet spel som spelas av 1.

int compareMoves = userMove.compareMoves (computerMove) -witch (compareMoves) {case 0: // PareggioSystem.out.println ("Rita!") -break-case 1: // Vinner userSystem.out.println (userMove + " beats " + computerMove + ". Du har vunnit!") -userScore ++ - break-case -1: // ComputerSystem.out.println (computerMove +) vinner " beats " + userMove + ". Du har förlorat.") -computerScore ++ - ++ genombrott} numberOfGames -

Fråga användaren om han vill spela igen. Om så är fallet, ring metoden igen startgame (). I det negativa fallet, ring metoden printGameStats () för att skriva ut matchstatistiken på skärmen. Vi kommer att skapa den här metoden i nästa steg.

om (user.playAgain ()) {System.out.println () - startGame () -} annars {printGameStats () -}

Skriv metodkoden printGameStats (). Denna metod måste skriva ut matchstatistiken på skärmen: antal vinster, antal nederlag, antal dragningar, antal turneringar som spelats och procentandel av rundor som användaren vann. Procentandelen av vinster beräknas på detta sätt (# av vinster + (# antal teckningar / 2)) / (# av turneringar spelade). Denna metod använder koden System.out.printf för att visa formaterad text.

private void printGameStats ()% 6s

Inne i huvudklassen skriver du koden för att starta spelet. Inom "huvud" -klassen kommer en instans av klassen att initieras RockPaperScissors och metoden kommer att återkallas startgame ().

offentlig statisk tomt huvud (String [] args) {RockPaperScissors game = nya RockPaperScissors () - game.startGame () -}

Kör ett test av ditt program. Nu har vi slutat skriva hela koden relaterad till vårt program som replikerar spelet "Sten, papper, sax". Det är dags att slutföra och verifiera att allt fungerar ordentligt.

Exempelprogram

java.util.Random import-import java.util.Scanner-public class användare {privata RockPaperScissors användar privata dator private int Computer userScore privata int computerScore privata int numberOfGames privata enum {Move ROCK, papper, sax - / * ** Vi jämför den aktuella flytta med den föregående drag för att bestämma om det är oavgjort, om * vinner eller förlorar @parametro otherMove ** * * @return att utföra jämförelsen 1, om detta drag tar den andra, -1 om detta drag den andra är slagen * 0 om det är oavgjort * / public int compareMoves (Move otherMove) {// Pareggioif (detta == otherMove) avkastning 0-switch (detta) {case ROCK: retur (otherMove == SAX? ? 1: 1) -Mål PAPPER: avkastning (otherMove == ROCK 1: 1) -Mål SAX: avkastning (otherMove == PAPPER 1: 1) -} // programmet bör aldrig nå denna puntoreturn 0 -}} privat klass användaren {privat-offentlig inputScanner Scanner användare () {inputScanner = new Scanner (System.in) -} public getMove Flytta () {// Be användaren att utföra en till mossaSystem.out.print ("Sten, papper eller sax? ") - // Läs dell`utenteString ingång Userinput inputScanner.nextLine = () - Userinput userInput.toUpperCase = () - char = first userInput.charAt (0) -Om (first == `S` || == first `C` || first == `F`) {// användaren har skrivit in ett giltigt inputswitch (first) {case `S`: tillbaka Move.ROCK-case `C`: återvända Move.PAPER-case `F`: returnera Move.SCISSORS -}} // Användaren har inte angett ett giltigt drag. Be om ett nytt move.return getMove () -} offentliga booleanska playAgain () {System.out.print ()"Vill du spela igen? ") -String Userinput inputScanner.nextLine = () - Userinput userInput.toUpperCase = () - återgång userInput.charAt (0) == `Y` -}} privat klass Dator {public getMove Flytta () {Move [] = flyttar Flytta .values () - Random slumpmässig = new Random () - int index = random.nextInt (moves.length) -Return drag [index] -}} offentliga RockPaperScissors () {user = ny användare () - = ny dator dator ( ) -userScore-computerScore = 0 = 0 = 0 - numberOfGames startgame} public void () {System.out.println ("SASSO, PAPPER, SKISSAR!") - // Kör moveMove userMove = user.getMove () - Flytta computerMove = computer.getMove () - System.out.println (" nDu spelade " + userMove + ".") -System.out.println ("Datorn har spelat " + computerMove + ". N") - // Jämför de rörelser som gjorts för att bestämma winnerint appearMoves = userMove.compareMoves (computerMove) -witch (compareMoves) {case 0: // PareggioSystem.out.println ("Rita!") -break-case 1: // Vinner userSystem.out.println (userMove + " beats " + computerMove + ". Du har vunnit!") -userScore ++ - break-case -1: // The ComputerSystem.out.println (computerMove +) vinner " beats " + userMove + ". Du har förlorat.") -computerScore ++ - ++ numberOfGames break} - // Fråga användaren om de vill spela ancoraif (user.playAgain ()) {System.out.println () - startgame () -} else {printGameStats () -}} / * ** Skriv ut matchstatistik. Den vinnande procent tar hänsyn till den drar som de var * 1/2 punkt. * / Privata void printGameStats ()% privata void 6s printDashes (int numberOfDashes) {for (int i = i 0- < numberOfDashes- i ++) {System.out.print ("-") -}} statisk statisk tomt huvud (String [] args) {RockPaperScissors game = nya RockPaperScissors () - game.startGame () -}}

Dela på sociala nätverk:

Relaterade