如何编写一个方法以将2个不同的数组返回到另一个类？

Question

我有一个4类的代码，甲板，卡，玩家和测试。

我的想法是创建一个21点游戏，玩家有你的“手”与甲板上提供的卡。我的代码工作正常，但是我只想要一个方法返回两个不同的数组。

我的代码简历：

牌:一张牌(价值，花色)

套牌：创建一个包含 52 张牌的牌阵列。一个类的方法提供Cards（）来获取玩家的卡。

玩家：一类有牌阵列的“手牌”

问题在哪里？

看“Deck”类，我使用了2个方法，provideCards()和provideNewCards()，这两个方法是相同的，但是为每个玩家返回不同的数组。我不能在我的方法中使用provide cards()" ArrayList player = new ArrayList

我的代码:

甲板等级:

    package jamilzin.cassino;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;

 // /*
   public class Deck {
    private ArrayList<Card> deck = new ArrayList<>();
    public  ArrayList<Card> playerA = new ArrayList<>();
    public  ArrayList<Card> playerB = new ArrayList<>();

    private ArrayList<String> suits = new ArrayList(Arrays.asList(" Diamonds", " Clubs", " Spades", " Hearts"));
    Random gerador = new Random();
    
    public Deck(){
  for(int j=0; j<suits.size(); j++){ // Idea: create a 13 cards for each suits
      for(int i=0; i<13; i++){ 
 deck.add(new Card((i + 1), suits.get(j))); 
    } // for i
  } // for j
   Collections.shuffle(deck); // randomize the deck
} // deck()
    
public ArrayList<Card> provideCards(){
   int  number = gerador.nextInt(52);
   while(deck.get(number)==null){ 
        number = gerador.nextInt(52);}
   Card card = (deck.get(number));
  playerA.add(card);
   deck.set(number, null);
        return  playerA ;} 

public ArrayList<Card> provideNewCards(){
   int  number = gerador.nextInt(52);
   while(deck.get(number)==null){ 
        number = gerador.nextInt(52);}
   Card card = (deck.get(number));
  playerB.add(card);
   deck.set(number, null);
        return  playerB ;} 


@Override
public String toString(){
    return deck.toString();
    }   
   } 

卡类：

package jamilzin.cassino;

public class Card {
    
    private String suit;
    private int value;
    
    Card(int value, String suit){
    this.value = value;
    this.suit = suit;
    }

    public String getSuit() {
        return suit;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
     return getValue() + getSuit();
    //return Integer.toString(getValue());
}
}

玩家等级:

package jamilzin.cassino;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.*;
public class Player {
 ArrayList<Card>  hands = new ArrayList<>();

 
   public Player(){
this.hands = new ArrayList<>();
    }

   
    public ArrayList<Card> getHands() {
    return hands;
    }
    
    public void setHands(ArrayList<Card> hands) {
        this.hands = hands;
    }
}

测试类：

package jamilzin.cassino;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Cassino {
    
    public static void main(String[] args) {
 Deck deckMaster = new Deck();
Player PlayerA = new Player();
Player PlayerB = new Player();
for(int i=1;i<=5;i++){
 PlayerA.setHands(deckMaster.provideCards());}
for(int i=1;i<=5;i++){
PlayerB.setHands(deckMaster.provideNewCards());}

        System.out.println(PlayerA.getHands());
        System.out.println(PlayerB.getHands());
        
        System.out.println(deckMaster);
    }
 }

类测试结果：运行项目结果

Answer 1

枚举套装

public enum Suit {
    DIAMONDS, CLUBS, SPADES, HEARTS
}

卡西诺

public class Cassino {
    public static void main(String[] args) {
        Blackjack game = new Blackjack(2);

        System.out.println(game);
    }
}

21点

public class Blackjack {
    private final Player[] players;
    private final Deck deck;

    public Blackjack(int player) {
        this.players = createPlayer(player);
        this.deck = new Deck();
    }

    public Player[] createPlayer(int player){
        Player[] players = new Player[player];
        for (int i = 0; i < player; i++) {
            List<Card> cards = new ArrayList<>();
            for (int j = 0; j < 5; j++) {
                cards.add(deck.provideCard());
            }
            players[i] = new Player(cards);
        }
        return players;
    }

    public Player[] getPlayers() {
        return players.clone();
    }

    public Deck getDeck() {
        return deck;
    }

    @Override
    public String toString() {
        return "Blackjack{" +
                "players=" + Arrays.toString(players) +
                ", deck=" + deck +
                '}';
    }
}

甲板

public class Deck {
    private final LinkedList<Card> deck;

    public Deck() {
        Suit[] suits = Suit.values();
        List<Card> cards = new ArrayList<>();
        for (Suit suit : suits) { // Idea: create a 13 cards for each suits
            for (int j = 0; j < 13; j++) {
                cards.add(new Card((j + 1), suit));
            }
        }
        Collections.shuffle(cards); // randomize the deck
        deck = new LinkedList<>(cards) {
        };
    } // deck()

    public Card provideCard() {
        return deck.pollFirst();
    }

    @Override
    public String toString() {
        return "Deck{" +
                "deck=" + deck +
                '}';
    }
}

卡

    public class Card {
    private final Suit suit;
    private final int value;

    Card(int value, Suit suit) {
        this.value = value;
        this.suit = suit;
    }

    public Suit getSuit() {
        return suit;
    }

    public int getValue() {
        return value;
    }

    @Override
    public String toString() {
        return getValue() + getSuit().toString();
        //return Integer.toString(getValue());
    }
}

选手

    public class Player {
    List<Card> hand;

    public Player(List<Card> cards) {
        this.hand = cards;
    }


    public List<Card> getHand() {
        return hand;
    }

    public void setHand(List<Card> hand) {
        this.hand = hand;
    }

    public void addToHand(Card card){
        this.hand.add(card);
    }

    @Override
    public String toString() {
        return "Player{" +
                "hand=" + hand +
                '}';
    }
}

1. 尽可能为变量和方法使用更通用的类型，因为如果您使用安装的LinkedList，它不会改变逻辑。
2. 你不需要随机的，因为你的牌已经被刷掉了，所以你不需要从刷掉的牌列表中随机选择一个。相反，您应该使用显式链接列表。这将为您提供pollFirst方法，该方法轮询列表的第一个/头，并减少列表，即您的甲板
3. Suits应该是一个枚举，而不是字符串列表，因为它是一个不变的枚举。所以新的Enum很适合
4. 玩家的手不应该在玩家类中，有什么原因吗
5. 你需要更多的类来给游戏一个逻辑和类似的结构