Java 基于文本的Uno游戏，随机电脑玩家和人类玩家（StackOverflower错误）

我一直在为我的Java入门课程编写一个Uno游戏。该平台功能齐全，所有代码均可编译。我在很多行上都有一个运行时堆栈溢出错误。当制作一个新的玩家或游戏对象时，我会遇到这些错误

再次感谢你的帮助

public class Game
{
private Player player1;
private Player player2;
private Player player3;
private Deck thisDeck;
private Card currentCard;

public Game()
{
    player1 = new Player(1,0);
    player2 = new Player(2,1);
    player3 = new Player(3,1);
    thisDeck = new Deck();
    currentCard = null;
    startGame();
}

public void startGame()
{
    setCurrentCard(thisDeck.drawRandomCard());
    System.out.println("The game has been started by drawing a random card and setting it as the current card");
    currentCard.print();
}

public void setCurrentCard(Card newCurrentCard)
{
    currentCard = newCurrentCard;
    System.out.println("The current card has been changed");
}    

public Player getPlayer1()
{
    return player1;
}

public Player getPlayer2()
{
    return player2;
}

public Player getPlayer3()
{
    return player3;
}

public Card getCurrentCard()
{
    return currentCard;
}

}

import java.util.ArrayList;

public class Player
{
private int playerID;
private int playerType; //0 is human, 1 is computer
private Deck thisDeck;
private Game thisGame;
private ArrayList<Card> hand;
private ArrayList<Card> handToPlay;

public Player(int pPlayerID, int pPlayerType)
{
    playerID = pPlayerID;
    playerType = pPlayerType;
    thisDeck = new Deck();
    thisGame = new Game();
    hand = new ArrayList<Card>();
    handToPlay = new ArrayList<Card>();
}

public void dealtAHand()
{
    hand.add(thisDeck.drawRandomCard());
    hand.add(thisDeck.drawRandomCard());
    hand.add(thisDeck.drawRandomCard());
    hand.add(thisDeck.drawRandomCard());
    hand.add(thisDeck.drawRandomCard());
    hand.add(thisDeck.drawRandomCard());
    hand.add(thisDeck.drawRandomCard());
}

public void createHandToPlay()
{
    Card currentCard = thisGame.getCurrentCard();
    for(Card thisCard: hand)
    {
        if(thisCard.getColor().equals(currentCard.getColor()) || thisCard.getValue()== currentCard.getValue())
        {
            handToPlay.add(thisCard); 
            System.out.println("A card has been added to Hand To Play");
        }
        if(thisCard.getValue()==13 || thisCard.getValue()==14)
        {
            handToPlay.add(thisCard);
            System.out.println("A wild card has been added to Hand To Play");
        }
    }
    for(Card thisCard: handToPlay)
    {
        thisCard.print();
    }
}

public void takeAComputerTurn()
{
    createHandToPlay();
    if(handToPlay.isEmpty())
    {
        drawACard();
    }
    else
    {
        playACard();
    }
}

public void takeAHumanTurn()
{
    createHandToPlay();
    if(handToPlay.isEmpty())
    {
        drawACard();
        System.out.println("As you had no cards to play in your hand, you have drawn a card");
    }
    else
    {
        System.out.println("Based on these available choices, which card would you like to play?");
    }

}

public void playACard()
{
    //int randomIndex = randomGenerator.nextInt(handToPlay.size());
    //Card cardToPlay = handToPlay.get(randomIndex);  
    //System.out.println("The card to play has been randomly chosen");
    Card cardToPlay = handToPlay.get(0); 
    System.out.println("The card to play has been chosen (first card in the ArrayList)");
    thisGame.setCurrentCard(cardToPlay);
    thisGame.getCurrentCard().print();
    handToPlay.clear();
}

public void drawACard()
{
    hand.add(thisDeck.drawRandomCard());
}

public int getPlayerType()
{
    return playerType;
}
}

import java.util.ArrayList;
import java.util.Random;

public class Deck
{
private Card thisCard;
private ArrayList<Card> deck;
private ArrayList<String> colors;
private ArrayList<Integer> values;
private Random randomGenerator;

public Deck()
{
    deck = new ArrayList<Card>();
    randomGenerator = new Random();
    initalizeColors();
    initalizeValues();
    createDeck();
}

private void initalizeColors()
{
    colors = new ArrayList<String>();
    colors.add("Red");
    colors.add("Yellow");
    colors.add("Green");
    colors.add("Blue");        
}    

private void initalizeValues()
{
    values = new ArrayList<Integer>();
    values.add(0);
    values.add(1);
    values.add(2);
    values.add(3);
    values.add(4);
    values.add(5);
    values.add(6);
    values.add(7);
    values.add(8);
    values.add(9);
    values.add(10);
    values.add(11);
    values.add(12);
    values.add(13);
    values.add(14);        
}

public void createDeck()
{
    for(int thisValue:values)
    {
        if(thisValue==0)
        {
            for(String thisColor:colors)
            {
                thisCard = new Card(thisColor,thisValue);
                deck.add(thisCard);               
            }
        }

        if(thisValue>=1 && thisValue<=9)
        {
            for(String thisColor:colors)
            {
                thisCard = new Card(thisColor,thisValue);
                deck.add(thisCard);         
                thisCard = new Card(thisColor,thisValue);
                deck.add(thisCard); 
            }
        }

        if(thisValue>=10 && thisValue<=12)
        {
            for(String thisColor:colors)
            {
                thisCard = new ActionCard(thisColor,thisValue);
                deck.add(thisCard);  
                thisCard = new ActionCard(thisColor,thisValue);
                deck.add(thisCard); 
            }
        }

        if(thisValue==13)
        {
            for(String thisColor:colors)
            {
                thisCard = new WildCard(null,thisValue);
                deck.add(thisCard);               
            }
        }

        if(thisValue==14)
        {
            for(String thisColor:colors)
            {
                thisCard = new WildActionCard(null,thisValue);
                deck.add(thisCard);               
            }
        }
    }
}

public Card drawCardByIndex(int index)
{
    thisCard = deck.get(index);
    deck.remove(index);
    return thisCard;
}  

public Card drawRandomCard()
{
    int randomIndex = randomGenerator.nextInt(deck.size());
    thisCard = drawCardByIndex(randomIndex);
    return thisCard;
}    

public void printDeckInfo()
{
    for(Card thisCard:deck)
    {
        thisCard.print();
    }
}
}

公共类游戏
{
私人玩家玩家1；
私人玩家玩家2；
私人玩家玩家3；
私人甲板；
私人卡；
公共游戏（）
{
player1=新玩家（1,0）；
player2=新玩家（2,1）；
player3=新玩家（3,1）；
此甲板=新甲板（）；
currentCard=null；
startGame（）；
}
公共无效StartName（）
{
setCurrentCard（thisDeck.drawRandomCard（））；
System.out.println（“游戏通过随机抽取一张卡并将其设置为当前卡开始”）；
currentCard.print（）；
}
公共作废setCurrentCard（卡新CurrentCard）
{
currentCard=newCurrentCard；
System.out.println（“当前卡已更改”）；
}    
公共播放器getPlayer1（）
{
返回播放器1；
}
公共播放器getPlayer2（）
{
返回player2；
}
公共玩家getPlayer3（）
{
返回player3；
}
公共卡getCurrentCard（）
{
返回电流卡；
}
}
导入java.util.ArrayList；
公开课选手
{
私人int playerID；
private int playerType；//0是人，1是计算机
私人甲板；
私人游戏这个游戏；
私人ArrayList手；
私人ArrayList handToPlay；
公共播放器（int-pPlayerID，int-pPlayerType）
{
playerID=pPlayerID；
playerType=pPlayerType；
此甲板=新甲板（）；
这个游戏=新游戏（）；
hand=newarraylist（）；
handToPlay=newarraylist（）；
}
公共空间和（）
{
hand.add（thisDeck.drawRandomCard（））；
hand.add（thisDeck.drawRandomCard（））；
hand.add（thisDeck.drawRandomCard（））；
hand.add（thisDeck.drawRandomCard（））；
hand.add（thisDeck.drawRandomCard（））；
hand.add（thisDeck.drawRandomCard（））；
hand.add（thisDeck.drawRandomCard（））；
}
public void createHandToPlay（）
{
Card currentCard=thisGame.getCurrentCard（）；
用于（此卡：手）
{
如果（thisCard.getColor（）.equals（currentCard.getColor（））| | thisCard.getValue（）==currentCard.getValue（））
{
handToPlay.添加（此卡）；
System.out.println（“已将一张卡添加到手牌中进行游戏”）；
}
如果（thisCard.getValue（）==13 | | thisCard.getValue（）==14）
{
handToPlay.添加（此卡）；
System.out.println（“已将通配符添加到手牌中以进行游戏”）；
}
}
对于（此卡：handToPlay）
{
这张卡片。打印（）；
}
}
公共计算机
{
createHandToPlay（）；
if（handToPlay.isEmpty（））
{
drawACard（）；
}
其他的
{
playACard（）；
}
}
公共无效takeAHumanTurn（）
{
createHandToPlay（）；
if（handToPlay.isEmpty（））
{
drawACard（）；
System.out.println（“因为你手中没有牌可玩，所以你抽了一张牌”）；
}
其他的
{
System.out.println（“根据这些可用选项，您想玩哪张牌？”）；
}
}
公共空间playACard（）
{
//int randomIndex=randomGenerator.nextInt（handToPlay.size（））；
//卡片cardToPlay=handToPlay.get（随机索引）；
//System.out.println（“随机选择要玩的牌”）；
Card cardToPlay=handToPlay.get（0）；
System.out.println（“已选择要玩的牌（ArrayList中的第一张牌）”；
此游戏。设置当前卡（cardToPlay）；
thisGame.getCurrentCard（）.print（）；
handToPlay.clear（）；
}
公共图书馆
{
hand.add（thisDeck.drawRandomCard（））；
}
public int getPlayerType（）
{
返回播放类型；
}
}
导入java.util.ArrayList；
导入java.util.Random；
公务舱甲板
{
私人卡这张卡；
私人露天甲板；
私有数组列表颜色；
私有数组列表值；
专用随机发生器；
公共甲板（）
{
deck=newarraylist（）；
随机生成器=新随机（）；
初始化颜色（）；
initalizeValues（）；
createDeck（）；
}
私有无效初始颜色（）
{
颜色=新的ArrayList（）；
颜色。添加（“红色”）；
颜色。添加（“黄色”）；
颜色。添加（“绿色”）；
颜色。添加（“蓝色”）；
}    
私有void initializeValues（）
{
值=新的ArrayList（）；
值。添加（0）；
增加（1）；
增加（2）；
增加（3）；
增加（4）；
增加（5）；
增加（6）；
增加（7）；
增加（8）；
增加（9）；
增加（10）；
增加（11）；
增加（12）；
增加（13）；
增加（14）；
}
公共void createDeck（）
{
for（int thisValue:values）
{
如果（thisValue==0）
{
for（字符串thisColor:colors）
{
thisCard=新卡（thisColor，thisValue）；
卡片组。添加（此卡片）；
}
}
如果（thisValue>=1&&thisValue=10&&thisValue这个答案是不完整的，因为代码通常是一团糟的，几乎可以肯定还有其他问题。也就是说，
堆栈溢出错误的原因是你的
游戏
构造函数创建了一个
玩家
对象，而你的
玩家
构造函数创建了一个
玩家
对象一个
Game
对象。此错误可能会跳过编译，但一旦运行此代码，它就会爆炸

public Game() {
    player1 = new Player(1,0);   // create a new Player
    player2 = new Player(2,1);
    player3 = new Player(3,1);
    thisDeck = new Deck();
    currentCard = null;
    startGame();
}

public Player(int pPlayerID, int pPlayerType) {
    playerID = pPlayerID;
    playerType = pPlayerType;
    thisDeck = new Deck();
    thisGame = new Game();           // create a new Game (really??)
    hand = new ArrayList<Card>();
    handToPlay = new ArrayList<Card>();
}

公共游戏（）{
player1=新玩家（1,0）；//创建新玩家
player2=新玩家（2,1）；
player3=新玩家（3,1）；
此甲板=新甲板（）；
currentCard=null；
startGame（）；
}
公共播放器（int-pPlayerID，int-pPlayerType）{
playerID=pPlayerID；
playerType=pPlayerType；
此甲板=新甲板（）；
thisGame=新游戏（）；//创建新游戏（真的吗？？）
hand=newarraylist（）；
handToPlay=newarraylist（）；
}
您能发布您的
main
方法（以及错误堆栈跟踪）吗？我们使用的IDE隐藏了main方法（Blu
public Game() {
    player1 = new Player(1,0);   // create a new Player
    player2 = new Player(2,1);
    player3 = new Player(3,1);
    thisDeck = new Deck();
    currentCard = null;
    startGame();
}

public Player(int pPlayerID, int pPlayerType) {
    playerID = pPlayerID;
    playerType = pPlayerType;
    thisDeck = new Deck();
    thisGame = new Game();           // create a new Game (really??)
    hand = new ArrayList<Card>();
    handToPlay = new ArrayList<Card>();
}