როკი, ქაღალდი, მაკრატელი არის თამაში, რომელსაც თამაშობს ორი ადამიანი. ორივე იტყოდა "კლდე, ქაღალდი, მაკრატელი" და შემდეგ ერთდროულად ქმნიდა სამივე ობიექტიდან ერთს (კლდე, ქაღალდი ან მაკრატელი) გაშლილი ხელით. გამარჯვებული განისაზღვრება ხელის ფორმირებებით. მაკრატელი სცემს ქაღალდს, ქაღალდი სცემს კლდეს, ხოლო კლდე სცემს მაკრატელს. თუ ორივე მოთამაშე თამაშობს ერთნაირ ხელის ფორმირებას, ის ითვლება ფრედ. ჩვენ დავწერთ მარტივ თამაშს ჯავაში როკის, ქაღალდის, მაკრატლის სიმულაციისთვის, სადაც ერთი მოთამაშე არის მომხმარებელი, ხოლო მეორე მოთამაშე არის კომპიუტერი.
ნაბიჯები
ნაბიჯი 1. შექმენით ძირითადი კლასი და დაურეკეთ მას
Ქვა ფურცელი მაკრატელი
.
ეს იქნება კლასი, სადაც ჩვენ დავწერთ თამაშს. თქვენ შეგიძლიათ დაასახელოთ სხვა რამ, მაგალითად
თამაში
ან
მთავარი
რა ჩაწერეთ მეთოდის დეკლარაციები კონსტრუქტორისთვის და ძირითადი მეთოდი.
საჯარო კლასი RockPaperScissors {public RockPaperScissors () {} public static void main (String args) {}}
ნაბიჯი 2. ჩამოთვალეთ ხელის ჟესტები (როკი, ქაღალდი ან მაკრატელი)
ჩვენ შეგვიძლია გამოვიყენოთ სტრიქონები კლდის, ქაღალდის ან მაკრატლის გამოსახატავად, მაგრამ ჩამოთვლა საშუალებას გვაძლევს წინასწარ განვსაზღვროთ ჩვენი მუდმივები, რაც ნიშნავს რომ აღრიცხვის გამოყენება უკეთესი დიზაინია. ჩვენ დავარქმევთ ჩვენს enum ტიპს
გადაადგილება
ღირებულებებთან ერთად
როკი
ქაღალდი
და
ᲛᲐᲙᲠᲐᲢᲔᲚᲘ
პირადი enum Move {ROCK, PAPER, SCISSORS}
ნაბიჯი 3. შექმენით ორი კერძო კლასი
მომხმარებელი
და
კომპიუტერი
.
ეს კლასები წარმოადგენენ ჩვენს მოთამაშეებს თამაშში. თქვენ შეგიძლიათ აირჩიოთ ეს კლასები საჯარო გახადოთ. ის
მომხმარებელი
კლასი იქნება კლასი, რომელიც მომხმარებელს მოუწოდებს როკის, ქაღალდის ან მაკრატლისთვის, ამიტომ ჩვენ უნდა დავწეროთ
getMove ()
მეთოდი. ის
კომპიუტერი
კლასს ასევე უნდა ჰქონდეს
getMove ()
მეთოდი ისე, რომ კომპიუტერმა ასევე შეძლოს ნაბიჯის გადადგმა. ჩვენ ამ მეთოდებში ჩავდებთ ადგილსამყოფელს და განვახორციელებთ მათ მოგვიანებით. ის
მომხმარებელი
კლასს დასჭირდება კონსტრუქტორი, რომელიც ადგენს
სკანერი
ობიექტი მიიღოს მომხმარებლის შეყვანა. ჩვენ დავდებთ
სკანერი
როგორც მომხმარებლის პირადი შეტყობინების ველი და შემდეგ მისი ინიცირება კონსტრუქტორში. ვინაიდან ჩვენ ვიყენებთ
სკანერი
კლასი, ჩვენ უნდა დავწეროთ იმპორტის განცხადება ამისთვის ჩვენი კოდის ზედა ნაწილში. ის
კომპიუტერი
კლასს არ სჭირდება კონსტრუქტორი, ამიტომ ჩვენ არ გვჭირდება მისი დაწერა; როდესაც ჩვენ ვიწყებთ
კომპიუტერი
ობიექტი, ჩვენ უბრალოდ მოვუწოდებთ ნაგულისხმევ კონსტრუქტორს. აი რა არის ჩვენი
Ქვა ფურცელი მაკრატელი
კლასი ახლა ასე გამოიყურება:
java.util. Scanner იმპორტი; საჯარო კლასი RockPaperScissors {private enum Move {ROCK, PAPER, SCISSORS} პირადი კლასის მომხმარებელი {private Scanner inputScanner; საჯარო მომხმარებელი () {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 ()
მეთოდი ამისთვის
კომპიუტერი
კლასი.
ეს მეთოდი დააბრუნებს შემთხვევითობას
გადაადგილება
რა ჩვენ შეგვიძლია მივიღოთ მასივი
გადაადგილება
აღრიცხვები დარეკვით
ღირებულებები ()
მეთოდი:
გადატანა. ღირებულებები ()
რა შემთხვევითი ასარჩევად
გადაადგილება
ამ ღირებულებების მასივში ჩამოთვლა, ჩვენ უნდა შევქმნათ შემთხვევითი ინდექსი, რომელიც არის მთელი რიცხვი 0 -სა და ჩვენი მნიშვნელობების მასივის სიგრძეს შორის. ამისათვის ჩვენ შეგვიძლია გამოვიყენოთ
შემდეგი ()
მეთოდი
შემთხვევითი
კლასი, საიდანაც უნდა შემოვიტანოთ
java.util
რა მას შემდეგ რაც მივიღეთ შემთხვევითი ინდექსი, შეგვიძლია დავუბრუნოთ
გადაადგილება
ამ ინდექსის ჩვენი ღირებულებების მასივიდან.
public Move getMove () {Move moves = Move.values (); შემთხვევითი = ახალი შემთხვევითი (); int ინდექსი = random.nextInt (moves.length); დაბრუნების მოძრაობები [ინდექსი]; }
ნაბიჯი 5. დაწერეთ
getMove ()
მეთოდი ამისთვის
მომხმარებელი
კლასი.
ეს მეთოდი დააბრუნებს a
გადაადგილება
შეესაბამება იმას, რაც მომხმარებელს აქვს შეყვანილი. ჩვენ ველით, რომ მომხმარებელი დაწერს ან "როკს", "ქაღალდს", ან "მაკრატელს". პირველ რიგში, ჩვენ უნდა შევატყობინოთ მომხმარებელს შეყვანისთვის:
System.out.print ("კლდე, ქაღალდი, თუ მაკრატელი?")
რა შემდეგ გამოიყენეთ
შემდეგი ხაზი ()
მეთოდი
სკანერი
ობიექტი მიიღოს მომხმარებლის შეყვანა როგორც სტრიქონი. ჩვენ ახლა უნდა შევამოწმოთ, წარადგინა თუ არა მომხმარებელმა მოქმედი ნაბიჯი, მაგრამ ჩვენ შეგვიძლია ვიყოთ მომთმენი, თუ მომხმარებელს არასწორად აქვს დაწერილი სიტყვა. ამრიგად, ჩვენ მხოლოდ შევამოწმებთ, არის თუ არა მომხმარებლის შეყვანის პირველი ასო ან "R" (როკისთვის), "P" (ქაღალდისთვის), ან "S" (მაკრატლისთვის) და ჩვენ არ ვაინტერესებთ საქმეს, რადგან ჩვენ პირველად გამოვიყენებთ
toUpperCase ()
მეთოდი
სიმებიანი
კლასი, რათა მომხმარებლის შეყვანის სტრიქონი იყოს დიდი. თუ მომხმარებელს არ აქვს შეყვანილი დისტანციურად სწორი შეყვანა, ჩვენ მას კვლავ შევეკითხებით. შემდეგ, იმისდა მიხედვით, თუ რა დააყენა მომხმარებელმა, ჩვენ დავუბრუნებთ შესაბამის სვლას.
public Move getMove () {// მომხმარებლის მოთხოვნა System.out.print ("როკი, ქაღალდი, თუ მაკრატელი?"); // მიიღეთ მომხმარებლის შეყვანა String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// მომხმარებელმა შეიყვანა სწორი შეყვანის გადამრთველი (firstLetter) {case 'R': return Move. ROCK; საქმე 'P': დაბრუნება Move. PAPER; საქმე 'S': დაბრუნება Move. SCISSORS; }} // მომხმარებელს არ აქვს შეყვანილი სწორი შეყვანა. ისევ მკითხა. დაბრუნება getMove (); }
ნაბიჯი 6. დაწერეთ ა
ხელახლა თამაში()
მეთოდი ამისთვის
მომხმარებელი
კლასი.
მომხმარებელს უნდა შეეძლოს თამაშის თამაში უსასრულოდ. იმის დასადგენად, სურს თუ არა მომხმარებელს კვლავ თამაში, ჩვენ უნდა დავწეროთ a
ხელახლა თამაში()
მეთოდი, რომელიც აბრუნებს ლოგიკურ თამაშს და ეუბნება თამაშს, გადაწყვიტა თუ არა მომხმარებელმა კვლავ თამაში. ამ მეთოდით, ჩვენ ვიყენებთ
სკანერი
რომ ჩვენ ადრე წამოვიწყეთ კონსტრუქტორში მომხმარებლისგან "დიახ" ან "არა". ჩვენ მხოლოდ შევამოწმებთ არის თუ არა პირველი ასო "Y", რათა დადგინდეს სურს თუ არა მომხმარებელს კვლავ თამაში. ნებისმიერი სხვა შეყვანა ნიშნავს, რომ მომხმარებელს არ სურს ხელახლა თამაში.
public boolean playAgain () {System.out.print ("გინდა ისევ თამაში?"); სიმებიანი userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); userInput.charAt (0) == 'Y' დაბრუნება; }
ნაბიჯი 7. შეაერთეთ
მომხმარებელი
და
კომპიუტერი
კლასები ერთად
Ქვა ფურცელი მაკრატელი
კლასი.
ახლა რომ დავამთავრეთ წერა
მომხმარებელი
და
კომპიუტერი
კლასები, ჩვენ შეგვიძლია გავამახვილოთ ყურადღება ჩვენს რეალურ თამაშზე მუშაობაზე. შექმენით პირადი ველები
მომხმარებელი
და
კომპიუტერი
კლასები
Ქვა ფურცელი მაკრატელი
კლასი. ჩვენ დაგვჭირდება ამ ველზე წვდომა, რომ შევიდეთ
getMove ()
მეთოდები, როდესაც ჩვენ ვთამაშობთ თამაშს. კონსტრუქტორში ამისთვის
Ქვა ფურცელი მაკრატელი
კლასი, წამოიწყეთ ეს ველები. ჩვენ ასევე დაგვჭირდება თვალის დევნება ანგარიშში
userScore
და
კომპიუტერული ქულა
ველები, რომლებიც ჩვენ უნდა დავიწყოთ როგორც 0 კონსტრუქტორში. ჩვენ უნდა თვალყური ვადევნოთ თამაშების რაოდენობასაც, რომელიც ასევე იქნება ველი, როგორც 0.
პირადი მომხმარებლის მომხმარებელი; კერძო კომპიუტერული კომპიუტერი; პირადი int userScore; პირადი int computerScore; პირადი int numberOfGames; საჯარო RockPaperScissors () {მომხმარებელი = ახალი მომხმარებელი (); კომპიუტერი = ახალი კომპიუტერი (); userScore = 0; კომპიუტერული ქულა = 0; numberOfGames = 0; }
ნაბიჯი 8. გააგრძელეთ
გადაადგილება
enum მოიცავს მეთოდს, რომელიც გვეუბნება რომელი ნაბიჯი იგებს თითოეულ შემთხვევაში.
ჩვენ უნდა დავწეროთ ა
შეადარეთ გადაადგილება ()
მეთოდი, რომელიც ბრუნებს 0 -ს, თუ მოძრაობები ერთნაირია, 1 თუ მიმდინარე სვლა სცემს მეორე სვლას და -1 თუ მიმდინარე სვლა წააგებს მეორე სვლას. ეს სასარგებლო იქნება თამაშში გამარჯვებულის დასადგენად. ამ მეთოდის განსახორციელებლად, ჩვენ თავდაპირველად დავუბრუნებთ 0 -ს, თუ მოძრაობები იგივეა და ამიტომ გვაქვს ჰალსტუხი. შემდეგ ჩაწერეთ გადამრთველის განცხადება 1 ან -1 – ის დასაბრუნებლად.
პირადი enum გადატანა {ROCK, PAPER, SCISSORS; /** * ადარებს ამ ნაბიჯს სხვა ნაბიჯთან ფრე, მოგება ან * წაგება. * * @param otherMove * გადაადგილება შედარებისთვის * @return 1 თუ ეს ნაბიჯი სცემს სხვა მოძრაობას, -1 თუ ეს ნაბიჯი წააგებს * სხვა მოძრაობას, 0 თუ ეს მოძრაობები ჰალსტუხს * / public int compareMoves (Move otherMove) { / / ჰალსტუხი if (this == otherMove) დაბრუნდება 0; გადართვა (ეს) {case ROCK: return (otherMove == SCISSORS 1: -1); საქმე ქაღალდი: დაბრუნება (სხვა გადატანა == ROCK? 1: -1); საქმის მაკრატელი: დაბრუნება (სხვა გადატანა == ქაღალდი? 1: -1); } // არასოდეს უნდა მიაღწიოს აქ დაბრუნებას 0; }}
ნაბიჯი 9. შექმენით ა
თამაშის დაწყება()
მეთოდი
Ქვა ფურცელი მაკრატელი
კლასი.
ეს მეთოდი იქნება თამაში. დაიწყეთ მარტივი სიტყვებით
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 (კომპიუტერული გადატანა); გადართვა (შედარება გადაადგილება) {შემთხვევა 0: // ჰალსტუხი System.out.println ("ჰალსტუხი!"); შესვენება; შემთხვევა 1: // მომხმარებელი იმარჯვებს System.out.println (userMove + "სცემს" + computerMove + ". შენ გაიმარჯვე!"); userScore ++; შესვენება; შემთხვევა -1: // კომპიუტერი იმარჯვებს System.out.println (computerMove + "სცემს" + userMove + ". თქვენ წააგეთ."); computerScore ++; შესვენება; } numberOfGames ++;
ნაბიჯი 12. ჰკითხეთ, სურს თუ არა მომხმარებელს ხელახლა თამაში
თუ მომხმარებელს სურს კვლავ თამაში, დარეკეთ
თამაშის დაწყება()
ისევ წინააღმდეგ შემთხვევაში, დარეკეთ
printGameStats ()
რომელიც დაბეჭდავს თამაშის სტატისტიკას. ჩვენ დავწერთ ამ მეთოდს შემდეგ ეტაპზე.
if (user.playAgain ()) {System.out.println (); თამაშის დაწყება(); } else {printGameStats (); }
ნაბიჯი 13. დაწერეთ
printGameStats ()
მეთოდი.
ეს მეთოდი აჩვენებს თამაშის სტატისტიკას: მოგების რაოდენობა, წაგების რაოდენობა, ფრეების რაოდენობა, თამაშების რაოდენობა და მომხმარებლის მიერ მოგებული თამაშების პროცენტი. მოგებული თამაშების პროცენტი გამოითვლება (# მოგება + (# თანაბარი/2))/(# თამაში). ეს მეთოდი იყენებს
System.out.printf
ფორმატირებული ტექსტის დასაბეჭდად.
პირადი 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 გაიმარჯვა "); // 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", მოგება, წაგება, კავშირები, რიცხვი თამაშებში, პროცენტული მოგება * 100); // Line System.out.print ("+"); printDashes (68); System.out.println ("+"); }
ნაბიჯი 14. დაიწყეთ თამაში ძირითად კლასში
მთავარ კლასში ინიციალიზაცია მოახდინეთ
Ქვა ფურცელი მაკრატელი
კლასი და დარეკეთ
თამაშის დაწყება()
მეთოდი.
public static void main (სიმებიანი args) {RockPaperScissors თამაში = ახალი RockPaperScissors (); game.startGame (); }
ნაბიჯი 15. გამოსცადეთ თქვენი თამაში
ახლა, როდესაც ჩვენ გადავიტანეთ ყველა მცდელობა როკის, ქაღალდის, მაკრატლის თამაშის დასაწერად, დროა შევადგინოთ და გამოვცადოთ ყველაფერი!
საცდელი პროგრამა
იმპორტი java.util. Random; java.util. Scanner იმპორტი; საჯარო კლასი RockPaperScissors {პირადი მომხმარებლის მომხმარებელი; კერძო კომპიუტერული კომპიუტერი; პირადი int userScore; პირადი int computerScore; პირადი int numberOfGames; პირადი enum გადატანა {ROCK, PAPER, SCISSORS; /** * ადარებს ამ ნაბიჯს სხვა სვლაზე ფრე, მოგება ან * წაგება. * * @param otherMove * გადაადგილება შედარებისთვის * @return 1 თუ ეს ნაბიჯი სცემს სხვა მოძრაობას, -1 თუ ეს ნაბიჯი წააგებს * სხვა მოძრაობას, 0 თუ ეს მოძრაობები ჰალსტუხს * / public int compareMoves (Move otherMove) { / / ჰალსტუხი if (this == otherMove) დაბრუნდება 0; გადართვა (ეს) {case ROCK: return (otherMove == SCISSORS 1: -1); საქმე ქაღალდი: დაბრუნება (სხვა გადატანა == ROCK? 1: -1); საქმის მაკრატელი: დაბრუნება (სხვა გადატანა == ქაღალდი? 1: -1); } // არასოდეს უნდა მიაღწიოს აქ დაბრუნებას 0; }} კერძო კლასის მომხმარებელი {პირადი სკანერი inputScanner; საჯარო მომხმარებელი () {inputScanner = ახალი სკანერი (System.in); } public Move getMove () {// მომხმარებლის მოთხოვნა System.out.print ("როკი, ქაღალდი, თუ მაკრატელი?"); // მიიღეთ მომხმარებლის შეყვანა String userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); char firstLetter = userInput.charAt (0); if (firstLetter == 'R' || firstLetter == 'P' || firstLetter == 'S') {// მომხმარებელმა შეიყვანა სწორი შეყვანის გადამრთველი (firstLetter) {case 'R': return Move. ROCK; საქმე 'P': დაბრუნება Move. PAPER; საქმე 'S': დაბრუნება Move. SCISSORS; }} // მომხმარებელს არ აქვს შეყვანილი სწორი შეყვანა. ისევ მკითხა. დაბრუნება getMove (); } public boolean playAgain () {System.out.print ("გინდა ისევ თამაში?"); სიმებიანი userInput = inputScanner.nextLine (); userInput = userInput.toUpperCase (); userInput.charAt (0) == 'Y' დაბრუნება; }} კერძო კლასი კომპიუტერი {public Move getMove () {Move moves = Move.values (); შემთხვევითი = ახალი შემთხვევითი (); int ინდექსი = random.nextInt (moves.length); დაბრუნების მოძრაობები [ინდექსი]; }} საჯარო RockPaperScissors () {მომხმარებელი = ახალი მომხმარებელი (); კომპიუტერი = ახალი კომპიუტერი (); 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); გადართვა (შედარება გადაადგილება) {შემთხვევა 0: // ჰალსტუხი System.out.println ("ჰალსტუხი!"); შესვენება; შემთხვევა 1: // მომხმარებელი იმარჯვებს System.out.println (userMove + "სცემს" + computerMove + ". შენ გაიმარჯვე!"); userScore ++; შესვენება; შემთხვევა -1: // კომპიუტერი იმარჯვებს System.out.println (computerMove + "სცემს" + 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 გაიმარჯვა "); // 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", მოგება, წაგება, კავშირები, რიცხვი თამაშებში, პროცენტული მოგება * 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 game = new RockPaperScissors (); game.startGame (); }}
