在纸上写 Java 代码

像计算机一样读代码

学完你能 你能一行一行地手动运行一小段 Java 程序，并写下它用到的每一个值。

在纸上写代码时，没有任何东西会告诉你某一行写错了。你唯一的检查办法，是自己把程序运行一遍：一半在脑子里，一半写在纸上。这叫手动跟踪（英文叫 dry run）：你扮演计算机，拿着笔，一行一行地运行程序。

计算机不知道你的程序是做什么用的。它严格按每一行写的内容，按顺序执行，并且只记得变量里存着的东西。变量就是一个有名字的位置，里面存着一个值。你在跟踪时也要这样做：按这一行实际写的内容去做，而不是按你原本想写的内容去做。

用的工具叫跟踪表。跟踪表里每个变量占一列，每执行一行代码占一行。分四步来做。

1. 在页边给程序的每一行编号，从 1 开始。
2. 画表格。第一列是“行号”，接着每个变量一列，最后一列叫“备注”，用来写发生了什么，例如“条件为真”，或者程序输出了什么。
3. 开始运行。程序从 main 里的第一行开始执行。每执行一行，就加一行记录：先写行号，再写这一行执行完之后每个变量的值。没有变化的值要从上一行抄下来，这样每一行单独看也能读懂。
4. 对没有值的变量，用两种记号。短横线（–）表示这个变量还没有声明，问号（?）表示它已经声明，但还没有存进任何值。Java 不会编译读取问号变量的程序，所以在纸上，读取问号变量是一个你必须自己抓住的错误。

现在先把 String 变量在它那一列里写成带双引号的文字，例如 "data"。下一课会画出它背后真正发生的事。

循环语句会执行很多次，所以会有很多行记录。对于 for 循环，每当计算机走到条件判断，就加一行：写下更新部分（例如 i++）之后各变量的值，并在备注里写条件判断的结果。循环的最后一行记录，是条件为假的那一次，这之后循环体不会再执行。在 for 括号里声明的变量（例如 i）在循环结束后就不存在了，所以之后要写短横线。

if 语句只占一行记录。如果条件为假，下一行记录就是这个 if 右花括号之后的第一行代码。

如果程序调用了方法，就为这次调用另画一张小表，列出它的参数和它自己的变量，并给每次调用编号（f#1、f#2）。方法返回时，把返回值写在发起调用的那一行的备注里。

public class Main {
    public static void main(String[] args) {
        int count = 0;
        String word = "data";
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == 'a') {
                count++;
            }
        }
        System.out.println(count);
    }
}

2

double half = 7 / 2;

double half = 7 / 2.0;

String word = "data";
for (int i = 0; i <= word.length(); i++) {
    System.out.println(word.charAt(i));
}

String word = "data";
for (int i = 0; i < word.length(); i++) {
    System.out.println(word.charAt(i));
}

System.out.println('a' + 1);

System.out.println((char) ('a' + 1));

System.out.println("sum: " + 1 + 2);

System.out.println("sum: " + (1 + 2));

画出内存

学完你能 你能用一套固定的画法，画出 Java 程序在任意一行时的栈和堆，并说出哪些对象已经不可达。

Java 程序处理的是对象，而且好几个变量可以通向同一个对象。这一点从代码里看不出来，必须画出来。每次都用同一种画法。

Java 把值放在两个地方。把它们画成两列，每列写一个标题：栈和堆。

栈为当前正在运行的每个方法放一个栈帧。栈帧是一个方框，里面放这次调用的参数和局部变量。先画 main 的栈帧，放在栈这一列的最上面。每调用一次方法，就在它下面加一个新栈帧。方法返回时，把它的栈帧划掉，里面的东西全部消失。

堆放所有的对象和数组。它们都是用 new 创建的。你不需要释放它们，Java 会替你做。

下面是画图的规则。

1. 基本类型（int、double、boolean、char）的变量是一个方框，值写在里面，例如 int n 和 5。
2. 其他类型的变量里存的是引用。引用要么是指向对象的箭头，要么是 null。画一支箭头，同时在方框里写上目标的标签，这样箭头交叉时你仍然能读出来。
3. 给每个对象加标签：H1、H2、H3，按 new 被执行的顺序编号。在对象上方写标签和类名，例如 H1 (Box)。对象的字段画成里面的小方框，并写上字段名。数组画成 H2 (int[3])，带有 [0]、[1]、[2] 三个单元。新数组的单元一开始是 0（数值）、false，或者 null（引用），绝不会是 ?。
4. 对象数组是引用的数组。new Box[2] 只创建一个数组，它的两个单元里是 null，并不会创建任何 Box。每个 Box 都需要自己的 new。
5. String 是对象。把它画在堆里，写上它的文字，例如 H3 (String) "hi"。文字相同的两个字面量是同一个对象。new String("hi") 会创建另一个对象。
6. null 是不指向任何东西的引用。在方框上画一道斜线并写上 null。通过 null 调用方法，程序会因 NullPointerException 而停止。

= 做了什么。a = b 把 b 方框里的内容复制到 a 的方框里。对基本类型，复制的是数值；对引用，复制的是箭头。执行 Box c = a; 之后，c 和 a 通向同一个对象，对象本身并没有被复制。引用之间的 == 问的是：两支箭头是否指向同一个对象。它不会去看对象里面。要比较两个 String 的文字，用 equals。

方法调用做了什么。它把每个实参复制到新栈帧里新的参数方框中。Java 永远是复制。对引用来说，复制的是箭头。所以方法可以顺着箭头修改对象，但不能让调用者的变量指向别的地方。

什么变成了不可达。如果你能从仍然存在的栈帧里的某个变量出发，顺着箭头走到一个对象，它就是可达的。没有任何箭头通向的对象是不可达的。垃圾回收器（Java 里负责回收内存的部分）可以在某个时刻把它清除。在纸上，要在对象变成不可达的那一刻把它划掉：也就是通向它的最后一支箭头被改掉，或者持有最后一支箭头的栈帧被划掉的时候。

public class Main {
    static class Box {
        int value;

        Box(int value) {
            this.value = value;
        }
    }

    static void bump(Box b, int n) {
        b.value = b.value + n;
        n = 0;
        b = null;
        // A: draw the memory here, inside bump
    }

    public static void main(String[] args) {
        int n = 5;
        Box a = new Box(1);
        Box c = a;
        Box[] row = new Box[2];
        row[0] = new Box(7);
        bump(a, n);
        System.out.println(c.value + " " + n + " " + row[0].value + " " + row[1]);
        a = new Box(40);
        c = null;
        // B: draw the memory here
        System.out.println(a.value);
    }
}

6 5 7 null
40

String a = new String("hi");
String b = new String("hi");
boolean same = (a == b);

String a = new String("hi");
String b = new String("hi");
boolean same = a.equals(b);

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 9;

int[] a = {1, 2, 3};
int[] b = a.clone();
b[0] = 9;

Box[] row = new Box[2];
row[0].value = 3;

Box[] row = new Box[2];
row[0] = new Box(0);
row[0].value = 3;

static void reset(Box b) {
    b = new Box(0);
}

static void reset(Box b) {
    b.value = 0;
}

要背熟的语法

学完你能 你能凭记忆写出下面十一个 Java 骨架，从最短的开始，每个括号和分号都不缺。

有些代码没法当场推出来，你必须不看资料就知道它的形状。这一课的十一个骨架，是 Java 里反复要用的。它们都很短，可以背下来。按下面的顺序学，从最短的开始，上一个背牢了，再加下一个。

1. 类。2. main。3. 构造方法。4. 增强 for（for-each）。5. length、length() 和 size()。6. String 的方法。7. ArrayList。8. HashMap。9. try 和 catch。10. 泛型。11. interface 和 extends。

背诵的办法：盖住页面，在纸上默写这个骨架，再和页面逐个字符对照。只有完全对、中途没有偷看，才打勾。明天再来一遍。连续三天都能写对的骨架，才算学会。

下面的程序包含全部十一个骨架，每个骨架旁边有一条形如 (4) 的注释。先读一遍，再盖住它，在你自己的纸上把每个骨架单独默写出来，每个只写几行。

“有多少个”的三种写法。数组有的是字段，所以不带括号：nums.length。String 有的是方法，所以带括号：word.length()。ArrayList 或 HashMap 的方法叫 size()：names.size()。一个记法：只有朴素的数组不带括号。

String 的方法。位置从 0 开始，而且 String 永远不会改变：每个方法都给你一个新值。length() 是字符个数。charAt(i) 是一个 char。substring(from, to) 取从位置 from 开始、到位置 to 之前（不含 to）的字符。indexOf("x") 是第一个 x 的位置，没有就是 -1。equals(other) 比较文字。toUpperCase() 返回一个大写的新 String。contains("x") 说明 x 是否出现过。

ArrayList：ArrayList<String> names = new ArrayList<>(); 常用 add(x)、get(i)、set(i, x)、remove(i)、size()、contains(x)。HashMap：HashMap<String, Integer> ages = new HashMap<>(); 常用 put(key, value)、get(key)、containsKey(key)、remove(key)、size()。尖括号里的类型必须是类：写 Integer，不能写 int。两者都需要在最上面写 import 行。

import java.util.ArrayList;
import java.util.HashMap;

/* (11) interface and extends */
interface Shape {
    double area();
}

class Rect implements Shape {
    private double width;
    private double height;

    /* (3) constructor */
    Rect(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return width * height;
    }
}

class Square extends Rect {
    Square(double side) {
        super(side, side);
    }
}

/* (10) generics */
class Box<T> {
    private T item;

    Box(T item) {
        this.item = item;
    }

    T get() {
        return item;
    }
}

/* (1) a class */
public class Main {
    static <T extends Comparable<T>> T larger(T a, T b) {
        if (a.compareTo(b) >= 0) {
            return a;
        }
        return b;
    }

    /* (2) main */
    public static void main(String[] args) {
        /* (7) ArrayList */
        ArrayList<String> names = new ArrayList<>();
        names.add("Leon");
        names.add("Mia");
        names.add("Emma");

        /* (8) HashMap */
        HashMap<String, Integer> ages = new HashMap<>();
        ages.put("Leon", 20);
        ages.put("Mia", 22);

        /* (4) for-each */
        for (String name : names) {
            if (ages.containsKey(name)) {
                System.out.println(name + " is " + ages.get(name));
            } else {
                System.out.println(name + " has no age");
            }
        }

        /* (5) length, length() and size() */
        int[] nums = new int[3];
        String word = "banana";
        System.out.println(nums.length + " " + word.length() + " " + names.size());

        /* (6) String methods */
        System.out.println(word.substring(1, 3) + " " + word.indexOf("n") + " " + word.charAt(0) + " " + word.toUpperCase() + " " + word.equals("banana"));

        Shape s = new Square(3);
        System.out.println(s.area());
        System.out.println(larger("pear", "apple"));
        Box<Integer> box = new Box<>(7);
        System.out.println(box.get());

        /* (9) try and catch */
        try {
            int x = Integer.parseInt("12a");
            System.out.println(x);
        } catch (NumberFormatException e) {
            System.out.println("not a number");
        }
    }
}

Leon is 20
Mia is 22
Emma has no age
3 6 3
an 2 b BANANA true
9.0
pear
7
not a number

int a = nums.length();
int b = word.length;
int c = names.length();

int a = nums.length;
int b = word.length();
int c = names.size();

String word = "banana";
String part = word.substring(1, 3);

String word = "banana";
String part = word.substring(1, 4);

for (String name in names) {
    System.out.println(name);
}

for (String name : names) {
    System.out.println(name);
}

class Rect {
    private double width;

    public void Rect(double width) {
        this.width = width;
    }
}

class Rect {
    private double width;

    public Rect(double width) {
        this.width = width;
    }
}

手写时常见的错误

学完你能 你能把自己写的 Java 答案像编译器那样再读一遍，抓住本来会丢分的小错。

在计算机上，编译器会在第一个错误处拦住你，并告诉你是哪一行。在纸上，没有人拦你，而这些小错每一个都会丢分，尽管它们和你是否理解题目毫无关系。所以你必须自己当自己的编译器。

答案写完之后，再读第二遍。这一遍不要问逻辑对不对，只问形式对不对。照下面的清单，用笔逐项打勾。

1. 每条语句都以分号结尾。类、方法、if、for 的右花括号后面没有分号。
2. 每个 ( [ { 都有配对的另一半。把花括号成对地数一遍。
3. 每个变量名前面都有类型。String 的 S 要大写。
4. java.util 里的每个类都有 import 行。
5. = 是存入一个值。== 对数值和 char 提出问题。比较 String 要用 equals。
6. 字符串用双引号，单个 char 用单引号。
7. 不是 void 的方法，在每条路径上都要返回一个值。
8. 把 double 放进 int 需要强制转换。
9. 集合里放的是类：写 Integer，不写 int。
10. 局部变量在读取之前必须有值。
11. 实现接口方法的方法要标成 public。
12. 类名与文件名一致，main 要原样写出。

下面是最容易丢分的四组错误。每组里第一块是常见的错误写法，第二块是改正后的写法。

ArrayList<int> nums = new ArrayList<>();
nums.add(5);
int first = nums[0];

ArrayList<Integer> nums = new ArrayList<>();
nums.add(5);
int first = nums.get(0);

class Rect implements Shape {
    double area() {
        return 1.0;
    }
}

class Rect implements Shape {
    public double area() {
        return 1.0;
    }
}

double x = 7 / 2.0;
int half = x;
String s = 'hi';

double x = 7 / 2.0;
int half = (int) x;
String s = "hi";

static int sign(int x) {
    if (x > 0) {
        return 1;
    } else if (x < 0) {
        return -1;
    }
}

static int bump() {
    int n;
    n++;
    return n;
}

static int sign(int x) {
    if (x > 0) {
        return 1;
    } else if (x < 0) {
        return -1;
    }
    return 0;
}

static int bump() {
    int n = 0;
    n++;
    return n;
}

给自己打分

学完你能 你能对照评分标准诚实地给自己的手写答案打分，找出分数丢在哪里，安排明天的练习，并在限时下写代码。

在纸上，一页写满的答案看起来像是完成了，其实可能是错的。给自己打分能解决这个问题。你拿答案去对照评分标准。评分标准是一组条目，每条值若干分，每条描述一件你能在答案里看到的东西。要严格。真正算数的分数，是一个陌生人会给你的分数。

怎样逐条读评分标准。

1. 读一条。问自己：一个正确的答案里，我到底会看到什么？
2. 在你的答案里找到那样东西，用笔尖点住它。指得出来，就打勾并写下这条的分数；指不出来，这一条就是零分。
3. “差不多”不给半分。只有评分标准写明怎么拆分时，才给一条的部分分数。
4. 检查每一条路径。像“处理空列表”这样的条目，如果只有正常情况能工作，就是零分。
5. 把各条加起来，把总分写成“得分/满分”的形式放在页面上。

怎样找出分数丢在哪里。把每一个丢掉的分放进四个格子之一。思路：我不知道怎么解。记忆：我知道，但记不起语法或方法名。小错：在我本来会的东西上犯的小错误，例如漏了分号或写错了符号。时间：我没写完。数一数每个格子。最大的格子告诉你该练什么。思路：重读对应的课。记忆：多做“盖住再默写”。小错：用上一课的编译器检查清单，再加一个很小的测试。时间：练习先做计划。

第二天要做什么。第一，在空白页上不看资料，把同一道题的答案重写一遍。第二，做一道同类型的不同题目。第三，把两份答案再各打一次分。三天后和一周后再重复。当最大的格子换了，说明你在进步。

怎样在限时下写。

1. 先做计划。用掉最初的十分之一时间。写出方法头，再写三四行说明步骤的注释。不要跳过这一步。
2. 代码行之间空一行。你会需要空间补写漏掉的一行。
3. 变量名要清楚：用 count，不要用 c；用 longest，不要用 l。名字清楚，就不会把两个变量混在一起。
4. 用一个很小的输入手算测试。代码写完后，用最小的情况走一遍：只有一个元素、空列表、长度为 1 的单词。再走一个恰好卡在边界上的情况。这只要一分钟，却能找出大部分边界错误。
5. 大约每分花一分钟。某一部分卡住了，就写一行注释说明你打算怎么做，然后往下写，回头再补。
6. 留出两分钟做编译器检查。

在“练习”页面里，题型为“手写代码”的题目有手写模式：有计时器、参考答案，以及可以打勾的评分标准。完全按这一课的办法用它：先在纸上写，再打分。

import java.util.ArrayList;

public class Main {
    /* A student's answer. It has one bug. */
    static int countLong(ArrayList<String> words, int min) {
        int count = 0;
        for (String w : words) {
            if (w.length() > min) {
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        ArrayList<String> words = new ArrayList<>();
        words.add("a");
        words.add("bb");
        words.add("cc");
        words.add("ddd");
        System.out.println(countLong(words, 2) + " (expected 3)");
    }
}

1 (expected 3)

for (int i = 0; i <= words.size(); i++) {
    System.out.println(words.get(i));
}

for (int i = 0; i < words.size(); i++) {
    System.out.println(words.get(i));
}

static int total(ArrayList<Integer> xs) {
    for (int x : xs) {
        int sum = 0;
        sum = sum + x;
    }
    return sum;
}

static int total(ArrayList<Integer> xs) {
    int sum = 0;
    for (int x : xs) {
        sum = sum + x;
    }
    return sum;
}

static void total(ArrayList<Integer> xs) {
    int sum = 0;
    for (int x : xs) {
        sum = sum + x;
    }
    System.out.println(sum);
}

static int total(ArrayList<Integer> xs) {
    int sum = 0;
    for (int x : xs) {
        sum = sum + x;
    }
    return sum;
}