Maak een nieuwe klasse met de naam TicTacToeGame . Als u gebruik maakt van een Java- IDE , zoals Netbeans of Eclipse , zal deze automatisch worden afgehandeld voor u . Als u gebruik maakt van een teksteditor en de command line compiler , dan moet u een bestand met de naam TicTacToeGame.java maken en steek de volgende klas skelet erin :

/*** Deze klasse
vertegenwoordigt een 2 player game van TicTacToe . * /class TicTacToeGame { //Alle andere code in de tutorial zal gaan in deze ruimte ! } kopen van 2

variabelen worden gedefinieerd . Er zijn een paar manieren waarop je zou kunnen doen , maar de manier waarop deze tutorial kiest is een eenvoudige 2D -array van enkele personages aan de raad te vertegenwoordigen , met de huidige speler , X of O , opgeslagen als een personage . Ook de samenhang en later verbeteren de leesbaarheid van je code , definieert een paar constanten voor de personages die voor X , O , en leeg. Plaats de volgende :

/*** Het bestuur
. De char is ofwel ' X ' , ' O' , of '' . Deze worden gedefinieerd in de constanten * /private char [ ] [ ] board = new char [ 3 ] [ 3 ] ; . Char currentPlayer ; public static final char X = ' X ' ; public static final char O = ' O ' ; publiek static final char NONE = ' ' ;

Wanneer een waarde wordt opgeslagen op het bord , in vergelijking met een andere waarde op het bord , of opgeslagen in currentPlayer , moet u het uw verklaarde constanten X, Y , en NONE . Zoals hierboven vermeld , dit verbetert de leesbaarheid en de robuustheid van de code .
3

Initialiseer het spel . Slechts een aannemer nodig is voor onze TicTacToe boord .

/*** Initialiseert het bord . * /Public TicTacToeBoard ( ) { //Je kan ook een dubbel - geneste gebruiken voor lus om de board.board vullen [ ,"0 ] [ 0 ] = NONE ; board [ 0 ] [ 1 ] = NONE ; board [ 0 ] [ 2 ] = NONE ; board [ 1 ] [ 0 ] = NONE ; board [ 1 ] [ 1 ] = NONE ; board [ ,"1 ] [ 2 ] = NONE ; board [ 2 ] [ 0 ] = NONE ; board [ 2 ] [ 1 ] = NONE ; board [ 2 ] [ 2 ] = NONE ;

//Stel de huidige speler gelijk aan de X constante u earlier.currentPlayer gedefinieerd = X ; }
4

Voeg de " makeMove " -methode . Deze methode moet drie argumenten nemen : . Het xCoord , yCoord en currentPlayer

/*** Maak een beweging * @ param xCoord de x -coördinaat te markeren * @ param yCoord de y -coördinaat naar * @ param markeren . speler de speler te gebruiken . Dit moet een van de constanten zijn : X , O * @ return true als verhuizing plaatsgevonden . False als beweging is verboden omdat plein vol is * /boolean makeMove ( int xCoord , int yCoord , char speler ) {if ( board [ xCoord ] [ yCoord ] == NONE ) { board [ xCoord ] [ yCoord ] = speler ; . Rendement true ; } else { return false ; } }

Vergeet niet om altijd te definiëren uw JavaDoc reacties
5

Maak een methode om het bord te tekenen . . Er zijn een aantal manieren om dit te doen , maar de meest elegante manier is een eenvoudige , dubbele geneste lus .

/*** Tekent de huidige raad van bestuur om de console met behulp System.out * /void drawBoard ( ) { for ( int x = 0 ; x < board.length ; x + + ) { for ( int y = 0 ; y < board [ x ] lengte ; . y + + ) { //Teken de x en O's op het bord , zodat Wat (evenals de spaties ) . print ( " " + board [ x ] [ y ] + " " ) ;//Teken de verticale lijnen tussen columns.if ( y < 2 ) { System . out.print ( " | " ) ; } } System.out.println ( ) ;//Trek horizontale lijnen tussen rows.System.out.println ( " --- + --- + --- " ) ; } < br >

}
6

Schrijf uw spel lus. Alle spellen bevatten een soort van spel lus die het begin van het spel bepaalt , voert de spelregels , en tests voor een spel winnaar of eindconditie . Hier is het spel lus voor de TicTacToe spel :

void play
( ) { boolean spelen = true; BufferedReader in = new BufferedReader (nieuw InputStreamReader ( System.in ) ) , terwijl ( afspelen ) {

try { boolean validMove = false ;//Blijf vragen de speler om coördinaten totdat ze geeft een geldig antwoord , terwijl { drawBoard ( ) ; System.out.println ( " Huidige Player is : " + currentPlayer ) ! ( validMove ! ) System.out.println ( " Wat x coördinaat ? " ) ;//READ COORDINATESint xCoord = new Integer ( in.readLine ( ) ) ; System.out.println ( " Wat y coördineren? ' ) ; int yCoord = new Integer ( in.readLine ( ) ) ;

validMove = makeMove ( xCoord , yCoord , currentPlayer ) , als System.out.println ( " FOUT ! : Invalid move " ) ( validMove ! ) ; }

//Verander de huidige player.If ( currentPlayer == X ) { currentPlayer = O ; } else { currentPlayer = X ; }

//Als we een winnaar , dan feliciteer hen en de wedstrijd ! als { drawBoard ( ) ; System.out.println ( " Winnaar is : " + this.testWinner ( ) ) ; return ;} ( this.testWinner ( ) = GEEN ! ) //Test voor invoerfouten van het toetsenbord , en afdrukken debug informatie als er een is aangetroffen . Dit is niet alleen een goed idee , is het vereist door de in.readLine ( ) -functie } catch ( IOException e ) { e.printStackTrace ( ) ; . } }

( Zie referenties 1 ) op < br > 7 p Er is een in de play ( ) lus die nog niet is geschreven vermeld functie : TESTWINNAAR ( ) . Het is de moeilijkste functie van alle , en er zijn vele manieren om te gaan over het testen voor de TicTacToe winnaar . De volgende is de meest voor de hand liggende , maar niet de meest efficiënte , oplossing voor het probleem :

/*** Deze functie
zal de raad testen om te zien of er een winnaar is * @ return X als X heeft gewonnen . het spel . O als O heeft het spel gewonnen . NONE indien niemand heeft het spel gewonnen . Deze maakt gebruik van de constanten die door de klas . * /Char TESTWINNAAR ( ) { //TOP ROWif ( board [ 1 ] [ 0 ] == board [ 0 ] [ 0 ] && board [ 1 ] [ 0 ] == board [ 2 ] [ 0 ] ) { return board [ 1 ] [ 0 ] ; }

//MIDDEN HORIZONTALE ROWif ( board [ 1 ] [ 1 ] == board [ 0 ] [ 1 ] && board [ 1 ] [ 1 ] == board [ 2 ] [ 1 ] ) { return board [ 1 ] [ 1 ] ; }

//BOTTOM ROWif ( board [ 1 ] [ 2 ] == board [ 0 ] [ 2 ] && board
[ ,"1 ] [ 2 ] == board [ 2 ] [ 2 ] ) { return board [ 1 ] [ 2 ] ; }

//LEFT ROWif ( board [ 0 ] [ 1 ] == board [ 0 ] [ 0 ] && board [ 0 ] [ 0 ] == board [ 0 ] [ 2 ] ) { return board [ 0 ] [ 0 ] ; }

//middenverticaal ROWif ( board [ 1 ] [ 1 ] == board [ 1 ] [ 0 ] && board [ 1 ] [ 0 ] == board [ 1 ] [ 2 ] ) { return board [ 1 ] [ 1 ] ; }

//RIGHT ROWif
( board [ ,"2 ] [ 1 ] == board [ 2 ] [ 0 ] && board [ 2 ] [ 0 ] == board [ 2 ] [ 2 ] ) { return board [ 2 ] [ 0 ] ; }

//LINKSBOVEN DIAGONALif ( board [ 0 ] [ 0 ] == board [ 1 ] [ 1 ] && board [ 0 ] [ 0 ] == board [ 2 ] [ 2 ] ) { return board [ 0 ] [ 0 ] ; } < br >

//TOP RIGHT DIAGONALif ( board [ 0 ] [ 2 ] == board [ 1 ] [ 1 ] && board [ 0 ] [ 2 ] == board [ 2 ] [ 0 ] ) { return board [ 0 ] [ ,"2 ] ; }

//Als het hier is , niemand won deze round.return NONE ; }

zij gaat eenvoudig door het bestuur , het testen van alle mogelijke winnende combinatie van pleinen en te kijken of een van de spelers heeft het.
8

Maak de belangrijkste functie . Tot slot moet u een belangrijke functie om uw programma een plek om te beginnen geven te creëren . Deze belangrijkste functie zal heel eenvoudig : Het zal gewoon initialiseren uw TicTacToeGame klasse en start de methode play ( ) . Plaats de volgende functie in je klas :

public static void main ( String [ ] args ) op { TicTacToeGame spel = new TicTacToeGame ( ) ; highscorelijst toe te voegen.Speel ( ) ; }

Nu heb je een functionerende TicTacToe spel !