《Android游戏开发详解》——第2章，第2.21节对象和基本类型的分组

2.21　对象和基本类型的分组
Android游戏开发详解
Java允许我们把对象和基本类型组织到一起。我们常见的有两种对象，可以用来进行分组，它们是数组和列表。

2.21.1　数组
要表示某种类型的一个数组（或组），我们使用方括号。例如，如果想要整数的一个数组，可以像下面这样声明。

int[] numbers = new int[5];

上面例子中的数字5，表示名为numbers的数组应该有多大。正如上面所声明的，numbers将能够容纳5个整数值。要描述数组的样子，我们可以画一个表，如图2-28所示。

一开始，数组将会有默认值（创建整数数组的时候，默认值是0）。Java允许我们直接为每个索引（或位置）分配数值。数组索引是基于0的，就像字符串中的字符一样。数组的赋值语法如下所示。

numbers[0] = 5;
numbers[1] = 10;
numbers[2] = 15;
numbers[3] = 20;
numbers[4] = 25;

numbers数组将会如图2-29所示。

我们可以使用完全相同的语法来获取这些值。举例如下。

int sum = numbers[0] + numbers[1] + numbers[2] + numbers[3] + numbers[4];
System.out.println(sum) 　　　　// will print 75

数组也有缺点。一旦创建了数组，就不能改变其大小。为什么会有这个问题呢？想象一下，你在开发一个射击游戏，其中每次玩家点击鼠标左键，就会有一个Bullet对象添加到一个数组中（表示所有已经发射的子弹）。我们事先不知道需要多少个Bullet。某些玩家可能使用42颗子弹。其他的玩家可能使用刀和手榴弹，甚至不开一枪就完成了关卡。在这种情况下，使用ArrayList通常会更好，它允许我们动态地调整大小以放入更多的对象。

2.21.2　ArrayLists
ArrayLists比数组更加常用，并且你应该知道如何使用它们（以及如何用好它们）。要使用ArrayList，必须首先导入它。

import java.util.ArrayList
创建ArrayLists，就像创建任何其他的对象一样。

ArrayList playerNames = new ArrayList();
我们使用add()方法向一个ArrayList对象中插入对象。

playerNames.add(“Mario”);
playerNames.add(“Luigi”);
...
playerNames.add(“Yoshi”);
你可以看到，这是String对象的一个ArrayList。你可以调用get()方法，使用基于0的索引（注意，用于数组的[]对于ArrayLists无效）从一个ArrayList获取一个对象（在这个例子中，是一个String对象）。

playerNames.get(2); 　　　　// will retrieve “Luigi” (kind-of)
理论上讲，我们可以在一个单个的ArrayList中，放置所有的各种类型的对象，而不管其类型是什么；然而，这不是很有用，因为一旦你这么做了，可能不知道某个位置（如索引152）具体是什么类型的对象。如果不知道它是什么类型的对象，你就不知道它有什么方法。看如下所示的例子。

someArrayList.get(152); 　　　　// What kind of object is this?

我们从someArrayList提取出第153个对象（记住，索引是基于0的）。问题在于，我们对这个对象一无所知。它可能是一个可口的Sushi对象，又或者甚至是一个危险的Bomb。如果我们这样编写代码，想象一下后果。

Monster hungryOne = new Monster();
Object unknown = someArrayList.get(152); 　　// The Object is actually a Bomb
hungryOne.eat(unknown); 　　　　　　　　　　// hungryOne thinks it’s Sushi
// Boom!

实际上，Java允许我们通过添加标志，来限制ArrayLists只保存某一种类型的对象。

ArrayList<String> playerNames = new ArrayList<String>();
playerNames.add(“Mario”); 　　　　// Works!
Bomb b = new Bomb();
playerNames.add(b); 　　　　　　// Gives type-mismatch error

现在，我们知道从playerNames获取的任何对象都是一个String，并且我们可以在其上调用String方法。

// Any object from playerNames will always be a String
String nameZero = playerNames.get(0);
System.out.println(nameZero.length());

2.21.3　对基本类型使用ArrayList
不能直接将基本数据类型插入到一个ArrayList中。实际上，如下所示的代码是不允许的。

ArrayList<int> numbers = new ArrayList<int>(); // not allowed

要绕开这个限制，可以直接使用一个内建的包装类，即每种基本数据类型的对象版本。这包括int所对应的Integer，char所对应的Character，等等。要做到这点，直接创建该ArrayList并声明包装类作为其类型。

ArrayList<Integer> numbers = new ArrayList<Integer>();

这个ArrayList最初的大小为0。

System.out.println(numbers.size()); 　　// Prints zero

接下来，直接调用add()方法，并且传入想要放到ArrayList中的int值。这些值将会自动地包装到一个Integer对象中。

numbers.add(2);
numbers.add(3);
numbers.add(1);

此时，ArrayList看上去如图2-30所示（注意，其长度动态地增长了）。

你可以调用get()方法，传入想要的值的索引，从而获取基本类型值。例如，要取回数字3，让ArrayList给出位于索引1的值。这个值会自动转换为一个int(从包装的Integer对象)，因此，你可以将它存储到一个int变量中。
``
int myNum = numbers.get(1);
System.out.println(myNum); 　　// Prints 3

**2.21.4　对ArrayList使用循环**
在亲眼见到ArrayList的应用之前，你很难认识到它有多么强大，因此，让我们来尝试一个例子。

我们将编写包含了2个类的一个简单的程序。第一个类是我们的进入点，其中，我们存储了main方法并且创建了ArrayList。第二个类将是表示人的一个定制类。

首先，创建一个名为Groups的、新的Java项目。其中，创建一个名为ListTester的新的类，并且给其一个main方法，如程序清单2.25所示。

程序清单2.25　ListTester.java

01　public class ListTester {
02
03　　　　public static void main(String[] args) {
04　　　　
05　　　　}
06
07　}

现在，在同一项目中创建第二个类并将其命名为Person。添加如下所示的变量和方法（参见程序清单2.26）。

程序清单2.26　Person.java

01　public class Person {
02　　　　
03　　　　private String name;
04　　　　private int age;
05
06　　　　public void initialize(String name, int age) {
07　　　　　　　　this.name = name;
08　　　　　　　　this.age = age;
09　　　　}
10
11　　　　public void describe() {
12　　　　　　　　System.out.println("My name is " + name);
13　　　　　　　　System.out.println("I am " + age + " years old");
14　　　　}
15
16　}
``
Person类描述了一个新的Person对象的蓝图。特别是，它表明了一个Person对象的状态将由两个实例变量来描述，即name和age。我们没有给name和age默认值，并且，必须调用initialize()方法来提供这些值。一旦Person对象有了一个name和age，我们就可以调用describe()方法，以易于理解、可读的形式打印出这些信息。让我们回到ListTester并且确保可以做到这一点。

程序清单2.27　ListTester.java（更新版本）

1　public class ListTester {
2
3　　　　public static void main(String[] args) {
4　　　　　　　　Person p = new Person();
5　　　　　　　　p.initialize("Marty", 40);　　
6　　　　　　　　p.describe();
7　　　　}
8
9　}

我们来一行一行地看一看程序清单2.27：首先创建了Person类的一个名为p的新实例。此时，p有两个实例变量：name和age。这些变量还没有初始化。

接下来，我们调用了initialize()方法，它接受两个值：一个String和一个整数。initialize()方法将会接受这两个值，并且将其赋值给实例变量。

现在，两个实例变量已经初始化了，我们可以通过调用describe()来要求Person对象描述自己。结果如下所示。

My name is Marty
I am 40 years old

现在，我们创建多个Person对象并且将它们组织到一个ArrayList中。修改ListTester类，使其如程序清单2.28所示。

程序清单2.28　创建ArrayList并添加第一个循环

01　import java.util.ArrayList;
02　import java.util.Random;
03
04　public class ListTester {
05
06　　　　public static void main(String[] args) {
07　　　　　　
08　　　　　　　　ArrayList<Person> people = new ArrayList<Person>();
09　　　　　　　　Random r = new Random();
10　　　　　　
11　　　　　　　　for (int i = 0; i < 5; i++) {
12　　　　　　　　　　　　Person p = new Person();
13　　　　　　　　　　　　p.initialize("Person　#" + i, r.nextInt(50));
14　　　　　　　　　　　　people.add(p);
15　　　　　　　　}
16　　　　}
17
18　}

在程序清单2.28中，我们创建了一个新的、名为people的ArrayList，以及一个新的名为r的Random对象。然后，开始了一个for循环，它将运行5次。循环每迭代（重复）一次，我们就创建一个名为p的新的Person对象。用相应的名称（Person #i，其中i从0到4）和一个随机生成的年龄值，来为该Person初始化实例变量。最后，我们把新创建的Person对象添加到ArrayList中（第14行）。循环重复，创建了一个全新的Person，初始化它并且再次添加它。

注意如下所示的代码行。

Person p = new Person();

在循环中创建的任何变量，都只在其相同的迭代中有效，这意味着，该变量仅限于在循环的当前迭代中存在。因此，我们可以在循环的每一次重复中复用变量名p。

每次调用上面的代码，我们都用变量名p创建了一个新的Person。然后，将临时变量p中保存的值，存储到较为持久的、名为people的ArrayList中，以便随后在代码中可以引用每一个新创建的Person对象，而不需要为它们中的每一个分配一个唯一的变量名。

为了看到这是如何工作的，我们可以尝试再次迭代循环，并且调用describe()方法，如程序清单2.29所示（第17行到第20行）。

程序清单2.29　添加第2个循环

01　import java.util.ArrayList;
02　import java.util.Random;
03
04　public class ListTester {
05
06　　　　public static void main(String[] args) {
07　　　　　　
08　　　　　　　　ArrayList<Person> people = new ArrayList<Person>();
09　　　　　　　　Random r = new Random();
10　　　　　　
11　　　　　　　　for (int i = 0; i < 5; i++) {
12　　　　　　　　　　　　Person p = new Person();
13　　　　　　　　　　　　p.initialize("Person　#" + i, r.nextInt(50));
14　　　　　　　　　　　　people.add(p);
15　　　　　　　　}
16　　　　　　
17　　　　　　　　for (int i = 0; i < people.size(); i++) {
18　　　　　　　　　　　　Person p = people.get(i);
19　　　　　　　　　　　　p.describe();
20　　　　　　　　}
21
22　　　　}
23
24　}

最终的输出如下所示（年龄可能不同，因为是随机生成的）。

My name is Person　#0
I am 29 years old
My name is Person　#1
I am 1 years old
My name is Person　#2
I am 4 years old
My name is Person　#3
I am 21 years old
My name is Person　#4
I am 47 years old

你可能会问，为什么要将第17行到第20行的循环运行people.size()次而不是5次？两个值是相同的，并且任何一个解决方案都会产生相同的输出；然而，上面的例子是一个更加灵活的循环，因为它并不需要把循环运行的次数直接编码。根据ArrayList people的大小，第二个for循环将运行相应的次数。这意味着，我们可能需要将上一个循环（即向ArrayList添加对象的那个循环）运行的次数从5修改为8，而下面的循环则不需要修改，因为people.size()也会增加为8。

程序清单2.30　迭代8次

01　　　　import java.util.ArrayList;
02　　　　import java.util.Random;
03
04　　　　public class ListTester {
05
06　　　　　　　　public static void main(String[] args) {
07　　　　　　
08　　　　　　　　　　　　ArrayList<Person> people = new ArrayList<Person>();
09　　　　　　　　　　　　Random r = new Random();
10　　　　　　
11　　　　　　　　　　　　//for (int i = 0; i < 5; i++) {
12　　　　　　　　　　　　for (int i = 0; i < 8; i++) {　　
13　　　　　　　　　　　　　　　　Person p = new Person();
14　　　　　　　　　　　　　　　　p.initialize("Person　#" + i, r.nextInt(50));
15　　　　　　　　　　　　　　　　people.add(p);
16　　　　　　　　　　　　}
17　　　　　　　　　　　　// people.size() is now 8!
18　　　　　　　　　　　　for (int i = 0; i < people.size(); i++) {
19　　　　　　　　　　　　　　　　Person p = people.get(i);
20　　　　　　　　　　　　　　　　p.describe();
21　　　　　　　　　　　　}
22
23　　　　　　　　}
24
25　　　　}

最终输出如下所示（年龄可能不同，因为是随机生成的）。

My name is Person　#0
I am 27 years old
My name is Person　#1
I am 27 years old
My name is Person　#2
I am 20 years old
My name is Person　#3
I am 28 years old
My name is Person　#4
I am 5 years old
My name is Person　#5
I am 49 years old
My name is Person　#6
I am 2 years old
My name is Person　#7
I am 26 years old

上面的示例展示了如何使用循环快速地创建多个对象，并将它们组织到一个ArrayList中。我们还学习到，可以通过一个for循环快速遍历一个ArrayList的所有成员并调用其方法。