Eenvoudige dobbelstenen games kunnen eenvoudig worden gemaakt op Java door het creëren van een wrapper rond de Random class genaamd Dice . Deze wrapper zal een eenvoudige dobbelspel en kan gebruikt worden als een dobbelsteen abstractie binnen een groter programma , zonder zich zorgen te maken over de random number zaden en andere technische details . Omdat het bedoeld is uitbreidbaar , zal deze klasse bevatten opties voor het instellen van het aantal zijden van een matrijs en het aantal gelijktijdige rollen te voeren . Wat je nodig hebt
Java Development Kit
Java- runtime-engine
Java IDE of teksteditor
Toon Meer Aanwijzingen
1 Creëer een ' Oprolbaar " -interface . Dit kan gedaan worden door het creëren van een nieuwe klasse -bestand en het schrijven van het volgende erin : . /*** Deze interface
definieert objecten die kunnen worden uitgerold in de mode van de dobbelstenen * @ author Amber Rollins * /openbare interface Oprolbaar { /*** Rolls een enkel object en retourneert het resultaat van de rol * @ return het resultaat van de rol * /int roll ( ) ; . /*** roll
een aantal objecten en de terugkeer van de totale gerold * @ param aantal het aantal objecten te rollen * @ return de som van alle rollen * /int roll ( int aantal ) ; . } kopen van 2 Maak een " Dice " klasse die de Oprolbaar interface implementeert . De interface definieert de minimale functionaliteit die nodig zullen zijn voor een dobbelsteen klasse , maar die interface moet nog worden geïmplementeerd . Public class Dice
{ //Vul de rest met behulp van de stappen 3-5 . }
3 Schrijf twee constructeurs , een die geen argumenten die een zes zijdige dobbelsteen gaat ervan wordt gemaakt , en een ander die het aantal zijden neemt de dobbelsteen als argument neemt .
/*** een matrijs wordt gemaakt met 6 zijden * /public Dice ( ) . { willekeurige = new Random ( ) ; zijden = 6 ; } /*** een dobbelsteen
wordt gemaakt met een bepaald aantal zijden * @ param zijden het aantal zijden van de dobbelsteen * /public Dice ( int zijkanten ) . { dit ( ) ; this.sides = zijden ; }
4 Schrijf de twee roll -functies om te voldoen de interface-eisen verklaard Oprolbaar . Een functie wordt gebruikt om een enkele rol vervullen , en de tweede wordt gebruikt voor het verlengen dat het uitvoeren van een reeks van rollen in een keer en het resultaat terug . Public int roll ( ) op { //1 toevoegen omdat de mogelijke resultaten lopen van 0 tot en met zijden - 1 ( zie referenties 1 ) , en dit is niet hoe gewone dobbelstenen behave.return random.nextInt ( zijkanten ) 1 ; } public int roll
( int getal ) { int totaal = 0; for ( int x = 0 ; x < aantal ; x + + ) { totaal + = roll ( ) ; } return totaal ; }
5 Schrijf een hoofdfunctie die zal spelen een eenvoudige hoge roll dobbelspel . Dit spel zal twee spelers te bereiken rollen een dobbelsteen , en de hoogste roller zal winnen public static void main
( String [ ] args ) { try { Dice d = new Die ( ) ; . System.out . println ( " Speler ene ... op een willekeurige toets te rollen . "); System.in.read ( ) ; int oneRolls = d.roll ( ) ; System.out.println ( " Speler men gooit een " + oneRolls ) ; System.out.println
( " Speler twee ... op een willekeurige toets te rollen . "); System.in.read ( ) ; int twoRolls = d.roll ( ) ; System.out.println
if ( oneRolls > twoRolls ) { System.out.println ( " Player een wint . "); ; } else { System.out.println ( " Speler ( " Speler twee gooit een " + twoRolls ) twee overwinningen " ) ; . } } catch
( IOException e ) { e.printStackTrace ( ) ; System.exit ( -1 ) ; }
}
< br >
|
