Java 入门第一步

源代码、编译、运行：第一个程序

学完你能 你能说清源代码、编译和运行各是什么，并能自己写出、编译、运行一个打印文字的程序。

程序就是写给计算机的一串指令。你把这串指令写成文字，存在一个文件里。这些文字叫源代码。Java 源文件的名字以 .java 结尾。

计算机不能直接照着 Java 文字去做，要先由一个叫编译器的程序把它翻译一遍。Java 的编译器叫 javac。它读取 Main.java，写出一个新文件 Main.class，里面装的是字节码。字节码是一串紧凑的指令，专为 Java 自己的虚拟机准备。这个翻译的步骤叫编译。

接着，Java 虚拟机（Java Virtual Machine，简称 JVM）读取字节码，并执行里面的指令。启动它就叫运行程序。你用 java 这个命令来启动它。

所以永远是两步。你在终端里输入它们，终端就是用来输入命令的窗口（见“准备你的电脑”）：

javac Main.java
java Main

第一条命令编译，第二条命令运行。注意第二条只写 Main，没有 .java，也没有 .class，因为你给出的是类的名字，不是文件的名字。较新的 JDK（11 及以上）也接受 java Main.java，一次完成两步。本指南仍然分成两步，让你能看清每一步。

如果你改了源文件，旧的 Main.class 不会跟着变。要重新编译，再重新运行。忘了这一点，是第一天最常见的错误。

下面看程序的基本形状。Java 把所有代码都放在类里面。类是一个有名字的代码容器。public 的类必须和它的文件同名，所以叫 Main 的类放在 Main.java 里。类的里面写一个叫 main 的方法。方法是一段有名字、只做一件事的代码。运行程序时，JVM 会去找 main，并从那里开始。

在方法里，每一条指令叫一条语句。大多数语句以分号结尾。花括号 { } 标出类或方法从哪里开始、到哪里结束。语句 System.out.println 会打印文字，然后换到新的一行。System.out.print 做同样的事，但不换行。文字必须放在双引号里面。

Java 25 还允许一种短得多的程序写法。你的课程用的是这里的经典写法，它在所有版本上都能用。要在本页运行一个例子，点它下面的“运行”。你也可以点“修改代码”，改一点东西，再点一次“运行”。

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
        System.out.println("My name is Leon.");
        System.out.println(2 + 3);
    }
}

Hello, Java!
My name is Leon.
5

Main.java.txt

Main.java

java Main    (typed after editing Main.java, without compiling again)

javac Main.java
java Main

system.out.println("Hi");

System.out.println("Hi");

变量和类型

学完你能 你能声明 int、double、boolean、char 和 String 类型的变量，修改它们的值，并预测除法和 + 的结果。

变量是计算机内存里一个有名字的位置，里面存放一个值。名字由你来起。Java 还需要知道这个变量允许存放哪一种值，这一种就叫变量的类型。

最先要学的五种类型是：
int：整数，例如 7 或 -3。
double：带小数部分的数，例如 1.5。
boolean：只有 true 或 false 两个值。
char：一个字符，写在单引号里，例如 'A'。
String：文字，写在双引号里，例如 "Mia"。String 的 S 要大写。

声明变量时，依次写出类型、名字和第一个值：int apples = 7; 其中的 = 号表示“把右边的值存进左边的名字里”。它不表示数学里的“等于”。之后你可以存入新的值：apples = apples + 1; 读作“取出 apples 现在的值，加 1，再把结果存回 apples”。这时不用再写类型，因为变量已经存在了。

Java 在程序运行之前就检查类型。它不会把 2.5 存进 int，因为 .5 会丢掉。它还要求每个变量在被使用之前先有一个值。

算术运算有 + - * / 和 %，其中 % 求除法的余数。如果 / 两边都是 int，结果就是 int，小数部分被直接去掉：7 / 2 是 3，不是 3.5。只要有一边是 double，结果就是 double：7 / 2.0 是 3.5。Java 先算 * 和 /，再算 + 和 -，其余情况按从左到右的顺序计算。

+ 号还能把文字连起来。把文字连起来叫拼接。"Mia" + " is " + 7 得到文字 Mia is 7。因为 Java 从左到右计算，所以顺序很重要，下面的常见错误会演示这一点。

public class Main {
    public static void main(String[] args) {
        String name = "Mia";
        int apples = 7;
        int people = 2;
        double price = 1.5;
        boolean cheap = price < 2.0;
        char grade = 'A';

        System.out.println(name + " has grade " + grade);
        System.out.println("whole share: " + apples / people);
        System.out.println("left over: " + apples % people);
        System.out.println("exact share: " + apples / 2.0);
        System.out.println("total cost: " + apples * price);
        System.out.println("cheap? " + cheap);

        apples = apples + 1;
        System.out.println("apples now: " + apples);
    }
}

Mia has grade A
whole share: 3
left over: 1
exact share: 3.5
total cost: 10.5
cheap? true
apples now: 8

int half = 7 / 2.0;

double half = 7 / 2.0;

System.out.println("Sum: " + 2 + 3);

System.out.println("Sum: " + (2 + 3));    // prints Sum: 5

int total;
System.out.println(total);

int total = 0;
System.out.println(total);

char grade = "A";

char grade = 'A';

判断与重复：if 和 for

学完你能 你能用 if 和 else 让程序在两条路径中选择，并用 for 让一段工作重复固定的次数。

通常 Java 把语句从上到下各运行一次。有两个工具可以改变这一点：if 语句决定要不要运行某些语句，for 语句让某些语句重复运行。

if 语句在括号里放一个条件，后面跟一个代码块。代码块是花括号里的一组语句。条件必须是 boolean，也就是 true 或 false。如果为 true，Java 运行这个代码块；如果为 false，Java 跳过它，有 else 的话就运行 else 后面的代码块。else 部分是可选的。要依次测试好几种情况，可以在 else 后面再写一个 if。Java 会选中第一个条件为 true 的代码块，并跳过其余的。

条件通常来自比较：<（小于）、<=（小于或等于）、>（大于）、>=（大于或等于）、==（等于）和 !=（不等于）。条件还可以组合：&& 表示并且，|| 表示或者，! 表示取反。注意区别：两个等号 == 是比较两个值，一个等号 = 是存入一个值。

for 循环让一个代码块重复运行。循环就是让代码块一遍又一遍运行的语句。for 的括号里有三部分，用分号隔开，例如 for (int i = 1; i <= 5; i++)。起点 int i = 1 创建一个叫 i 的计数器并设为 1。测试 i <= 5 在每一轮开始前检查，变成 false 时循环结束。步进 i++ 在每一轮结束后让 i 加 1，它是 i = i + 1 的简写。同样，i-- 表示减 1。

跟踪的意思是用手把程序走一遍，每一步之后写下每个变量的值。这样不用运行代码也能知道它做了什么，这是值得在纸上多练习的一项技能。

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total = total + i;
            if (i % 2 == 0) {
                System.out.println(i + " is even, total " + total);
            } else {
                System.out.println(i + " is odd, total " + total);
            }
        }
        System.out.println("final total " + total);
    }
}

1 is odd, total 1
2 is even, total 3
3 is odd, total 6
4 is even, total 10
5 is odd, total 15
final total 15

if (score = 50) {

if (score == 50) {

for (int i = 0; i < 3; i++);
{
    System.out.println("hi");
}

for (int i = 0; i < 3; i++) {
    System.out.println("hi");
}

for (int i = 1; i < 5; i++) {
    System.out.println(i);
}    // meant to print 1 to 5

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

if (x > 0)
    System.out.println("positive");
    System.out.println("done");

if (x > 0) {
    System.out.println("positive");
}
System.out.println("done");

方法：给一段工作起名字

学完你能 你能写出带形参和返回值的方法，并在 main 里调用它。

方法是一段有名字的代码。你只写一遍，却可以用任意多次。用它叫作调用它。有了方法，就不必把同样的几行代码复制一遍又一遍，而一个好名字还能告诉读者这几行代码是做什么的。

方法有四个部分。以 static int square(int n) { return n * n; } 为例：返回类型 int 说明返回的是哪一种值；名字是 square；形参列表 (int n) 声明输入，形参就是接收一个输入的变量；花括号里的方法体是运行的代码。现在必须写 static，因为 main 是 static 的，眼下先保留它。第 7 课会讲不带 static 的方法。

调用方法时，写出它的名字，并在括号里放上要交给它的值：square(6)。这些值叫实参。Java 把每个实参复制给对应的形参。return 语句把一个值送回去，并结束这个方法。于是 square(6) 就代表值 36，凡是能放值的地方都能用它，例如放在 println 里面，或者放在 = 号的右边。

有些方法什么也不返回。它们的返回类型是 void，也不需要 return 语句。例子中的 greet 就是这样。

在方法里创建的变量（包括形参）都是局部变量。它只在方法运行期间存在，别的方法看不到它。因为实参是被复制过去的，所以在方法里修改形参，不会改变调用它的代码（称为调用者）里的变量。例子里用 n 演示了这一点。

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    static int square(int n) {
        return n * n;
    }

    static int addOne(int n) {
        n = n + 1;
        return n;
    }

    public static void main(String[] args) {
        greet("Iris");
        int result = square(6);
        System.out.println("6 squared is " + result);
        System.out.println(square(square(2)));

        int n = 5;
        int bigger = addOne(n);
        System.out.println("n is " + n + ", bigger is " + bigger);
    }
}

Hello, Iris!
6 squared is 36
16
n is 5, bigger is 6

static int square(int n) {
    int result = n * n;
}

static int square(int n) {
    int result = n * n;
    return result;
}

int n = 5;
addOne(n);
System.out.println(n);    // expecting 6

int n = 5;
n = addOne(n);
System.out.println(n);    // prints 6

int square(int n) {
    return n * n;
}

static int square(int n) {
    return n * n;
}

数组：排成一行的多个值

学完你能 你能创建数组，按下标读取和修改它的元素，用循环遍历它，并把它打印出来。

数组存放固定数量的同类型的值，它们排成一行。想象一排有编号的格子。每个格子是一个元素，格子的编号叫下标。下标从 0 开始，不是从 1 开始。有 3 个元素的数组，下标是 0、1、2。

创建数组时可以直接给出值：int[] scores = {80, 95, 70}; 类型 int[] 表示“int 的数组”。也可以只指定大小：int[] blanks = new int[3]; 这时每个元素都有一个默认值：数字是 0，boolean 是 false，String 是 null。null 表示“没有对象”。

用 scores[0] 读取一个元素，用 scores[1] = 100; 修改一个元素。数组的大小是 scores.length。注意 length 后面没有括号。数组一旦创建，大小就不能再改变。

最后一个有效下标是 length - 1。下标超出 0 到 length - 1 的范围，不会造成编译错误，而是程序运行到那一行时停下来，报 ArrayIndexOutOfBoundsException。异常是 Java 报告“程序运行时出了问题”的方式。第 8 课会教你怎样读懂它。

要访问每一个元素，可以按下标循环：for (int i = 0; i < scores.length; i++)。还有一种更短的写法，叫 for-each 循环：for (int s : scores) { ... } 读作“对 scores 里的每个 int s”。变量 s 依次取到每一个值。不需要下标的时候用它。

直接打印数组，显示的是类似 [I@6d06d69c 的代号，而不是里面的值。想看到值，就在类的上方写 import java.util.Arrays;，然后打印 Arrays.toString(scores)。import 这一行告诉 Java 你指的是哪个库里的类。库是 Java 自带的、大量现成的类的集合。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] scores = {80, 95, 70};
        System.out.println("first = " + scores[0]);
        System.out.println("length = " + scores.length);

        scores[1] = 100;
        System.out.println(Arrays.toString(scores));

        int total = 0;
        for (int i = 0; i < scores.length; i++) {
            total = total + scores[i];
        }
        System.out.println("total = " + total);

        for (int s : scores) {
            System.out.println("score: " + s);
        }

        int[] blanks = new int[3];
        System.out.println(Arrays.toString(blanks));
    }
}

first = 80
length = 3
[80, 100, 70]
total = 250
score: 80
score: 100
score: 70
[0, 0, 0]

for (int i = 0; i <= scores.length; i++) {
    System.out.println(scores[i]);
}

for (int i = 0; i < scores.length; i++) {
    System.out.println(scores[i]);
}

int[] copy = scores;
copy[0] = 0;

int[] copy = Arrays.copyOf(scores, scores.length);
copy[0] = 0;    // scores is unchanged

System.out.println(scores.length());

System.out.println(scores.length);

字符串，以及 == 与 equals 的区别

学完你能 你能使用常用的 String 方法，并正确地比较两个字符串。

String 是一段文字，由按顺序排列的字符组成。字符串的值写在双引号里。String 不是 int 那样的简单类型，它是一个类，每个字符串值都是一个对象。对象是由类创建出来的值，它存放在内存的某个地方。String 类型的变量里存放的不是文字本身，而是一个引用，说明对象在哪里。可以把引用想成指向对象的一张标签。

用点号来使用对象的方法，例如 word.length()。下面这些很有用：length() 给出字符的个数。charAt(i) 给出下标 i 处的字符，下标像数组一样从 0 开始数。substring(a, b) 给出从下标 a 到下标 b 之前的字符，不包括下标 b。indexOf("l") 给出第一次匹配的下标，没有匹配就给出 -1。toUpperCase() 和 toLowerCase() 改变大小写。注意，String 的 length() 带括号，这一点和数组的 length 不同。

String 一旦创建就永远不能改变。toUpperCase() 这样的方法不会改变原来的字符串，而是返回一个新的 String。想保留结果，就要把它存起来：word = word.toUpperCase();

下面讲 == 和 equals。对引用来说，== 问的是：这两个名字指向的是不是同一个对象？它不问文字是否一样。两个不同的对象可以装着相同的字母。equals 方法问的是：这两个字符串包含的字符是否相同？这几乎总是你真正想问的。所以比较字符串要用 a.equals(b)，永远不要用 a == b。要忽略大小写，用 equalsIgnoreCase。

== 有时候看上去能用。Java 对相同的字符串字面量（直接写在代码里的文字）只存一份，所以文字相同的两个字面量就是同一个对象。但是一旦文字来自别处，例如键盘、文件或者某次计算，== 就会得到 false。在测试里正常、之后才出错的 bug 是最糟糕的一种。所以请永远使用 equals。

public class Main {
    public static void main(String[] args) {
        String word = "hello";
        String typed = new String("hello");    // pretend this text came from the keyboard

        System.out.println("same text? " + word.equals(typed));
        System.out.println("same object? " + (word == typed));

        String shout = word.toUpperCase();
        System.out.println(shout + " " + word);
        System.out.println(word.length());
        System.out.println(word.charAt(1));
        System.out.println(word.substring(1, 3));
        System.out.println(word.indexOf("l"));
        System.out.println("ignoring case? " + word.equalsIgnoreCase("HELLO"));
    }
}

same text? true
same object? false
HELLO hello
5
e
el
2
ignoring case? true

if (answer == "yes") {

if ("yes".equals(answer)) {

name.toUpperCase();
System.out.println(name);

name = name.toUpperCase();
System.out.println(name);

String part = "hello".substring(1, 3);    // expecting "ell"

String part = "hello".substring(1, 4);    // ell

第一个类，以及构造方法

学完你能 你能写一个带字段、构造方法和方法的小类，用 new 创建它的对象，并调用对象的方法。

到目前为止，你用的都是 Java 自带的类型。有了类，你就能做出自己的类型。类是一张蓝图：它说明每个对象有哪些数据、每个对象能做什么。对象是按蓝图造出来的一个具体的东西。一个类（例如 Player）可以造出许多对象，每个对象都有自己的数据。

这些数据叫字段。字段是属于某个对象的变量。你在类里面、所有方法外面声明它。我们把字段标成 private。private 表示只有同一个类里面的代码才能使用这个字段。这样数据就受到了保护，其他代码必须通过这个类的方法来使用它。

不带 static 的方法是针对某一个具体的对象工作的。对 Leon 的对象调用 addPoints(5)，改变的是 Leon 的分数，不会影响别人。在类的内部，这样的方法直接用名字使用字段。

构造方法是一种特殊的方法，用 new 创建对象时它会运行。它的名字和类名相同，没有返回类型，连 void 也不写。它的工作是给字段赋上最初的值。new Player("Leon") 会创建对象，以 "Leon" 作为实参运行构造方法，并把指向新对象的引用交给你。

在构造方法里，形参和字段可能都叫 name。写 this.name 表示“这个对象的 name 字段”，单独写 name 表示形参。所以 this.name = name; 的作用是把实参存进字段。

类放在哪里呢？在真正的项目里，每个类都有自己的文件，文件以类命名。为了让这个例子留在同一个文件里，多出来的类要写在 public class Main 的上方。在这种写法下，只有叫 Main 的类可以是 public 的。

class Player {
    private String name;
    private int score;

    Player(String name) {
        this.name = name;
        this.score = 0;
    }

    void addPoints(int points) {
        score = score + points;
    }

    String describe() {
        return name + " has " + score + " points";
    }
}

public class Main {
    public static void main(String[] args) {
        Player leon = new Player("Leon");
        Player mia = new Player("Mia");

        leon.addPoints(5);
        leon.addPoints(3);
        mia.addPoints(10);

        System.out.println(leon.describe());
        System.out.println(mia.describe());
    }
}

Leon has 8 points
Mia has 10 points

Player leon = Player("Leon");

Player leon = new Player("Leon");

void Player(String name) {
    this.name = name;
}

Player(String name) {
    this.name = name;
}

Player(String name) {
    name = name;
    this.score = 0;
}

Player(String name) {
    this.name = name;
    this.score = 0;
}

读懂编译错误和堆栈跟踪

学完你能 你能在 javac 的报错信息和异常的堆栈跟踪里，找到出错的行和原因。

程序出问题有三种方式。编译错误：javac 拒绝构建程序，什么都不会运行。运行时错误：程序开始运行，随后 Java 在某一行把它停掉，并打印堆栈跟踪。答案错误：程序一直运行到结束，但打印出的内容不对，Java 什么也不说。前两种会带着一条信息，这一课就是教你读这些信息。下面的常见错误里有真实的例子。

读编译错误要从上往下读。第一行有三部分：文件名和行号（例如 Main.java:4）、单词 error，以及问题是什么（例如 cannot find symbol）。下一行重复那一行的代码，并在 Java 卡住的位置下面用插入符 ^ 标出来。有些错误还带详细信息，例如 symbol: variable totl 和 location: class Main，说明 Java 不认识哪个名字，以及它在哪里找过。最后一行统计错误的个数。

有三个习惯很有帮助。先修第一个错误，因为后面的错误常常是它引起的，少一个花括号就可能带来十几条报错。每改一处就重新编译一次。其次，报出的行号是 Java 发现问题的地方，真正的错误可能在上面一行。最后，把信息当作提示，而不是诊断结论。cannot find symbol 只说明 Java 不认识某个名字。

异常没有被处理时，就会出现堆栈跟踪。异常是一种事件，表示程序运行时出了问题，例如除以零，或者使用了数组范围之外的下标。程序会在那一刻停止。堆栈跟踪的第一行写着异常的名字和一条消息。接下来是若干以 at 开头的行，每一行是一个当时正在运行的方法，括号里是文件名和行号。最上面的 at 行是异常发生的地方，它下面一行是调用它的方法，依次往下，一直到 main。找到第一行写着你自己文件名（例如 Main.java）的 at 行，打开那个文件，跳到那一行。提到 java.base 或 java.util 的行是 Java 自己的代码。原因几乎总是在你自己的代码里。

你也可以处理异常，而不是任由它让程序停下来。把有风险的语句放进 try 代码块。如果这里发生了指定种类的异常，Java 就跳过 try 代码块里剩下的部分，转而运行 catch 代码块，之后程序在 catch 后面继续运行。例子就是这样工作的。

public class Main {
    static int readAge(String text) {
        return Integer.parseInt(text);
    }

    public static void main(String[] args) {
        System.out.println("start");
        try {
            System.out.println("age is " + readAge("12"));
            System.out.println("age is " + readAge("twelve"));
            System.out.println("this line is skipped");
        } catch (NumberFormatException e) {
            System.out.println("not a whole number");
        }
        System.out.println("done");
    }
}

start
age is 12
not a whole number
done

public class Main {
    public static void main(String[] args) {
        int total = 5
        System.out.println(total);
    }
}

public class Main {
    public static void main(String[] args) {
        int total = 5;
        System.out.println(total);
    }
}

public class Main {
    public static void main(String[] args) {
        int total = 5;
        System.out.println(totl);
    }
}

public class Main {
    public static void main(String[] args) {
        int total = 5;
        System.out.println(total);
    }
}

public class Main {
    static int average(int total, int count) {
        return total / count;
    }

    public static void main(String[] args) {
        System.out.println(average(10, 0));
    }
}

static int average(int total, int count) {
    if (count == 0) {
        return 0;
    }
    return total / count;
}