如何使位于自己文件中的私有节点 class 对我的卡片组 class (LINKEDLIST) 可见？

Question

所以我有这个项目，基本上我的教授希望节点 class 位于一个单独的文件中，而不是在我的实际平台 class 中。结果，我的 deck class 方法不能再使用节点数据类型并且将无法工作。我的教授只给了我使用 get、set 方法的提示，以便让我的 deck class 访问位于不同文件中的节点 class。我不确定如何执行此操作，因此如果能帮助我弄清楚如何设置 get、set 方法以便我的 Deck class 可以读取它们，我们将不胜感激！

我的套牌中的代码 class:

package card;

import java.io.*;
import java.util.*;

public class Deck<Card> implements DeckInterface<Card> {
    
    
    private Node frontOfDeck; // Cannot be final due to doubling
    private int numberOfEntries; 
         
    /**
     * Creates a deck of cards whose default capacity is 52. 
    */   
    public Deck() {
        frontOfDeck = null;
        numberOfEntries = 0;
    } // end default constructor
    
    
    //sets private data member
    public void setNumOfEntries(int numberOfEntries) {
        this.numberOfEntries = numberOfEntries;
    }
    //returns number of entries
    public int getNumOfEntries() {
        return numberOfEntries; 
    }
    
       
    /** Adds a new card to this deck.
     * @return True.
     * @param aCard
    */
    public boolean add(Card aCard) {
        //Beginning of chain
        Node newNode = new Node(aCard);
        newNode.setNextNode(frontOfDeck);
        //Make new node reference rest of chain
        //frontOfDeck is nulll if chain is empty
        frontOfDeck = newNode; //New node is at beginning of chain
        numberOfEntries++;
    
    return true;
        
    } //end add
    
    
    /**
     * Sees if deck is empty
     * @return true if empty, or false if not
     */
    public boolean isEmpty() {
        return numberOfEntries == 0;
    } //end isEmpty
    
    
    public int getFrequencyOf(Card aCard) {
        int frequency = 0;
        int loopCounter = 0;
        Node currentNode = frontOfDeck;
        
        while ((loopCounter < numberOfEntries) && (currentNode != null)) {
            if (aCard.toString().trim().equals(currentNode.data.toString().trim())){
                frequency++;}
            loopCounter++;
            currentNode = currentNode.next;
        }
        
        return frequency;
        
    }
    
    public int getCardDeck(Card aCard) {
        int numCards = 0;
        int loopCounter = 0;
        Node currentNode = frontOfDeck;
        
        while ((loopCounter < numberOfEntries) && (currentNode != null)) {
            //if (aCard.equals(currentNode.data))
            numCards++;
            System.out.println(currentNode.getData());
            loopCounter++;
            currentNode = currentNode.next;
        }

        return numCards;
        
    }
    
    public Card remove() {
        Card result = null;
        if(frontOfDeck != null) {
            result = frontOfDeck.data;
            frontOfDeck = frontOfDeck.next;
            numberOfEntries--;
        }
        
        return result;
        
    }
    
    public boolean removeSpecific(Card aCard) {
        boolean result = false;
        Node nodeN = getReferenceTo(aCard);
        if (nodeN != null) {
            nodeN.data = frontOfDeck.data;
            
            frontOfDeck = frontOfDeck.next;
            numberOfEntries--;
            result = true;
        }
        
        return result;
        
    }
    
    public boolean search(Card aCard) {
        boolean found = false;
        Node currentNode = frontOfDeck;
        
        while (!found && (currentNode != null)) {
            if(aCard.equals(currentNode.data))
                found = true;
            else
                currentNode = currentNode.next;
        } //end while
        
        return found;
        
    }
    
    
    public void clear() {
        frontOfDeck = null;
    } //end clear
    
    public int getNum() {
        return numberOfEntries;
    }
    
    public Card[] toArray() {
        @SuppressWarnings("unchecked")
        Card[] result = (Card[])new Object [numberOfEntries];
        
        int index = 0;
        Node currentNode = frontOfDeck;
        while ((index < numberOfEntries) && (currentNode != null)) {
            result[index] = currentNode.data;
            index++;
            currentNode = currentNode.next;
        }
        
        return result;
        
    }

private Node getReferenceTo(Card aCard) {
        boolean found = false;
        Node currentNode = frontOfDeck;
        while (!found && (currentNode != null)) {
            if (aCard.equals((currentNode.data)))
                found = true;
            else
                currentNode = currentNode.next;
        }
        
    return currentNode;
        
    }
}

来自我的节点的代码 Class:

package card;

public abstract class NodeClass<Card> implements DeckInterface<Card> {
    
     private class Node {
      private Card data; // Entry in bag
      private Node next; // Link to next node

        private Node(Card dataValue) {
            this(dataValue, null);  
        } // end constructor
        
        private Node(Card dataValue, Node nextValue) {
            data = dataValue;
            next = nextValue;   
        } // end constructor
                
        private void setData(Card dataValue){
            data = dataValue;
        }
        
        private Card getData() {
            return data;
        } 
        
        private void setNextNode(Node nodeValue) {
            next = nodeValue;
        }
        
    } // end Node
    
}

Answer 1

正确节点Class：

package card;

/**
 *
 * @param <Card>
 
 */
class NodeClass<Card> {
    
      Card data; // Entry in bag
      NodeClass<Card> next; // Link to next node

        NodeClass(Card dataValue) {
            this(dataValue, null);  
        } // end constructor
        
        NodeClass(Card dataValue, NodeClass<Card> nextValue) {
            data = dataValue;
            next = nextValue;   
        } // end constructor
                
                void setData(Card dataValue){
                    data = dataValue;
                }
                
                Card getData() {
                    return data;
                } 
                
                NodeClass<Card> getNextNode() {
                    return next;
                }
                
                void setNextNode(NodeClass nodeValue) {
                    next = nodeValue;
                }
                
                
                
            } // end Node

正确的牌组Class：

package card;


import java.io.*;
import java.util.*;

public class Deck<Card> implements DeckInterface<Card> {
    
    
    private NodeClass frontOfDeck; // Cannot be final due to doubling
    private int numberOfEntries; 
         
    /**
     * Creates a deck of cards whose default capacity is 52. 
    */   
    public Deck() {
        frontOfDeck = null;
        numberOfEntries = 0;
    } // end default constructor
    
    
    //sets private data member
    public void setNumOfEntries(int numberOfEntries) {
        this.numberOfEntries = numberOfEntries;
    }
    //returns number of entries
    public int getNumOfEntries() {
        return numberOfEntries; 
    }
    
       
    /** Adds a new card to this deck.
     * @return True.
     * @param aCard
    */
    public boolean add(Card aCard) {
        //Beginning of chain
        NodeClass newNode = new NodeClass(aCard);
        newNode.setNextNode(frontOfDeck);
        //Make new node reference rest of chain
        //frontOfDeck is nulll if chain is empty
        frontOfDeck = newNode; //New node is at beginning of chain
        numberOfEntries++;
    
    return true;
        
    } //end add
    
    
    /**
     * Sees if deck is empty
     * @return true if empty, or false if not
     */
    public boolean isEmpty() {
        return numberOfEntries == 0;
    } //end isEmpty
    
    
    public int getFrequencyOf(Card aCard) {
        int frequency = 0;
        int loopCounter = 0;
        NodeClass currentNode = frontOfDeck;
        
        while ((loopCounter < numberOfEntries) && (currentNode != null)) {
            if (aCard.toString().trim().equals(currentNode.data.toString().trim())){
                frequency++;}
            loopCounter++;
            currentNode = currentNode.next;
        }
        
        return frequency;
        
    }
    
    public int getCardDeck(Card aCard) {
        int numCards = 0;
        int loopCounter = 0;
        NodeClass currentNode = frontOfDeck;
        
        while ((loopCounter < numberOfEntries) && (currentNode != null)) {
            //if (aCard.equals(currentNode.data))
            numCards++;
            System.out.println(currentNode.getData());
            loopCounter++;
            currentNode = currentNode.next;
        }

        return numCards;
        
    }
    
    public Card remove() {
        Card result = null;
        if(frontOfDeck != null) {
            result = (Card) frontOfDeck.data;
            frontOfDeck = frontOfDeck.next;
            numberOfEntries--;
        }
        
        return result;
        
    }
    
    public boolean removeSpecific(Card aCard) {
        boolean result = false;
        NodeClass nodeN = getReferenceTo(aCard);
        if (nodeN != null) {
            nodeN.data = frontOfDeck.data;
            
            frontOfDeck = frontOfDeck.next;
            numberOfEntries--;
            result = true;
        }
        
        return result;
        
    }
    
    public boolean search(Card aCard) {
        boolean found = false;
        NodeClass currentNode = frontOfDeck;
        
        while (!found && (currentNode != null)) {
            if(aCard.equals(currentNode.data))
                found = true;
            else
                currentNode = currentNode.next;
        } //end while
        
        return found;
        
    }
    
    
    public void clear() {
        frontOfDeck = null;
    } //end clear
    
    
    public int getNum() {
        return numberOfEntries;
    }
    
    public Card[] toArray() {
        @SuppressWarnings("unchecked")
        Card[] result = (Card[])new Object [numberOfEntries];
        
        int index = 0;
        NodeClass currentNode = frontOfDeck;
        while ((index < numberOfEntries) && (currentNode != null)) {
            result[index] = (Card) currentNode.data;
            index++;
            currentNode = currentNode.next;
        }
        
        return result;
        
    }

    
    private NodeClass getReferenceTo(Card aCard) {
        boolean found = false;
        NodeClass currentNode = frontOfDeck;
        while (!found && (currentNode != null)) {
            if (aCard.equals((currentNode.data)))
                found = true;
            else
                currentNode = currentNode.next;
        }
        
    return currentNode;
        
    }
}

卡片Class供参考：

import java.util.Objects;

public class Card {
    private String cardSuit; //declares variables as private
    private int cardValue;
    
public Card() {    
}

/**
* @param suit
* @param value
*/
public Card(String suit, int value) { 
    this.cardSuit = suit;
    this.cardValue = value;
}

//returns cardSuit
public String getCardSuit() {
    return cardSuit;
}

//sets private data member
public void setCardSuit(String cardSuit) {
    this.cardSuit = cardSuit;
}

//returns cardValue
public int getCardValue() {
    return cardValue;
}

//sets private data member
public void setCardValue(int cardValue) {
    this.cardValue = cardValue;
}

//returns class data as string
@Override
public String toString() {
    return "Card " + cardValue + " of " + cardSuit.toUpperCase();
}


@Override
public boolean equals(Object obj) {
    //check is obj are referenced
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
        Card card = (Card) obj;
            return cardValue == card.cardValue && cardSuit.equals(card.cardSuit);
}

//returns intgers 
@Override
public int hashCode() {
    return Objects.hash(cardSuit, cardValue);
}

}

如何使位于自己文件中的私有节点 class 对我的卡片组 class (LINKEDLIST) 可见？

How to make a private node class located in its own file visible to my deck class (LINKEDLIST)?

java

nodes