Question

我刚开始学习Java - 我的学习资源是：Deitel Java：如何编程。

请看这段代码：

1    public class DeckOfCards
2    {
3       private Card[] deck; // array of Card objects
4       private int currentCard; // index of next Card to be dealt (0-51)
5       private static final int NUMBER_OF_CARDS = 52; // constant # of Cards
6       // random number generator
7       private static final Random randomNumbers = new Random();
8   
9     // constructor fills deck of Cards
10    public DeckOfCards()
11  {
12   String[] faces = { "Ace", "Deuce", "Three", "Four", "Five", "Six", 
13    "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };
14          String[] suits = { "Hearts", "Diamonds", "Clubs", "Spades" };
15    
16          deck = new Card[ NUMBER_OF_CARDS ]; // create array of Card objects
17          currentCard = 0; // set currentCard so first Card dealt is deck[ 0 ]
18    
19          // populate deck with Card objects
20          for ( int count = 0; count < deck.length; count++ ) 
21             deck[ count ] = 
22                new Card( faces[ count % 13 ], suits[ count / 13 ] );
23       } // end DeckOfCards constructor

我的问题是我无法理解为什么程序会两次构建deck数组？

第一次（第16行），它可以正常，因为程序描述它（创建卡对象数组），但为什么第二次（第21-22行）？程序员不会在不使用new的情况下使用此表达式，如下所示：

deck[ count ] = Card( faces[ count % 13 ], suits[ count / 13 ] );

如果需要，这是Card类：

public class Card 
{
   private String face; // face of card ("Ace", "Deuce", ...)
   private String suit; // suit of card ("Hearts", "Diamonds", ...)

   // two-argument constructor initializes card's face and suit
   public Card( String cardFace, String cardSuit )
   {
      face = cardFace; // initialize face of card
      suit = cardSuit; // initialize suit of card
   } // end two-argument Card constructor

   // return String representation of Card
   public String toString() 
   { 
      return face + " of " + suit;
   } // end method toString
} // end class Card

Answer 1

没有。数组未创建两次。它被创建一次然后被填充。

在此声明中，程序员创建数组并将分配给名为deck的引用：

 deck = new Card[ NUMBER_OF_CARDS ];

在以下声明中，程序员为数组中的每个组件分配值：

deck[ count ] = new Card( faces[ count % 13 ], suits[ count / 13 ] );

此数组包含Card类型的组件，在最后一条语句中，程序员正在创建类型为Card的对象，并将它们分配给数组中的每个组件。

Answer 2

第二次没有构建数组，而是用Card对象填充它。

在第16行，它实例化了一个数组，但它的对象具有对象的所有默认值＆gt;的空即可。

deck[ count ] = Card( faces[ count % 13 ], suits[ count / 13 ] );

此行创建一个新的Card对象，对这个新创建的对象的引用存储在deck[count]数组单元格中。

Answer 3

我们只创建一次数组。我们第一次声明一个数组，但是数组中的每个单独的条目都是null，第二次我们分配数组中的每个条目来引用一个卡对象。

Answer 4

第16行＆＃34;程序员＆＃34;这实际上是本书的作者，

deck = new Card[ NUMBER_OF_CARDS ];

正在初始化一个数组，其长度为静态变量NUMBER_OF_CARDS的值，即52。在第21行和第22行，作者没有初始化数组，而是初始化数组中的元素，这些元素是Card类型的对象。

deck[ count ] = new Card( faces[ count % 13 ], suits[ count / 13 ] );

ps我喜欢那本书

为什么这个数组构造了两次？

4 个答案: