Wie kann ich einem Wert innerhalb einer HashMap eine Klassenmethode zuweisen?

Question

Ich erstelle ein textbasiertes "Game of Real Life" -Programm. Ich habe Schwierigkeiten damit, eine effiziente Methode zu finden, mit der man die Anweisungen jeder Spielfliese des Spielplans (lineares Spielbrett mit bestimmten Start-/Zielpunkten) ausführen kann. Jeder Spieler im Spiel wird durch ein Objekt der Klasse "Player" dargestellt, das Variablen für verschiedene Spielstatistiken enthält (einschließlich eines Platzhalterwerts für ihre Position auf dem Spielbrett), und jedes Spielerobjekt ist in einer Hash-Karte enthalten. Ich möchte eine Schleife erstellen, die jedes Spielerobjekt durchläuft und basierend auf dem jeweiligen Platzhalterwert eine bestimmte Methode für diese Kachel des Bretts referenziert.

Meine Hauptklasse:

import java.util.Scanner; 
import java.util.HashMap; 

public class Main { 

public static void main(String[] args) { 
    Coin coin = new Coin(); 
    Die die = new Die(); 
    Scanner choice = new Scanner(System.in); 

    System.out.println("Choose player amount:"); 
    int n = choice.nextInt(); 

    /*This map contains master list of all players and player values*/ 
    HashMap<Integer, Player> playerList = new HashMap<Integer, Player>(); 

    /*This map contains just the true_false value of life for each player*/ 
    HashMap<Integer, Boolean> lifeCheck = new HashMap<Integer, Boolean>(); 

    /*This section defines number/sex/name of each player*/ 
    for (int y = 1; y <= n; y++) { 
     System.out.println("New player now flips a coin."); 
     coin.flip(); 
     if (coin.get() == true) { 
      System.out.println("You flipped heads! You are a man."); 
     } else { 
      System.out.println("You flipped tails! You are a woman."); 
     } 

     System.out.println("What is your name?"); 
     String user = choice.next(); 
     playerList.put(y, new Player(user)); 

     /*This adds a check functionality to ensure live players still exist*/ 
     lifeCheck.put(y, playerList.get(y).pulse()); 
    } 

    /*This invokes a new instance of our game board*/ 
    GameSpace gameBoard = new GameSpace();/*Not yet defined*/ 

    /*This do_while loop checks that a live player exists after each turn*/ 
    do { 
     /*This is where I think I would be putting the majority of 
        the game code*/ 

    } while (lifeCheck.containsValue(true)); 

    /*This tests to see if my player naming loop works properly*/ 
    /* 
    int x = 1; 
    for (int i = 1; i <= n; i++) { 
     System.out.println("Player number " + x + " is named " + playerList.get(i).name); 
     x++; 
    } 
    */ 





    choice.close(); 
} 
} 

Meine Spielerklasse:

public class Player { 
public boolean gender; 
public String name; 
public int wealthClass; 
public double income; 
public double wealth; 
public double health; 
public boolean parent = false; 
public boolean disabled = false; 
public boolean alive = true; 
public double placeHold = 1; 

public Player(String playerName) { 
    name = playerName; 
} 

public boolean getGender() { 
    return gender; 
} 
public String getName() { 
    return name; 
} 
public int getCaste() { 
    return wealthClass; 
} 
public double getIncome() { 
    return income; 
} 
public double getWealth() { 
    return wealth; 
} 
public double getHealth() { 
    return health; 
} 
public boolean getParent() { 
    return parent; 
} 
public boolean getDisabled() { 
    return disabled; 
} 
public boolean pulse() { 
    return alive; 
} 
public double getPosition() { 
    return placeHold; 
} 

public void move() { 
    Die die1 = new Die(); 
    die1.roll(); 
    placeHold += die1.get(); 
    System.out.println("You moved forward " + die1.get() + " spaces."); 
} 

public void main(String[] args) { 
    if (health <= 0) { 
     alive = false; 
    } 
} 
} 

Meine Münzklasse:

public class Coin { 
private boolean face; 

public Coin() { 
    flip(); 
} 
public void flip() { 
    double x = (Math.floor(Math.random()*2)); 
    if (x == 0) { 
     face = true; 
    } else { 
     face = false; 
    } 
} 
public boolean get() { 
    return face; 
} 
} 

Wo wäre die logischste Ort, um von hier aus?

Answer 1

Wenn die HashMap Wert ist der Name der Methode, die Sie aufrufen möchten, sollten Sie in der Lage sein, Reflexion zu verwenden:

HashMap<Integer, String> map = new HashMap<>(); 
map.put(0, "methodName1"); 
map.put(1, "methodName2");  

String methodName = map.get(player.getPosition()); 
Method method = Player.class.getDeclaredMethod(methodName); 
method.invoke(); 

Answer 2

Wenn ich die Frage verstehen, Sie zu fragen, wie ein Verfahren zum Speichern von im Zusammenhang mit Jede Position auf dem Brett gibt an, was an dieser Position zu tun ist. Wenn ja, würde ich vorschlagen, dass Sie es in der Position einkapseln. Das wäre am besten als eine Schnittstelle definiert:

interface Position { 
    void operateOnPlayer(Player player); 
} 

Dann dein Board wird eine Karte aus dem Abstand von Anfang an eine Position Implementierung:

Map<Integer,Position> board; 

Wenn Sie mit Java 8, dann können Sie auch verwenden lambdas die Positionen zu definieren:

board.put(17, player -> player.moveBack(4)); 
board.put(16, player -> player.skipATurn()); 

in früheren Versionen von Java genauso gut funktionieren müssen Sie einfach erstellen (möglicherweise anonym) Implementierungen von Position.

dieser Aufruf wird dann ziemlich trivial:

for (Player player: players) 
    board.get(player.getPosition()).operateOnPlayer(player); 

Oder, noch besser, fügt hinzu, dass auf die Player Klasse, so dass Sie die Position Feld nicht aussetzen müssen:

class Player { 
    public takeTurn() { 
     board.get(position).operateOnPlayer(this); 
    } 
}    

Es gibt andere Mechanismen, wie Mapping zu einem Consumer<Player>, aber ich glaube wirklich nicht, dass sie so ein gutes Design sind, wie eine explizite Schnittstelle zu definieren;