8.1.1. 对图书馆藏书进行建模¶

作为示例，让我们尝试在计算机程序中对一个藏书图书馆进行建模。首先，让我们创建一个 Book 类，用字段跟踪书名、作者和 ISBN 号。

public class Book
{
    private String title;
    private String author;
    private int isbn;

    public Book(String aTitle, String anAuthor, int theISBN)
    {
        this.title = aTitle;
        this.author = anAuthor;
        this.isbn = theISBN;
    }

    public String getTitle()
    {
        return title;
    }

    public String getAuthor()
    {
        return author;
    }

    public int getISBN()
    {
        return isbn;
    }
}

一旦图书被创建，我们就不需要更改这些字段中的任何一个，因此我们只需要创建取值方法（getter）。当这些字段是只读的时候，就无需 setter 方法。

接下来，我们要表示一个 书架（shelf） ，它最多能存放 50 本书。显然，我们不想创建 50 个字段来存放书，再创建 50 个取值方法和设值方法来更改它们。相反，我们将把书存储在一个书籍列表中，并提供一个向书架添加另一本书的方法。

import java.uti.*;

public class Shelf
{
    private int maxCapacity;
    private List<Book> contents;

    public Shelf()
    {
        maxCapacity = 50;
        contents = new ArrayList<Book>();
    }

    // adds a book if there is space on the shelf
    public void addBook(Book book)
    {
        if (contents.size() < maxCapacity)
        {
            contents.add(book);
        }
    }

    public List<Book> getContents()
    {
        return this.contents;
    }
}

我们还将有一个包含许多书架的图书馆：

import java.util.*;

public class Library
{
    private List<Shelf> stacks;

    public Library()
    {
        stacks = new ArrayList<Shelf>();
    }

    public void addShelf(Shelf shelf)
    {
        stacks.add(shelf);
    }
}

在接下来的各节中，我们将逐步增强这个基本设计。

8.1.2. 循环惯用法¶

"惯用法"（idiom）是一种常见的模式或表达方式。在使用 Java 编写循环时，你可能会开始看到循环使用方式中的一些常见模式。 for 循环特别适合以下情况：

• 按指定次数重复代码

• 在一系列位置上重复

• 在某个数值范围内累加答案

此外，循环常常用于在一系列值中搜索，以找到满足某个条件的第一个（或最后一个）值。

import java.util.*;

public class Library
{
    private List<Shelf> stacks;

    public Library()
    {
        stacks = new ArrayList<Shelf>();
    }

    public void addShelf(Shelf shelf)
    {
        stacks.add(shelf);
    }

    // new method
    public void createShelves()
    {
        // will add Shelf objects to our stacks
    }
}

// Create a single shelf
public void createShelves()
{
    Shelf shelf = new Shelf();
    this.stacks.add(shelf);
}

public void createShelves(int n)
{
    for (int i = 0; i < n; i++)
    {
         Shelf shelf = new Shelf();
         this.stacks.add(shelf);
    }
}

import java.util.*;

public class Shelf
{
    private int maxCapacity;
    private List<Book> contents;

    public Shelf()
    {
        maxCapacity = 50;
        contents = new ArrayList<Book>();
    }

    // other methods omitted ...

    // new method
    public boolean hasTitle(String title)
    {
        // should return true if a book with the specified title
        // is in our list of books,
        // otherwise return false
    }
}

public boolean hasTitle(String title)
{
    boolean result = false;
    for (Book book : this.contents)
    {
        if (title.equals(book.getTitle()))
        {
            result = true;
        }
    }
    return result;
}

public boolean hasTitle(String title)
{
    for (Book book : this.contents)
    {
        if (title.equals(book.getTitle()))
        {
            return true;
        }
    }
    return false;
}

public boolean hasTitle(String title)
{
    for (int i = 0; i < this.contents.size(); i++)
    {
        Book book = this.contents.get(i);
        if (title.equals(book.getTitle()))
        {
            return true;
        }
    }
    return false;
}

for (int i = 0; i < this.contents.size(); i++)
{
    Book book = this.contents.get(i);
    if (title.equals(book.getTitle()))
    {
        break;
    }
}
System.out.println("Found it!");

public boolean hasTitle(String title)
{
    for (int i = this.contents.size() - 1; i >= 0; i--)
    {
        Book book = shelfContents.get(i);
        if (title.equals(book.getTitle()))
        {
            return true;
        }
    }
    return false;
}

import java.util.*;

public class Library
{
    private List<Shelf> stacks;

    public Library()
    {
        stacks = new ArrayList<Shelf>();
    }

    public void addShelf(Shelf shelf)
    {
        stack.add(shelf);
    }

    // new method
    public int countBooksByAuthor(String author)
    {
        // ...
    }
}

public int countBooksByAuthor(String author)
{
    // declare our counter (accumulator)
    int count = 0;
    // iterate over every shelf:
    for (Shelf shelf : this.stacks)
    {
        // iterate over every book on a given shelf
        for (Book book : shelf.getContents())
        {
            // if we find a book by our desired author...
            if (book.getAuthor().equals(author))
            {
                // increase counter by 1
                count++;
            }
        }
    }
    // return our count
    return count;
}

// new method
public List<Book> getAllBooksByAuthor(String author)
{
    // declare our List
    List<Book> foundBooks = new ArrayList<Book>();

    // iterate over every shelf:
    for (Shelf shelf : this.stacks)
    {
        // iterate over every book on a given shelf
        for(Book books : shelf.getContents())
        {
            // if we find a book by our desired author...
            if (book.getAuthor().equals(author))
            {
                // add the book to our List
                foundBooks.add(book);
            }
        }
    }
    // return our list
    return foundBooks;
}

8.1.3. 再谈泛型¶

到目前为止，凡是使用变量，我们总是知道它们是什么类型。例如，每当我们使用 String 时，都会声明一个类似 String s = "Hello World"; 的变量。然而，在 Java 中有一些情况，我们需要在不知道将要处理什么数据类型的情况下创建方法——或者更准确地说，让它们适用于 任何类型 。对于这些情况，我们使用所谓的 泛型类型参数（Generic Type Parameter） 来表示我们正在处理的数据类型。

声明使用泛型类型参数的类涉及使用新的语法来引用类名。这样的类和接口，包括用于 Java 集合的那些，使用尖括号（<...>）来引用未指定的类型名，其中包含一个或多个变量（用逗号分隔）。例如，你会用 <Element> 或 <Key, Value> 来引用未指定的类型名。有时，你会看到以这种方式使用的超短变量名，如 <E> 或 <K, V>，尽管对初学者来说更长的名字更容易理解。使用这种技术时，用泛型类型实现的类或接口的名字写作 ClassName<E> 。

让我们看看一个使用泛型类型参数的类。下面的 Box 类可以存放任何类型的数据。我们将使用参数名 Content 来引用 Box 中存放的数据类型。

public class Box <Content>
{
    private Content value;

    public Box(Content newValue)
    {
        this.value = newValue;
    }

    public Content getValue()
    {
        return this.value;
    }

    public void setValue(Content newValue)
    {
        this.value = newValue;
    }
}

然后我们就可以创建一个 Box 对象。

Box<String> box1 = new Box<String>("surprise");

并不是所有 Box 对象都需要是相同的类型：

Box<String> box1 = new Box<String>("surprise");
Box<Integer> box2 = new Box<Integer>(42);

实际上， <Content> 的作用是作为将存储在 Box 中的对象类型的参数。

泛型类型提供的一个好处是在编译时检查方法实参的类型。例如，下面的代码在编译时会出错：

Box<String> box1 = new Box<String>("surprise");
box1.setValue(42);

因此，如果程序员想创建一个字符串列表，使用泛型类型将有助于保证被存储的对象确实属于正确的类型。尽管你可以创建任何类型对象的列表，但这个特定的列表只包含字符串，不包含其他任何东西。这样，使用泛型类型有助于减少编程错误的数量，从而使程序更安全、更健壮。同时，它允许我们创建更具可复用性的类，因为我们可以创建能与各种其他类协同工作的类型，而不必预先知道那些类是什么。

8.1.4. null 关键字¶

当你声明一个对象变量时，请记住你存储的是对某个对象的引用。在 Java 中，关键字 null 是一个特殊的值，意思是"没有对象"。你可以这样声明并初始化对象变量：

Pixel pix = null;

当你不希望创建新对象，也不希望把变量初始化为引用某个特定的既有对象时，这有时会很有用。当一个方法应当返回一个对象，但有时又没有对象可返回时，它也会很有用。想一个"查找"方法：它寻找某本特定的书，如果找到就返回那本书。如果没有找到会怎么样？在许多情况下，让这样的方法返回特殊值 null 是表明该方法不返回对象的一种有用方式，也许因为"没有对象"本身就是一个有意义的答案。

如果你试图把值为 null 的变量（或返回 null 的表达式）用于访问字段或调用方法，Java 会抛出 NullPointerException 。异常表示发生了不寻常的情况，这可能意味着你的程序"违反了规则"——无论是 Java 程序行为的规则，还是某个特定库方法或类的规则。

程序员常用"空指针异常"（null pointer exception）这个说法或其缩写 NPE 来引用这类错误。NPE 几乎总是意味着你的程序中有 bug，因为你的程序在需要对象的场合试图使用 "null"，而 null 的意思是"没有对象"，所以这个要求并没有得到满足。下面是一个会抛出空指针异常的代码示例。

Pixel pix = null;
pix.setRed(255); // This was a cause a NullPointerException

NullPointerException 是程序员经常遇到的常见错误。请注意，如果你在自己的代码中看到它出现，你很可能是在处理一个尚未被设置为引用特定对象的变量，或者你可能是在处理一个有时不返回对象的方法。

8.1.5. 诊断空指针异常¶

首先，请记住，当你试图把 null 用作某个操作的接收者时——基本上就是当你有一个用于调用方法或引用字段的点号（"."），但点号左侧的表达式（"接收者"）是 null 时——就会发生 NullPointerException (也称为 "NPE")。换句话说，你在一个没有对象充当接收者的地方使用了 "."。

如果这种情况发生在执行测试的过程中，测试将会失败。在测试结果窗口中，如果你单击失败的测试，窗口的下半部分会显示 NullPointerException 以及关于它在何处发生的信息，如本例所示。

在这里，通过单击失败的测试 testMaxRed() ，BlueJ 测试窗口的下半部分显示了这些信息。如果错误发生在你没有运行测试的时候，同样的信息会改而出现在 BlueJ 的终端窗口中。

在这段信息的顶部，你会看到 NPE 通常不包含任何异常消息或信息。你还会看到异常的类名 NullPointerException 。不要只盯着异常名称和/或消息——它们对说明发生了什么有用，但只是内容的一部分。此外，在异常消息下方还有一列（可能很长的）方法。这列方法被称为"堆栈跟踪"（stack trace），它基本上精确地显示了失败发生的位置，以及你的程序是如何到达那个位置的。列表中顶端的一条显示抛出异常的类、方法名、文件名和行号。文件名和行号位于括号中。有时那是在你自己的代码中——如果是这样，直接转到指定文件中的那一行，你就会正好位于抛出异常的位置。

例如，这个堆栈跟踪指向 TransformablePicture 类中的 maxRed() 方法，位于该类的第 38 行。如果我们查看那里，就会找到发生 NPE 的那一行（摘自上一节）。

pix.setRed(255); // This was a cause a NullPointerException

如果顶端那一行的不是你的代码——也许是某个库方法——不要灰心。虽然异常可能发生在属于另一个类的某个方法中，但它几乎可以肯定是因为你的代码调用某些东西的方式引起的。只要往列表下面看。看列出的第二个方法、第三个方法、第四个，以此类推，直到你在自己的某个类中找到一个方法。现在你就知道问题到底出在你自己的代码中的哪里了。同样，你可以使用文件名和行号直接跳到源代码中问题发生的那个位置。此后，就该调试了——弄清楚问题为什么发生，这样你才能修复它。

一旦找到了位置，要诊断空指针异常，只需检查抛出异常那一行上的点号（句点）。可能只有一个，也可能有好几个。逐一检查它们。你需要弄清楚其中哪一个点号的左侧恰好是 "null"（也就是没有对象）。通常你可以通过排除法来做到这一点。

在我们的示例中，出现问题的那一行包含 pix.setRed(255); ，所以只有一个点号。点号左侧的名字是 pix ，所以这个问题的发生是因为 pix 是 null ，但我们却试图像那里有一个对象一样用它来调用方法。

在本课程中，NPE 的一些最常见原因有：

• 你没有正确初始化字段或变量

• 你使用某个方法的结果时假定该方法总是返回对象，而实际上该方法有时可能返回 null

• 你在需要一个实际对象的场合，把 null 作为参数值传给某个库方法

你需要逐一检查抛出异常那一行上的每个"点号"，以排除这类问题，并逐步缩小可能性，直到你弄清楚 null 在哪里发生以及为什么发生。如果你不得不往堆栈跟踪下面看好几行，那么你总是有可能处于上面提到的最后一种情况——不是在"点号"左侧有一个 null 值，而是把 null 值传给了某个其他方法（库方法或从父类继承的方法）。

试试这个方法，看看你是否能弄明白。虽然这些是最常见的原因，但遇到这个问题的途径是无穷无尽的，而诊断它们的过程总是一样的。如果你在确定错误位置时遇到困难，请把你异常消息和堆栈跟踪的内容在这里发出来作为后续跟进，以获取更多信息。如果你找到了问题所在的那一行，但在尝试了上述建议后仍无法确定原因/方式，请把发生 NPE 的那一行连同堆栈跟踪一起发出来，这样我们可以指导你解决。

8.1.6. 使用 BlueJ 的调试器¶

8.1.7. 使用 BlueJ 的代码垫¶

8.1.8. 编程练习 8¶