java从另一个对象中访问对象数据

我最近开始学习java，大部分情况下都很顺利。为了帮助理解我正在学习的东西，我决定写一个纸牌游戏引擎。我使用我认为合适的抽象和封装方法来构建card and deck类。但是，在构建dealer类时，我遇到了一个问题，我不知道如何从dealer类中访问卡类数据。从deck类我可以访问card类，但一旦我访问dealer类，我就不知道如何访问封装在2个类中的数据

以下是我迄今为止所拥有的，虽然解决问题的代码很受欢迎，但如果有人能为我指出文档或书籍的方向，帮助我更好地理解我正在经历的事情，我将不胜感激

我只是想说清楚。我希望能够访问与数据组数组中各个卡相关的数据，例如来自dealer类的实例变量值。我知道，如果我从println语句中引用一张卡片，它将调用cards-to-string方法。但我要找的是卡的实际数据

最后一个类只是我用来测试我编写的方法的东西

   import java.util.*;
   public class Card {

        public Card() {
            suit = 0;
            value = 0;
            setName(value);                             
        }

        public Card(int cSuit, int cValue) {
            suit = cSuit;
            value = cValue;
            setName(cValue);
        }

        public String getNewCard() {
                suit = rgen.nextInt(4)+1;
            value = rgen.nextInt(13)+1;
            setName(value);

            return name +" of " +getSuitAsString();             
        }

        public int getValue() {
            return value;
        }

        public int getSuit() {
            return suit;
        }

        public String getName() {
            setName(value);
            return name;
        }

        public String getName(int val) {
            setName(val);
            return name;
        }

        public String getSuitAsString() {

            switch(suit) {
            case 1: return "Diamonds";
            case 2: return "Hearts";
            case 3: return "Spades";
                        case 4: return "Clubs";
                      default: return null;
            }
        }

        public String getSuitAsString(int cSuit) {
            switch (cSuit) {
                case 1: return "Diamonds";
            case 2: return "Hearts";
            case 3: return "Spades";
                    case 4: return "Clubs";
                default:return null;
            }
        }

        public String toString() {
            return name +" of "+ getSuitAsString();
        }

        private void setName(int value) {
            switch (value) {
            case 0 : name = "null";
            break;
            case 1 : name =  "Ace";
            break;
            case 2 : name =  "Two";
            break;
            case 3 : name =  "Three";
            break;
            case 4 : name =  "Four";
            break;
            case 5 : name =  "Five";
            break;
            case 6 : name =  "Six";
            break;
            case 7 : name =  "Seven";
            break;
            case 8 : name =  "Eight";
            break;
            case 9 : name =  "Nine";
            break;
            case 10 : name = "Ten";
            break;
            case 11: name =  "Jack";
            break;
            case 12 : name = "Queen";
            break;
            case 13 : name = "King";
            break;
            }


        }

    private int suit;
    private String name;
    private int value;


    private Random rgen = new Random();
    }
    import java.util.Random;


    public class Deck {

    //Constructor assembles an initial deck of 52 cards in order by suit.
    //Array element [0] is never used.
        public Deck(){
            int cards = 1;
            int cardsPerSuit = 13;
            int suits = 4;
            while(cards < DECK_ARRAY_SIZE){
                for(int i = 1; i <= suits ; i++){
                    for(int j = 1; j <= cardsPerSuit; j++){
                    deck[cards++] = new Card(i , j);


                }
            }
        }   
    }

    //  Constructor creates and empty deck of 53 indexes set to null.
    //  Array element [0] is never used.
        public Deck(int deckArraySize){
            for(int i = 1; i < deckArraySize ; i++){
                deck[i] = new Card();
                }
        }

        public Deck(int suitCount , int cardsPerSuit , int deckArraySize){
    //  Constructor for special deck configuration.     
    }



        public void shuffle(){
            int SHUFFLE_COUNT = 100000;
            int arrayPos1 = 0;
            int arrayPos2 = 0;
            int count = 0;

            while(count < SHUFFLE_COUNT){
                Card card1 = deck[rgen.nextInt(DECK_ARRAY_SIZE)];
                if(card1 == deck[0]) card1 = deck[1];//This prevents the NullPointerException error.broke the always use braces rule.
                Card card2 = deck[rgen.nextInt(DECK_ARRAY_SIZE)];
                if(card2 == deck[0]) card2 = deck[52];//This prevents the NullPointerException error.broke the always use braces rule.



                for(int i = 1; i < DECK_ARRAY_SIZE; i++){
                    for (int j = 1; j < DECK_ARRAY_SIZE; j++){
                        if (deck[i].equals(card1)){
                            arrayPos1 = i;
                            if (deck[j].equals(card2)){
                            arrayPos2 = j;

                            }
                        }
                    }   
                    Card temp = deck[arrayPos1];
                    deck[arrayPos1] = deck[arrayPos2];
                    deck[arrayPos2] = temp;
                    count++;    

                }       

        }           

    }


    //  Gets the top card of the deck.
        public Card getTopCard(){
            Card topCard = deck[1];
            return topCard;

        }
    //  Gets a card at specified index. 
        public Card getCardAt(int cardAtPos){
            Card cardAt = deck[cardAtPos];  
            return  cardAt; 

        }


    //This method makes an implicit call to the Card classes toString method when string manipulation is performed .    
    //This is done by the compiler automatically.
        public void getDeckInfo(){
            for(int i = 1; i < DECK_ARRAY_SIZE ; i++){
            System.out.print(i +" ");
            System.out.println(deck[i]);
            }
        }


        public String toString(){
    //      getDeckInfo();
            return "Nothing to see here, move along.";

        }

    private Random rgen = new Random();
    public static final int DECK_ARRAY_SIZE = 53;
    private Card[] deck = new Card[DECK_ARRAY_SIZE];

    }
    public class Dealer {

    public Dealer(){
        playDeck = new Deck();
        discardStack = new Deck(Deck.DECK_ARRAY_SIZE);
    }

    public int getDeckCardCount(){
// this count should go down anytime a card is dealt to a player 
        return deckCardCount;
    }

    public int getDiscardCount(){
// this count should go up anytime a card is removed from the deck or from play.        
        return discardCount;
    }

    public void dealCards(){

// should be self explanatory.      
    }

    public void shuffle(){
// need to make sure that shuffle compensates for cards removed 
// from deck and move cards to the front of the array before the shuffle.
// make sure that the empty indexes at the end of the array are not included in the shuffle.
// also need a shuffle method for shuffles at the end of the game. or just 
// throw out he deck and get a new deck.... 
// maybe pass the remaining cards in the deck to the shuffle method .

    }

    public String toString(){

        return "Nothing to see here , move along.";
}
public Deck playDeck;   
public Deck discardStack;
private int deckCardCount;
private int discardCount;
    }

public class CardTest  {

public static void main(String[] args){


    Card singleCard = new Card();
    Deck deck = new Deck();
    Deck playDeck = new Deck();
    Deck discardStack = new Deck(53); 
    Dealer dealer = new Dealer();

System.out.println("value: "+singleCard.getValue());
System.out.println("Name: "+singleCard.getName());
System.out.println("Suit: "+singleCard.getSuitAsString());
System.out.println("Card to string: "+singleCard.toString());
System.out.println("New card: " +singleCard.getNewCard());
System.out.println("New card: " +singleCard.getNewCard());
System.out.println("New card: " +singleCard.getNewCard());
System.out.println("Pass a 4 to the getSuitAsString() method:    "+singleCard.getSuitAsString(4));
System.out.println("Pass a 12 to the getName() method: "+singleCard.getName(12));
deck.getDeckInfo();
System.out.println("Top card is: "+deck.getTopCard());

System.out.println("Shuffling...");
int count =0;
while(count < 500){
dealer.playDeck.shuffle();
discardStack.shuffle();
count++;
}

deck.getDeckInfo();
System.out.println("Top card is: "+deck.getTopCard());
System.out.println("Card at position ??: "+deck.getCardAt(5));
playDeck.getDeckInfo();
discardStack.getDeckInfo();
playDeck.shuffle();
playDeck.getDeckInfo();
discardStack.shuffle();
discardStack.getDeckInfo();
dealer.playDeck.getDeckInfo();
dealer.playDeck.shuffle();
System.out.println("Shuffling...");
dealer.playDeck.getDeckInfo();
System.out.println(dealer.playDeck.getCardAt(5));
System.out.println(dealer.discardStack.getCardAt(5));   


}

import java.util.*；
公务舱卡{
公共卡（）{
西服=0；
数值=0；
设置名称（值）；
}
公共卡（int cSuit，int cValue）{
西服=西服；
值=C值；
setName（cValue）；
}
公共字符串getNewCard（）{
套装=rgen.nextInt（4）+1；
值=rgen.nextInt（13）+1；
设置名称（值）；
返回“+GetSuiteAsString（）的名称+”；
}
public int getValue（）{
返回值；
}
公共int getSuit（）{
反诉；
}
公共字符串getName（）{
设置名称（值）；
返回名称；
}
公共字符串getName（int val）{
集合名（val）；
返回名称；
}
公共字符串getSuiteAsString（）{
开关（套装）{
案例1：退回“钻石”；
案例2：返回“红心”；
案例3：返回“黑桃”；
案例4：返回“俱乐部”；
默认值：返回null；
}
}
公共字符串GetSuiteAsString（int-cSuit）{
开关（cSuit）{
案例1：退回“钻石”；
案例2：返回“红心”；
案例3：返回“黑桃”；
案例4：返回“俱乐部”；
默认值：返回null；
}
}
公共字符串toString（）{
返回“+GetSuiteAsString（）的名称+”；
}
私有void setName（int值）{
开关（值）{
案例0:name=“null”；
打破
案例1:name=“Ace”；
打破
案例2:name=“2”；
打破
案例3:name=“三”；
打破
案例4:name=“四”；
打破
案例5:name=“五”；
打破
案例6:name=“六”；
打破
案例7:name=“七”；
打破
案例8:name=“八”；
打破
案例9:name=“九”；
打破
案例10:name=“十”；
打破
案例11:name=“Jack”；
打破
案例12:name=“Queen”；
打破
案例13:name=“King”；
打破
}
}
私人诉讼；
私有字符串名称；
私有int值；
private Random rgen=new Random（）；
}
导入java.util.Random；
公务舱甲板{
//构造器按顺序组装52张卡片的初始牌组。
//从未使用数组元素[0]。
公共甲板（）{
int卡=1；
int cardsPerSuit=13；
int=4；
while（卡片<卡片组\阵列\大小）{
对于（inti=1；i我有一种感觉，我不理解某些东西，但它不是像将此方法放在Deck类中那样简单吗：

public Card[] getCards() {
    return deck;
}

现在，您的
经销商可以调用
aDeck.getCards（）
并对其执行任何操作

例如，我将此代码放在
Dealer
类中，它编译得很好：

public Dealer() {
    Deck deck = new Deck();
    for (Card card : deck.getCards()) {
        int suit = card.getSuit();
        int value = card.getValue();
    }
}

我有一种感觉，我不理解一些东西，但它不是像将此方法放入Deck类中那样简单吗：

public Card[] getCards() {
    return deck;
}

现在，您的
经销商可以调用
aDeck.getCards（）
并对其执行任何操作

例如，我将此代码放在
Dealer
类中，它编译得很好：

public Dealer() {
    Deck deck = new Deck();
    for (Card card : deck.getCards()) {
        int suit = card.getSuit();
        int value = card.getValue();
    }
}

模型还不错，问题在于你的第二个和第三个Deck构造函数。第一个构造函数确保了合法的Deck，而另外两个构造函数创建了一个Deck，你可以在下面的示例代码中从头开始

问问自己，为什么你会需要一个“特殊构造”，如果你需要的话。为什么你不能从你的第一个牌组构造器创建的一个合适的52张牌组开始，然后从那里开始工作。例如，移除你不需要的牌

最后，OO理念要求实例在构建后永远不要处于无效状态。拥有构造函数Card（）是不够的，因为你需要知道你想要得到什么样的卡片。6张红心卡片。新的（6，“红心”）是一个有效的ctor
模型还不错，问题在于你的第二个和第三个甲板构造函数。第一个构造函数确保一个合法的甲板，而另两个则创建一个甲板，你可以在下面的示例代码中从头开始

问问自己，为什么你会需要一个“特殊构造”，如果你需要的话。为什么你不能从你的第一个牌组构造师创建的一个合适的52张牌组开始，然后从