DEV Community: Homlander

Java 多态：重写、类型转换与动态绑定

Homlander — Wed, 11 Nov 2026 14:02:51 +0000

1. 先理解多态解决什么问题

猫和狗都是动物，都能“吃”，但吃的方式不同。我们希望调用时统一写成 animal.eat()，运行时却能根据实际对象，分别执行猫或狗的吃饭方法。

同样的方法调用，因为引用指向的对象不同，执行不同的实现，这就是本章讨论的运行时多态。

在本章的继承体系中，体现多态需要三个条件：

子类继承父类。
子类重写父类的方法。
通过父类引用调用这个被重写的方法。

先看一个完整例子，保存为 TestAnimal.java 即可运行。后面的动物示例继续使用这里的三个类。

class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(name + "吃鱼");
    }

    public void mew() {
        System.out.println(name + "喵喵叫");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(name + "吃骨头");
    }

    public void bark() {
        System.out.println(name + "汪汪叫");
    }
}

public class TestAnimal {
    public static void feed(Animal animal) {
        animal.eat();
    }

    public static void main(String[] args) {
        feed(new Cat("元宝"));
        feed(new Dog("小七"));
    }
}

输出：

元宝吃鱼
小七吃骨头

执行过程：

调用	形参 `animal` 的声明类型	实际指向的对象	执行的方法
`feed(new Cat("元宝"))`	`Animal`	`Cat` 对象	`Cat.eat()`
`feed(new Dog("小七"))`	`Animal`	`Dog` 对象	`Dog.eat()`

feed 只负责调用动物的 eat()，不必判断传进来的是猫还是狗。共同行为由父类规定，具体行为由子类实现。

2. 方法重写：让子类提供自己的实现

2.1 什么是重写

重写（override）是子类重新实现父类中允许被重写的实例方法。 上例中，Cat.eat() 和 Dog.eat() 都重写了 Animal.eat()。

重写要遵守以下规则：

检查项	规则
方法名	与父类方法相同
参数列表	参数类型、个数、顺序相同；参数名可以不同
返回类型	通常相同；父类方法返回类类型时，子类方法可以返回该类型的子类
访问权限	不能缩小，例如父类为 `public`，子类也必须为 `public`
不能重写的方法	`static` 方法、`private` 方法、`final` 方法、构造方法

返回类型的例外叫作协变返回类型。例如，父类方法为 Animal getAnimal()，子类可以重写为 Cat getAnimal()。方向不能反过来；基本类型也不能这样改变，例如 int 不能改成 long。

建议重写时加上 @Override：它让编译器检查这个方法是否真的构成重写。如果把 eat 错写成 aet，就能及时发现。重写由方法本身的关系决定，并不是写上注解才发生。

练习中还涉及“检查异常”：可暂时理解为编译器要求声明或处理的一类异常。重写方法不能新增父类方法未声明的检查异常，也不能把它扩大为更宽泛的类型；可以缩小或不声明。本章先记住这个限制即可。

2.2 重写和重载不要混淆

对比项	重写（override）	重载（overload）
核心含义	子类改变继承来的方法实现	同名方法接收不同的参数
关系	父类与子类之间	常见于同一个类，也可涉及继承来的方法
方法名	相同	相同
参数列表	相同	必须不同
返回类型	相同，或符合协变规则	可以不同，但不能仅凭返回类型构成重载
访问权限	不能缩小	不受重写的权限规则限制
决定调用的时机	运行时确定重写方法的实现	编译时选择重载版本

例如，eat() 和 eat(String food) 是重载；子类重新实现父类的 eat() 才是重写。

重写也有利于扩展已有功能：在适合继承的场景中，可以新建子类、复用共有内容并重写需要变化的方法，减少对已有类和原有使用者的影响。

3. 理解多态的关键：声明类型与实际对象

Animal animal = new Dog("小七");
animal.eat();       // 输出：小七吃骨头
// animal.bark();   // 编译错误：Animal 中没有 bark()

这里有两个类型，不能混为一谈：

引用的声明类型是 Animal：决定编译器允许通过它调用哪些方法。
对象的实际类型是 Dog：决定运行时执行哪个重写后的实例方法。

所以，animal.eat() 的判断分为两步：

编译时检查能否调用：Animal 中有可访问的 eat()，因此通过检查。
运行时确定具体实现：animal 指向 Dog 对象，因此执行 Dog.eat()。

而 animal.bark() 在第一步就失败了。虽然对象是狗，但编译器根据 Animal 类型检查方法，找不到 bark()。

对于这里的实例方法调用，可以记成：编译看引用类型，运行看实际对象。

静态绑定与动态绑定

“绑定”可以简单理解为确定方法调用对应哪个方法。

静态绑定（早绑定）：编译时确定。重载版本的选择是典型例子，依据实参表达式的编译时类型等信息完成。
动态绑定（晚绑定）：运行时根据实际对象确定重写方法的实现。

例如，假设有两个重载的静态方法 show(Animal a) 和 show(Dog d)：

Animal animal = new Dog("小七");
show(animal); // 选择 show(Animal a)，因为 animal 的声明类型是 Animal

如果 show(Animal a) 内部再调用 a.eat()，这次实例方法调用才会根据实际对象执行 Dog.eat()。

有些资料把重载称为“编译时多态”，把重写引起的动态绑定称为“运行时多态”。读题时要注意范围，不能因此认为重载也会在运行时重新选择参数版本。

4. 向上转型：统一当作父类使用

把子类对象的引用交给父类类型的变量，就是向上转型。 它可以自动完成，不需要强制类型转换。

Animal animal = new Cat("元宝");

这并没有把猫对象变成一个新的 Animal 对象。对象仍然是猫，只是通过父类类型的引用来使用它。

向上转型常见于以下三种场景。

4.1 直接赋值

Cat cat = new Cat("元宝");
Animal animal = cat;

cat 和 animal 指向同一个对象。

4.2 方法传参

// feed 的形参类型是 Animal
feed(new Cat("元宝"));
feed(new Dog("小七"));

一个父类类型的形参，就可以接收不同子类的对象。

4.3 方法返回

下面的方法可放在 TestAnimal 类中：

public static Animal buyAnimal(boolean wantCat) {
    if (wantCat) {
        return new Cat("元宝");
    }
    return new Dog("小七");
}

调用时：

Animal animal = buyAnimal(false);
animal.eat(); // 输出：小七吃骨头

方法声明返回 Animal，实际可以返回 Cat 或 Dog 对象。

向上转型让代码可以统一处理不同子类，代价是无法直接通过父类引用调用子类特有的方法。需要使用这些方法时，才考虑向下转型。

5. 向下转型：使用子类特有的方法

5.1 强制转换不会改变对象的实际类型

向下转型是把父类类型的引用转换为子类类型，需要显式写出目标类型：

Animal animal = new Dog("小七");
Dog dog = (Dog) animal;
dog.bark(); // 输出：小七汪汪叫

animal 和 dog 仍指向同一个狗对象；animal 本身的声明类型也没有改变。

能否转换成功，取决于对象实际是不是目标类型或它的子类。 写上强制转换，不代表一定能成功：

Animal animal = new Dog("小七");
Cat cat = (Cat) animal; // 能通过编译，但运行时抛出 ClassCastException
cat.mew();             // 上一行异常未处理，本行不会执行

ClassCastException 表示类型转换异常：实际是狗，不能当成猫使用。此处先理解异常会中断正常执行即可，不必提前学习异常处理语法。

5.2 用 instanceof 判断后再转换

引用 instanceof 类型 用来判断：引用指向的对象是否属于该类型或它的子类。

Animal animal = new Dog("小七");

if (animal instanceof Cat) {
    Cat cat = (Cat) animal;
    cat.mew();
} else if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();
}

输出：

小七汪汪叫

判断为 true 后，再把同一个引用转换为对应类型，就能避免这里的类型转换异常。引用为 null 时，instanceof 的结果为 false。

如果只是调用已有的共同方法 eat()，直接使用多态即可，不必先判断类型、再向下转型。

6. 多态为什么能减少分支、方便扩展

以绘制不同图形为例。下面是独立的完整示例，保存为 TestShape.java：

class Shape {
    public void draw() {
        System.out.println("画图形");
    }
}

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("画矩形");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("画圆形");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("画花朵");
    }
}

public class TestShape {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle(), new Rect(), new Flower()
        };

        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

输出：

画圆形
画矩形
画花朵

数组中存放的是不同子类对象的引用。遍历时，shape 的声明类型始终为 Shape，实际指向的对象不断变化，因此同一句 shape.draw() 会执行不同实现。

这样做有两个好处：

减少按类型判断的分支：不必编写“是圆就画圆，是矩形就画矩形”的一串 if-else。
方便扩展：增加 Triangle extends Shape 并重写 draw()，再把三角形对象放入数组，原来的遍历和调用逻辑无需修改。

课件提到的“圈复杂度”衡量代码中独立执行路径的数量。分支越多，通常越难理解和测试；它并不等于简单地数出所有条件语句和循环语句。这里理解多态能减少调用处的类型判断即可。

多态的使用限制仍然是：父类引用不能直接调用子类特有方法；向下转型虽然能解决这个问题，但必须注意实际类型。

7. 构造方法中的陷阱：对象还没初始化完，就调用了子类方法

尽量避免在构造方法中调用可能被子类重写的实例方法。

下面的独立示例保存为 TestInit.java：

class B {
    public B() {
        func();
    }

    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B {
    private int num = 1;

    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

public class TestInit {
    public static void main(String[] args) {
        D d = new D();
        d.func();
    }
}

输出：

D.func() 0
D.func() 1

第一行为什么是 0？按顺序看：

创建 D 对象时，其实例字段先获得默认值，int 类型的 num 此时为 0。
执行子类的初始化过程前，先执行父类 B 的构造方法。
B 的构造方法调用 func()，仍会发生动态绑定，因此执行的是 D.func()。
此时 private int num = 1; 中的显式赋值还没有执行，所以打印 0。
父类构造方法返回后，才执行子类字段的显式初始化，num 变为 1；随后完成子类构造。
new D() 完成后，再调用 d.func()，就打印 1。

问题不在于 num 没有任何值，而在于它只有默认值，尚未完成子类的显式初始化。

构造方法应尽量只做必要的初始化。private、final 方法不能被子类重写，因此不会因重写而直接跳到子类实现；关键是避免在对象尚未构造完成时，执行依赖子类初始化结果的逻辑。

8. 复习自查

问题	答案
`Animal a = new Dog("小七")` 后，`a.eat()` 执行谁的方法？	`Dog.eat()`，前提是狗类重写了该方法
为什么不能直接调用 `a.bark()`？	编译器按 `Animal` 类型检查，而该类型没有 `bark()`
向上转型会创建新对象吗？	不会，只是用父类类型的引用使用原对象
`(Cat) a` 一定成功吗？	不一定；实际对象必须是 `Cat` 或其子类对象
重写能缩小访问权限吗？	不能；返回的类类型则可以是原返回类型的子类
`final` 方法能通过子类重写产生运行时多态吗？	不能，因为它不允许被重写
重载和本章的多态是同一回事吗？	重载在编译时选择版本；本章重点是运行时选择重写实现
为什么构造方法里调用重写方法可能读到 `0`？	动态绑定调用了子类实现，但子类字段的显式初始化尚未执行

课件练习还提到接口。接口可以先理解为约定一组行为，由实现类提供具体实现；接口类型的引用也能指向不同实现类对象，调用时体现多态。具体语法留到接口章节学习。

11 继承

Homlander — Wed, 11 Nov 2026 13:52:12 +0000

一、继承解决什么问题

狗和猫都有名字、年龄，也都会吃饭、睡觉。如果分别在 Dog 和 Cat 中编写这些成员，就会出现重复代码。把共同成员放入 Animal，再让狗和猫继承它，就能复用这些代码。

继承表示“是一个”（is-a）的关系：狗是一种动物，因此 Dog 可以继承 Animal。

class 子类 extends 父类 {
    // 子类新增的成员
}

父类：也叫基类、超类，提供共同的属性和行为。
子类：也叫派生类，可以复用父类中允许继承的成员，并增加或调整自己的行为。

下面的完整示例可保存为 Test.java；后续完整示例也分别独立运行。

class Animal {
    String name;
    int age;

    public void eat() {
        System.out.println(name + "正在吃饭");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println(name + "汪汪叫");
    }
}

class Cat extends Animal {
    public void mew() {
        System.out.println(name + "喵喵叫");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "小黑";
        dog.age = 2;
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

输出：

小黑正在吃饭
小黑正在睡觉
小黑汪汪叫

Dog 没有重复声明 name、age、eat()、sleep()，仍然能使用它们，这就是代码复用。

子类通常会增加特有成员或调整行为，但语法并不强制子类必须新增成员。继承也是后续学习多态的基础，本章先掌握成员复用和访问规则。

二、先看权限：父类的成员能不能访问

有继承关系，不代表能直接访问父类的所有成员。 判断成员访问是否合法，必须先看权限。

访问位置	`private`	不写修饰符（包访问权限）	`protected`	`public`
声明该成员的类内部	可以	可以	可以	可以
同一个包中的其他类	不可以	可以	可以	可以
不同包中的子类内部	不可以	不可以	可以，但有限制	可以
不同包中的非子类	不可以	不可以	不可以	可以

“包访问权限”就是不写访问修饰符，不是写一个 default 关键字。

2.1 `private`：子类不能直接访问

class Animal {
    private String name = "小黑";

    public String getName() {
        return name;
    }
}

class Dog extends Animal {
    public void show() {
        // System.out.println(name);       // 错误：不能直接访问父类的 private 字段
        // System.out.println(super.name); // 错误：super 不能绕过权限
        System.out.println(getName());     // 正确：通过父类公开的方法读取
    }
}

父类的 private 成员不被子类继承，也不能由子类直接访问；但子类对象仍然具有由父类管理的这部分状态，父类自己的方法可以使用它。

2.2 `protected`：重点看跨包情况

同包时，protected 成员可以被包内其他类访问，不要求有继承关系。

跨包时，需要同时考虑访问代码写在哪里和通过什么类型的引用访问。对于父类的 protected 实例成员：

访问代码必须位于子类内部。
在该子类内部，可以通过 this、super，或该子类类型及其子类型的引用访问。
不能通过父类类型的引用，或另一个“兄弟子类”类型的引用访问。

父类放在 demo1 包：

// demo1/Base.java
package demo1;

public class Base {
    protected int value = 100;
}

两个子类放在另一个包：

// demo2/Derived.java
package demo2;

import demo1.Base;

class Other extends Base {
}

public class Derived extends Base {
    public void show() {
        System.out.println(this.value);  // 正确
        System.out.println(super.value); // 正确

        Derived d = new Derived();
        System.out.println(d.value);     // 正确：通过 Derived 类型的引用访问

        Base b = new Base();
        // System.out.println(b.value);  // 错误：通过 Base 类型的引用访问

        Other o = new Other();
        // System.out.println(o.value);  // 错误：Other 是兄弟子类
    }
}

虽然 Derived 和 Other 在同一个包，但 value 声明在另一个包的 Base 中，所以这里仍受跨包访问规则限制。

选择权限时，只开放必要的范围：内部实现尽量隐藏，需要给子类使用的成员再考虑 protected，需要对外公开的成员才用 public。

三、再看名字：到底访问哪个成员

以下讨论以成员有访问权限为前提。

3.1 成员变量：同名时优先使用子类的

在子类实例方法中，直接写变量名时，先看局部变量或参数，再看子类字段，最后沿父类查找。父子类存在同名字段时，两个字段都存在，子类字段会隐藏父类字段。

class Base {
    int value = 10;
    int count = 30;
}

class Derived extends Base {
    int value = 20;

    public void show(int value) {
        System.out.println(value);       // 参数
        System.out.println(this.value);  // 子类字段
        System.out.println(super.value); // 父类字段
        System.out.println(count);       // 子类没有，使用父类字段
    }
}

public class Test {
    public static void main(String[] args) {
        Derived d = new Derived();
        d.show(100);
    }
}

输出：

注意：

this.value 不会选中同名参数；它访问当前对象的字段。
super.value 明确访问父类字段，不会改成访问子类的同名字段。
字段同名即会发生隐藏，不要求类型相同。实际编写代码时，尽量避免父子类字段同名。
当前作用域和继承链中都找不到对应成员时，编译报错。

3.2 成员方法：不能只看方法名

情况	如何理解
子类没有对应方法，父类有可访问的方法	可以使用父类的方法
父子类方法同名，但参数列表不同	可以构成重载，按调用时的参数选择
子类重新实现父类中可重写的同签名实例方法	构成重写，可以用 `super.方法名(...)` 调用父类实现

重写先理解为：子类为父类已有的某个实例方法提供自己的实现。这里先用返回类型也相同的例子，具体规则留到后续学习。

class Base {
    public void show() {
        System.out.println("Base.show()");
    }

    public void work() {
        System.out.println("Base.work()");
    }
}

class Derived extends Base {
    public void show(int n) {
        System.out.println("Derived.show(int)：" + n);
    }

    public void work() {
        System.out.println("Derived.work()");
    }

    public void test() {
        show();        // 调用父类的无参方法
        show(5);       // 调用子类的有参方法
        work();        // 调用子类重写后的实现
        super.work();  // 明确调用父类实现
    }
}

public class Test {
    public static void main(String[] args) {
        new Derived().test();
    }
}

输出：

Base.show()
Derived.show(int)：5
Derived.work()
Base.work()

show() 和 show(int) 是重载；两个 work() 是重写。不要把方法调用简单理解成“只要子类有同名方法，就一定调用子类的”。

3.3 `super` 的作用

super 用于在子类中明确访问父类成员，常见形式有：

super.字段名
super.方法名(参数)
super(参数)            // 调用父类构造方法，下一节说明

this 是当前对象的引用；super 是访问父类成员的特殊语法，不是另一个独立父类对象的引用。二者都不能在 static 方法中使用，super 也不能突破访问权限。

四、创建子类对象：先初始化父类部分

一个子类对象既有父类定义的实例状态，也有子类自己定义的实例状态。因此，创建子类对象时，需要先通过父类构造方法初始化父类部分，再继续初始化子类部分。

构造方法不会被继承。 子类需要自己的构造方法，并在构造过程中调用父类构造方法。

4.1 用 `super(...)` 选择父类构造方法

class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
        System.out.println("Animal 构造：" + name);
    }
}

class Dog extends Animal {
    int age;

    public Dog(String name, int age) {
        super(name);
        this.age = age;
        System.out.println("Dog 构造：" + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑", 2);
    }
}

输出：

Animal 构造：小黑
Dog 构造：2

执行过程：

new Dog("小黑", 2) 进入 Dog 的构造过程。
super(name) 调用 Animal(String name)，完成父类部分的初始化。
返回后继续执行 Dog 构造方法中剩余的语句。

整个过程创建的是一个 Dog 对象，不是先创建独立的 Animal 对象，再创建一个 Dog 对象。

4.2 没写 `super(...)`，为什么有时可以、有时报错

如果构造方法没有显式调用 this(...) 或 super(...)，编译器会隐式添加 super()。

class Base {
    public Base(int n) {
    }
}

class Derived extends Base {
    public Derived() {
        // 隐式调用 super()，但 Base 没有无参构造方法，因此编译失败
    }
}

上面的错误不是“子类没有构造方法”，而是默认调用的父类无参构造方法不存在。

解决方法是显式调用已有的父类构造方法，例如在第一条语句写 super(10);；也可以根据设计需要，为父类提供可访问的无参构造方法。

这里需要分清两个规则：

一个类完全没有声明构造方法时，编译器才会提供默认的无参构造方法；已经写了有参构造，就不会再自动补无参构造。
隐式 super() 能否成功，取决于父类是否有可访问的无参构造方法，与父类是否还有其他有参构造无关。

4.3 `this(...)` 与 `super(...)` 的关系

写法	含义
`this.字段` / `this.方法(...)`	通过当前对象访问成员，本类没有时也可能使用继承的成员
`super.字段` / `super.方法(...)`	明确访问父类成员或方法实现
`this(...)`	调用本类的另一个构造方法
`super(...)`	调用父类构造方法

按照本章采用的构造方法写法，this(...) 或 super(...) 放在构造方法的第一条语句，二者不能同时写在同一个构造方法中。

class Base {
    public Base(int n) {
        System.out.println("Base：" + n);
    }
}

class Derived extends Base {
    public Derived() {
        this(10);
        System.out.println("Derived 无参构造");
    }

    public Derived(int n) {
        super(n);
        System.out.println("Derived 有参构造");
    }
}

public class Test {
    public static void main(String[] args) {
        new Derived();
    }
}

输出：

Base：10
Derived 有参构造
Derived 无参构造

调用链是 Derived() → Derived(10) → Base(10)，然后逐层返回。

因此，不是每个子类构造方法中都直接出现 super(...)；通过 this(...) 调用本类其他构造方法后，最终仍会调用父类构造方法。

“不能同时出现”指的是构造调用 this(...) 与 super(...)。super(...) 后面当然可以继续写 this.age = age;。

五、有继承时，代码块按什么顺序执行

静态代码块属于类，在类初始化时执行一次；实例代码块属于对象，每次创建对象都会执行。

当父子类都尚未初始化，第一次创建子类对象时，顺序是：

父类静态代码块
    ↓
子类静态代码块
    ↓
父类实例代码块
    ↓
父类构造方法体
    ↓
子类实例代码块
    ↓
子类构造方法体中 super(...) 后的部分

class Parent {
    static {
        System.out.println("父类静态块");
    }

    {
        System.out.println("父类实例块");
    }

    public Parent() {
        System.out.println("父类构造");
    }
}

class Child extends Parent {
    static {
        System.out.println("子类静态块");
    }

    {
        System.out.println("子类实例块");
    }

    public Child() {
        System.out.println("子类构造");
    }
}

public class Test {
    public static void main(String[] args) {
        new Child();
        System.out.println("--- 再创建一个对象 ---");
        new Child();
    }
}

输出：

父类静态块
子类静态块
父类实例块
父类构造
子类实例块
子类构造
--- 再创建一个对象 ---
父类实例块
父类构造
子类实例块
子类构造

记忆重点：静态先完成，实例先父后子；静态只执行一次，实例每次创建都执行。

不要误记成“先执行所有实例代码块，再执行所有构造方法”：父类的实例初始化和构造先完成，才轮到子类的实例初始化和构造。

六、Java 支持哪些继承关系

Java 的类支持：

单继承：一个类只有一个直接父类。
多层继承：C 继承 B，B 继承 A，C 也就间接继承了 A。
多个类继承同一个父类：例如 Dog 和 Cat 都继承 Animal。

class A { }
class B extends A { }
class C extends B { } // 多层继承
class D extends A { } // B 和 D 有同一个直接父类

// class E extends B, D { } // 错误：一个类不能同时继承两个类

多层继承不等于多继承：前者是一条逐层延伸的继承链，后者是一个类同时拥有多个直接父类，Java 的类不支持后者。

除 Object 本身外，Java 的类都直接或间接继承自 java.lang.Object；这里知道它是类继承体系的根即可。

继承层次过深会增加理解和维护的难度，应尽量保持简单。“尽量不超过三层”是设计建议，不是语法限制。

七、`final`：限制修改、重写和继承

修饰对象	作用
变量或字段	一旦赋值，就不能再次赋值
实例方法	子类不能重写这个方法
类	不能再被其他类继承

7.1 修饰变量

final int MAX = 10;
// MAX = 20; // 编译错误：不能重新赋值

如果修饰的是引用变量，不能改变的是引用指向，并不自动禁止修改对象内部的状态。

7.2 修饰类

final class Animal {
}

// class Dog extends Animal { } // 编译错误：Animal 不能被继承

常用的 String 类就是 final 类，不能继承它。

7.3 修饰方法

class Base {
    public final void show() {
        System.out.println("固定实现");
    }
}

class Derived extends Base {
    // public void show() { } // 编译错误：不能重写 final 方法
}

Derived 仍然可以继承和调用这个可访问的方法，只是不能重新实现它。这里先记住限制，重写的详细规则以后再学。

八、继承与组合：是一个，还是有一个

继承和组合都能复用代码，但表达的关系不同。

方式	关系	示例	实现方式
继承	is-a：是一个	奔驰是一种汽车	`class Benz extends Car`
组合	has-a：有一个	汽车有发动机	在 `Car` 中定义 `Engine` 类型的字段

组合不需要特殊关键字，就是让一个对象持有另一个对象，并使用它提供的功能。

class Engine {
    public void start() {
        System.out.println("发动机启动");
    }
}

class Car {
    private Engine engine = new Engine();

    public void start() {
        engine.start();
        System.out.println("汽车启动");
    }
}

class Benz extends Car {
}

public class Test {
    public static void main(String[] args) {
        Benz car = new Benz();
        car.start();
    }
}

输出：

发动机启动
汽车启动

这里同时存在两种关系：

Benz extends Car：奔驰是一种汽车，复用汽车的行为。
Car 持有 Engine：汽车有发动机，Car.start() 通过 engine.start() 复用发动机的功能。

engine 是 Car 的私有字段，Benz 不能直接访问，但可以通过继承来的 start() 使用这项功能。

注意，单写 private Engine engine; 只声明了引用，默认值是 null，没有创建发动机对象；必须让它指向有效对象后才能调用方法。

选择时先判断关系：“是一种”考虑继承，“有一个”考虑组合。 不要仅为了少写几行代码就强行建立继承关系；同样能满足需求时，优先考虑组合，避免过深的继承链。

九、复习自检

父类和子类有同名字段，父类字段消失了吗？ 没有。子类字段隐藏父类字段，在子类实例方法中可用 super.字段名 明确访问父类字段。
子类有同名方法，就一定调用子类的吗？ 不一定。重载要看参数；对于示例中的重写，可用 super.方法名(...) 调用父类实现。
父类只有有参构造，子类构造什么都不写可以吗？ 不可以。隐式 super() 找不到父类无参构造，需要通过构造调用链选中父类已有的构造方法。
super 能访问父类的 private 成员吗？ 不能，super 不会突破访问权限。
第二次创建子类对象，还执行静态代码块吗？ 不再执行；父子类的实例代码块和构造方法仍会执行。
构造方法能被继承吗？ 不能。调用父类构造方法与继承父类构造方法是两回事。
汽车和发动机应该用继承吗？ 不应该。汽车“有”发动机，适合用组合。

Java 类和对象（二）：包、封装、static 与代码块

Homlander — Wed, 11 Nov 2026 13:51:49 +0000

1. 包：给类分类，也给类名加上范围

项目中的类越来越多时，需要按用途组织；不同地方也可能出现同名的类。包（package）用来组织类，并区分不同包中的同名类。

例如，java.util.Date 和 java.sql.Date 都叫 Date，但它们属于不同的包，是两个不同的类。包名.类名 称为类的全限定名。

1.1 声明包与创建目录

package 表示“当前源文件中的类属于哪个包”，放在源文件开头、import 和类定义之前；前面可以有注释。

package com.bit.demo1;

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

在 IDEA 的普通项目中，对应目录为：

src/
└── com/
    └── bit/
        └── demo1/
            └── Test.java

包名通常使用小写，常按“域名倒写 + 项目或模块名”命名，尽量避免重名。
在 IDEA 中：右键 src → New → Package，输入 com.bit.demo1；再右键包 → New → Java Class 创建类。
IDEA 会创建目录，并自动添加对应的 package 语句。
不写 package 时，类属于默认包。

1.2 使用其他包中的类

方式一：直接写全限定名。

java.util.Date date = new java.util.Date();
System.out.println(date.getTime());

这里 getTime() 返回从 1970 年 1 月 1 日 00:00:00 UTC 到该时间点的毫秒数。此处只用它演示如何使用其他包中的类。

方式二：先用 import 导入类，再写简单类名。

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

二者效果相同。import 只是让当前文件能用简单类名，不会把类复制进当前包，也不会改变访问权限。

源文件中的常见顺序是：

package 声明（如果有）
import 导入（如果有）
类定义

同一个包中的类通常不需要互相导入；java.lang 包中的 String、System 等类也不需要显式导入。

1.3 通配导入与同名冲突

import java.util.*;

* 允许使用该包中可访问的类型的简单名称，不包含子包中的类型。通常更推荐明确写出需要的类，例如 import java.util.Date;。

下面两条导入同时存在时，单独写 Date 会产生歧义：

import java.util.*;
import java.sql.*;

因为两个包都有 Date，编译器不知道要选哪个。可以明确导入需要的那个类；如果两个同名类都要使用，就用全限定名区分，例如：

java.util.Date date = new java.util.Date();

1.4 常见包

包	主要用途
`java.lang`	常用基础类，如 `String`、`Object`，无需显式导入
`java.util`	常用工具类、集合类等，后续会经常使用
`java.io`	输入输出，如文件读写
`java.net`	网络编程
`java.sql`	数据库访问
`java.lang.reflect`	反射，即在程序运行时获取类的信息并操作其成员

这里先认识用途，具体用法在后续章节学习。

2. 访问权限与封装：把数据的使用规则放进类里

2.1 先分清哪些地方能访问成员

访问权限控制其他代码能否直接访问字段或调用方法。本章先掌握以下三种：

成员的访问权限	当前类内部	同包的其他普通类	不同包的普通类
`private`	可以	不可以	不可以
不写访问修饰符（包访问权限）	可以	可以	不可以
`public`	可以	可以	可以

表格以类本身可被访问为前提，暂不涉及继承和嵌套类。

包访问权限有时称为 default 权限，但不是在字段前写 default，而是什么都不写。

另一种访问修饰符是 protected，它涉及继承中的访问规则，留到继承章节再学。

看一个跨包访问的例子。两个类分别放在各自包对应的目录中。

com/bit/demo1/Computer.java：

package com.bit.demo1;

public class Computer {
    private String cpu = "i7";
    String brand = "HW";
    public String screen = "14英寸";

    public void showCpu() {
        System.out.println(cpu); // 当前类内部，可以访问 private 成员
    }
}

com/bit/demo2/TestComputer.java：

package com.bit.demo2;

import com.bit.demo1.Computer;

public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        System.out.println(computer.screen); // 可以：public
        computer.showCpu();                  // 可以：通过公开方法使用私有数据

        // System.out.println(computer.brand); // 错误：不同包，不能访问包权限成员
        // System.out.println(computer.cpu);   // 错误：其他类不能直接访问 private 成员
    }
}

如果把 TestComputer 移到 com.bit.demo1 包中，它就能访问 brand，但仍不能直接访问 cpu。“同一个包”和“同一个类”是两种不同的范围。

2.2 封装解决什么问题

封装就是把数据和操作数据的方法组织在类中，隐藏内部细节，通过对外提供的方法与对象交互。

例如，年龄不应该随意变成负数。如果把 age 设为 public，外部就能直接执行 stu.age = -1;。将它改为 private 后，外部必须经过类提供的方法修改，类就有机会检查数据。

这里的“对外接口”指公开的使用方式，例如方法，不是专指 Java 的 interface 语法。

class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            System.out.println("年龄不能为负数");
            return;
        }
        this.age = age;
    }

    public void show() {
        System.out.println(name + "，" + age + "岁");
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("小明");
        stu.setAge(18);
        stu.setAge(-1); // 被拒绝，年龄仍然是 18
        System.out.println(stu.getAge());
        stu.show();
    }
}

输出：

年龄不能为负数
18
小明，18岁

getXxx() 通常用于读取数据，叫 getter；setXxx(...) 通常用于修改数据，叫 setter。它们都是普通方法，名称是一种约定。
this.age = age; 中，左边是当前对象的字段，右边是方法参数。
private 阻止的是类外直接访问，不影响本类的方法操作这些数据。
不必给每个字段都提供 getter 和 setter。 只开放确实需要的操作；只读数据可以只提供 getter。

2.3 封装的价值

控制数据修改。 外部经过方法修改数据，类可以检查是否合法，减少意外破坏。
简化使用。 使用者只需要知道方法怎么调用，不必了解内部如何实现。
减少相互依赖。 对外方法的用法和约定保持一致时，内部实现的调整通常不需要调用者跟着修改。

封装不是“所有成员一律 private”，也不是“写了 getter/setter 就自动安全”。关键在于：哪些细节隐藏，哪些操作开放，以及开放的操作是否维护了数据规则。

3. static：属于类，还是属于某个对象

3.1 实例变量各有一份，静态变量共同使用一份

学生的姓名因人而异，应当是实例变量。如果当前程序约定所有学生共用一个教室，教室就可以是静态变量。

class Student {
    public String name;
    public static String classRoom = "1-101";
}

public class Test {
    public static void main(String[] args) {
        // 不创建对象，也能访问静态变量
        System.out.println(Student.classRoom);

        Student s1 = new Student();
        Student s2 = new Student();
        s1.name = "小明";
        s2.name = "小红";

        Student.classRoom = "1-102";
        System.out.println(s1.name + "：" + Student.classRoom);
        System.out.println(s2.name + "：" + Student.classRoom);
    }
}

输出：

1-101
小明：1-102
小红：1-102

可以把关系理解为：

s1 对象：name = "小明"
s2 对象：name = "小红"
Student 类共享的数据：classRoom = "1-102"

static 修饰的成员变量又叫静态成员变量、类变量，不在每个对象中各保存一份。它的生命周期与类相关，不会因为某一个对象不再使用就消失。

虽然 Java 允许写 s1.classRoom，但访问的仍然是共享变量，并不是 s1 独有的数据。推荐写 Student.classRoom，明确表示它属于类。

是否使用 static 取决于数据是否真的需要全类共享。如果学生可能属于不同教室，教室就不适合简单地定义成所有学生共享的变量。

3.2 静态方法与静态成员的封装

被 static 修饰的方法叫静态方法、类方法，推荐通过 类名.方法名(...) 调用，不需要先创建对象。

静态成员也受访问权限限制。可以将静态字段设为 private，再按需要提供公开方法：

class Student {
    private static String classRoom = "1-101";

    public static String getClassRoom() {
        return classRoom;
    }

    public static void setClassRoom(String classRoom) {
        Student.classRoom = classRoom;
    }
}

public class Test {
    public static void main(String[] args) {
        Student.setClassRoom("1-102");
        System.out.println(Student.getClassRoom()); // 1-102
    }
}

Student.classRoom 表示类变量；右边的 classRoom 是参数。static 不会让 private 成员变成公开成员。

3.3 为什么静态方法不能直接访问实例成员

实例成员需要先确定“是哪一个对象的”，静态方法本身没有当前对象，所以不能使用 this，也不能直接访问实例成员。

class Student {
    private int age = 18;

    public void show() {
        System.out.println(age);
    }

    public static void test() {
        // System.out.println(age);      // 错误：没有指定对象
        // System.out.println(this.age); // 错误：静态方法中没有 this
        // show();                       // 错误：没有指定调用对象

        Student stu = new Student();
        System.out.println(stu.age);     // 正确：访问 stu 的年龄，且代码位于本类内部
        stu.show();                     // 正确：调用 stu 的实例方法
    }
}

因此，准确说法是：静态方法不能直接访问实例成员，但可以通过具体对象访问有权限访问的实例成员。 main 是静态方法，却能先 new 对象再调用实例方法，原因就在这里。

方法所在环境	直接访问本类静态成员	直接访问当前对象的实例成员	使用 `this`
实例方法	可以	可以	可以
静态方法	可以	不可以，需要具体对象	不可以

3.4 静态变量如何初始化

本章掌握两种常见写法：

// 就地初始化：定义时直接给值
private static String classRoom = "1-101";

另一种是使用静态代码块，适合需要多条语句完成的初始化，下一节说明。

通常不要把静态变量的初始化放进构造方法：构造方法每创建一个对象就会执行，把共享数据放进去赋初值，可能导致每次创建对象都重置共享状态。

3.5 静态导入：省略静态成员前的类名

理解 static 后，再看 import static 就容易了：普通导入让类名可以简写，静态导入让指定类中可访问的静态方法、静态字段可以直接使用名称。

import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public class Test {
    public static void main(String[] args) {
        double result = sqrt(pow(3, 2) + pow(4, 2));
        System.out.println(result); // 5.0
    }
}

pow(a, b) 求 a 的 b 次方，sqrt(x) 求平方根。上面的计算等价于：

double result = Math.sqrt(Math.pow(3, 2) + Math.pow(4, 2));

也可以写 import static java.lang.Math.*;。静态导入只是简化写法，不改变方法的性质；如果省略类名反而难以判断来源，保留类名会更清楚。

4. 代码块：位置不同，执行时机不同

代码块是用 {} 包围的一段代码。本章重点区分普通代码块、实例代码块和静态代码块。同步代码块涉及多线程，留到后续章节学习。

4.1 普通代码块：限制局部变量的作用范围

普通代码块写在方法内部，执行流程走到这里时才执行。

public class Test {
    public static void main(String[] args) {
        {
            int x = 10;
            System.out.println(x);
        }

        // 上一个 x 的作用域已经结束
        int x = 100;
        System.out.println(x);
    }
}

输出依次为 10、100。内层块中的 x 出了块就不能访问，后面的 x 是重新声明的另一个变量。

4.2 实例代码块：每个对象都会执行的初始化

实例代码块也叫构造代码块，写在类内部、方法外部，不加 static。

class Student {
    private String name;

    {
        name = "小明";
        System.out.println("实例代码块");
    }

    public Student() {
        System.out.println("构造方法：" + name);
    }
}

每次执行 new Student()，都会先运行实例代码块，再运行这里的构造方法体：

实例代码块
构造方法：小明

实例代码块用于实例初始化，可以使用 this 和实例成员。
它没有方法名和参数，不能像普通方法那样单独调用。
即使把它写在构造方法定义的后面，执行时也仍然先于该构造方法体。

4.3 静态代码块：类初始化时执行一次

静态代码块写在类内部、方法外部，形式是 static { ... }，通常用于初始化静态数据。

class Student {
    private static String classRoom;

    static {
        classRoom = "1-101";
        System.out.println("静态代码块");
    }
}

静态代码块在类初始化时执行，同一个类正常初始化一次后，不会因为又创建了对象而重复执行。 它不属于某个对象，所以也不能使用 this 或直接访问实例成员。

类初始化可以由首次创建对象、调用该类的静态方法等操作触发。本章示例中的静态变量不是常量，首次访问它也会触发类初始化；因此，不创建对象，也可能执行静态代码块。

“类加载”和“类初始化”不完全相同；这里只需记住：静态代码块中的语句是在运行程序、初始化类时执行的，不是在编译时执行的。

4.4 用一次完整运行看清执行顺序

下面的类不涉及继承，重点观察静态初始化、实例初始化和构造方法体的先后关系。

class Student {
    private static String classRoom = "1-101";
    private String name = "默认姓名";

    static {
        System.out.println("静态块1：" + classRoom);
        classRoom = "1-102";
    }

    static {
        System.out.println("静态块2：" + classRoom);
    }

    {
        System.out.println("实例块：" + name);
        name = "小明";
    }

    public Student() {
        System.out.println("构造方法：" + name);
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("第一次创建");
        Student s1 = new Student();
        System.out.println("第二次创建");
        Student s2 = new Student();
    }
}

输出：

第一次创建
静态块1：1-101
静态块2：1-102
实例块：默认姓名
构造方法：小明
第二次创建
实例块：默认姓名
构造方法：小明

按两个阶段理解：

类初始化阶段，只进行一次。 静态字段先有默认值，再把静态字段的显式初始化和静态代码块按源码出现顺序执行。这里先把 classRoom 设为 "1-101"，再执行静态块1、静态块2。
对象初始化阶段，每个新对象都要进行。 实例字段先有默认值，再把实例字段的显式初始化和实例代码块按源码出现顺序执行，最后执行本例中的构造方法体。

注意：“按源码顺序”是分别在静态初始化阶段、实例初始化阶段内排序，不是把整个类从上到下无差别执行。也不是“所有字段赋值永远先于所有代码块”；同一阶段中，字段的显式初始化与代码块谁写在前，谁先执行。

形式	位置	执行时机	常见用途
普通代码块 `{ ... }`	方法内部	流程执行到该处时	限制局部变量作用域
实例代码块 `{ ... }`	类内、方法外	每次创建对象时	初始化实例数据
静态代码块 `static { ... }`	类内、方法外	类初始化时，一次	初始化类共享的数据

5. 复习自查

1. import 了一个类，就能访问它的所有成员吗？

不能。导入只解决名称使用问题，能否访问还要看访问权限。

2. 静态方法能否使用实例变量？

不能直接使用，但可以通过具体对象访问有权限访问的实例变量；静态方法中不能使用 this。反过来，实例方法可以直接访问本类的静态成员。

3. 创建两个对象，静态代码块、实例代码块、构造方法体分别执行几次？

在本章这种简单类中，若此前尚未初始化该类，静态代码块执行 1 次；实例代码块和构造方法体各执行 2 次。

4. getter/setter 会破坏封装吗？

不会必然破坏封装，它们是对外提供操作的一种方式。关键是按需要开放，并维护数据规则，而不是无条件暴露所有内部状态。

5. 封装后为什么更容易修改代码？

调用者依赖公开方法；在这些方法的用法和约定保持一致的前提下，可以调整类内部的实现，减少对调用者的影响。

Java 类和对象（一）

Homlander — Wed, 11 Nov 2026 13:46:21 +0000

1. 从“完成哪些步骤”到“让哪个对象做什么”

面向过程关注完成一件事需要哪些步骤；面向对象关注由哪些对象参与、每个对象负责什么，以及对象之间如何配合。

例如洗衣服：

面向过程：依次考虑加水、浸泡、搓洗、漂洗、拧干等步骤。
面向对象：把洗衣机看作一个对象，给它放入衣物、设置时间并启动，由洗衣机完成内部的洗涤过程。

面向对象不是没有步骤，而是把相关数据和操作组织到对象中。两者都是解决问题的思路，没有绝对的优劣。

Java 支持面向对象编程，简称 OOP（Object-Oriented Programming）。

2. 类、对象与成员

2.1 类描述“有什么”和“能做什么”

类是一种自定义类型，用来描述一类对象共同具有的属性和行为。

例如描述宠物狗：

要描述的内容	Java 中的表示	例子
属性：有什么数据	成员变量，也叫字段	名字、颜色
行为：能做什么	成员方法	叫、摇尾巴

使用 class 定义类：

public class PetDog {
    public String name;
    public String color;

    public void bark() {
        System.out.println(name + "：汪汪汪！");
    }

    public void wag() {
        System.out.println(name + "：摇尾巴！");
    }
}

成员变量定义在类中、方法外；方法内部声明的变量是局部变量。
类名使用大驼峰，例如 PetDog、WashMachine；变量名和方法名通常使用小驼峰。
本章的成员统一使用 public，表示允许外部访问；访问权限的完整规则后续再学。
上面的成员方法不加 static，需要通过具体对象调用。

通常一个源文件放一个类。上面的 public 类必须保存在 PetDog.java 中；如果修改类名，文件名也要同步修改，使用开发工具的重命名功能更稳妥。

2.2 类是模板，对象是具体实例

PetDog 描述宠物狗有哪些数据、能做哪些事；“阿黄”和“赛虎”则是根据这个类创建出的两个具体对象。

可以把类理解成房屋设计图，把对象理解成按图建造的房屋：一张设计图能建多套房屋，一个类也能创建多个对象。 每个对象都有自己的实例成员变量。

定义类只是定义类型，不等于已经创建了这个类的对象。

3. 创建对象并访问成员

3.1 用 `new` 实例化对象

通过类创建对象的过程叫实例化。

PetDog dog = new PetDog();

这条语句可以拆开理解：

部分	含义
`PetDog`	变量的类型
`dog`	引用变量，用来引用对象
`new PetDog()`	创建并初始化一个 `PetDog` 对象
`=`	将新对象的引用赋给 `dog`

引用变量不是对象本身。 可以把引用暂时理解成“找到对象的线索”。

PetDog dog;        // 只声明局部引用变量，没有创建对象，也还不能读取它
dog = new PetDog(); // 创建对象，把引用赋给 dog

3.2 用 `.` 访问成员

访问格式：

引用.成员变量
引用.成员方法(实参)

将下面的代码保存为 Main.java，与前面的 PetDog.java 放在同一目录：

public class Main {
    public static void main(String[] args) {
        PetDog dog1 = new PetDog();
        dog1.name = "阿黄";
        dog1.color = "黄色";

        PetDog dog2 = new PetDog();
        dog2.name = "赛虎";
        dog2.color = "黑色";

        dog1.bark();
        dog2.wag();

        dog1.color = "白色";
        System.out.println(dog2.color);
    }
}

输出：

阿黄：汪汪汪！
赛虎：摇尾巴！
黑色

两次 new 创建了两个对象，修改 dog1 所引用对象的颜色，不会改变另一个对象的颜色。

3.3 `null` 不是“空对象”

PetDog dog = null;

这表示 dog 没有引用任何对象，不是创建了一个内容为空的对象。此时不能通过 dog 访问实例成员，否则会出现空指针异常。

一个引用变量在同一时刻只能引用一个对象，或者为 null；它不能同时指向多个对象。

4. `this`：当前对象的引用

4.1 为什么 `year = year` 没有修改成员变量？

假设日期类有成员变量 year，方法也有同名参数：

public void setDate(int year, int month, int day) {
    year = year;
    month = month;
    day = day;
}

这里的参数遮蔽了同名成员变量，year = year 的左右两边都指向参数，相当于把参数赋给它自己，对象中的成员变量没有变化。

解决办法是用 this.成员变量 明确指出对象中的字段：

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(this.year + "-" + this.month + "-" + this.day);
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        Date d2 = new Date();

        d1.setDate(2021, 6, 9);
        d2.setDate(2022, 7, 10);

        d1.printDate();
        d2.printDate();
    }
}

输出：

2021-6-9
2022-7-10

以 this.year = year 为例：

左边 this.year：当前对象的成员变量。
右边 year：本次调用传入的参数。

4.2 谁调用方法，`this` 就引用谁

执行 d1.setDate(...) 时，方法里的 this 引用 d1 所引用的对象。
执行 d2.setDate(...) 时，方法里的 this 引用 d2 所引用的对象。

所以，同一个成员方法能够处理不同对象的数据。调用时不需要额外传入 this，Java 会隐式提供当前对象的引用；也不要在普通参数列表里手动添加所谓的 this 参数。

在没有同名局部变量或参数遮蔽时，访问当前对象的成员可以省略 this。例如上面 printDate() 中的 this.year 可以简写成 year。

记住以下用法与限制：

写法或规则	含义
`this.成员变量`	访问当前对象的成员变量
`this.成员方法(实参)`	调用当前对象的成员方法
`this` 的类型	在本例中是 `Date` 类型
不能写 `this = ...`	不能让 `this` 改为引用另一个对象
`static` 方法中不能使用 `this`	静态方法不依附于某一个对象，没有当前对象

main 是 static 方法，因此需要先创建对象，再通过引用访问实例成员。this 也能用于构造方法，下面会用到。

5. 对象中的数据如何初始化？

5.1 成员变量有默认值，局部变量不能照搬

局部变量必须在读取前被赋值：

int a;
// System.out.println(a); // 编译错误：变量 a 可能尚未初始化

但对象的成员变量会自动获得默认值：

成员变量类型	默认值
`byte`、`short`、`int`	`0`
`long`	`0L`
`float`	`0.0f`
`double`	`0.0d`
`char`	`'\u0000'`，不是字符 `'0'`，也不是空格
`boolean`	`false`
引用类型，如 `String`、数组、自定义类	`null`

使用上一节中尚未定义构造方法的 Date 类：

Date d = new Date();
d.printDate(); // 0-0-0

d 这个局部变量已被赋予对象引用，而对象中的三个 int 字段获得了默认值 0。

注意：String 字段的默认值是 null，不是空字符串 ""；日期字段默认为 0，也不代表这个日期有实际意义。

5.2 就地初始化：声明字段时直接赋值

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
}

此时执行 new Date()，得到的日期数据是 1900、1、1。

这种方式适合为对象设置统一的初始数据。如果希望创建不同日期的对象时直接传入不同的年月日，就需要构造方法。

5.3 构造方法：创建对象时完成初始化

构造方法也叫构造器，用来在创建对象时执行初始化操作。

public class Date {
    public int year;
    public int month;
    public int day;

    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date d = new Date(2021, 6, 9);
        d.printDate(); // 2021-6-9
    }
}

执行 new Date(2021, 6, 9) 时，会调用参数匹配的构造方法。这样，对象创建完成时就已有需要的数据，不必再单独调用 setDate()。

构造方法的两个关键语法要求：

名字必须与类名完全相同。
没有返回值类型，连 void 也不能写。

public Date() { }      // 构造方法
public void Date() { } // 普通方法，不是构造方法

构造方法随对象创建而调用，不能写成 d.Date(...)，也不能在对象创建完成后再次调用它来重新初始化对象。后续若要修改日期，可以调用普通的 setDate() 方法。

本章使用 public 构造方法；private 构造方法属于后续特殊用法，此处不展开。

5.4 默认构造方法：什么情况下会自动生成？

只有一个类没有声明任何构造方法时，编译器才会提供默认的无参构造方法。

类中自己写了什么	是否自动提供默认无参构造方法	能否使用 `new Date()`
没写任何构造方法	是	可以
只写了有参构造方法	否	不可以
自己写了无参构造方法	否	可以，调用自己写的那个

例如，5.3 节的 Date 只有三个参数的构造方法：

Date d1 = new Date(2021, 6, 9); // 正确
// Date d2 = new Date();       // 编译错误：没有匹配的无参构造方法

解决办法是传入所需参数，或者自己补写无参构造方法。这是编译错误，不是运行后才发现的问题。

另外，成员变量的默认值不依赖编译器生成的默认构造方法。即使自己写了构造方法，字段也会先获得默认值。

5.5 构造方法重载与 `this(...)`

一个类可以提供多个参数列表不同的构造方法，让对象有不同的创建方式：

public class Date {
    public int year;
    public int month;
    public int day;

    public Date() {
        this(1900, 1, 1);
    }

    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        Date d2 = new Date(2021, 6, 9);
        d1.printDate(); // 1900-1-1
        d2.printDate(); // 2021-6-9
    }
}

这两个构造方法构成重载。new Date() 进入无参构造方法后，this(1900, 1, 1) 会调用本类的三个参数构造方法，复用赋值代码。

执行顺序：

new Date()
    → 进入无参构造方法
    → this(1900, 1, 1) 调用三参数构造方法
    → 给当前对象的 year、month、day 赋值
    → 返回无参构造方法，继续执行剩余语句
    → 对象初始化完成

整个过程只创建了一个对象。所以，不能简单理解成“创建一个对象时只可能执行一个构造方法”；多个构造方法可以通过 this(...) 配合完成同一个对象的初始化。

沿用本章课件的语法规则，this(...)：

只能在构造方法中使用，并放在第一条语句。
调用的是本类其他构造方法，不会新建对象。
不能直接或间接形成循环调用。

下面的片段会编译失败，因为两个构造方法互相调用：

public Date() {
    this(1900, 1, 1);
}

public Date(int year, int month, int day) {
    this();
}

不要混淆：this.year 是访问字段，this.printDate() 是调用普通成员方法，this(...) 是调用本类构造方法。

5.6 把初始化顺序串起来

对本章这种普通类，只看当前对象的实例字段，顺序是：

默认初始化 → 就地初始化 → 构造方法中的赋值。

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;

    public Date(int year, int month, int day) {
        System.out.println(this.year + "-" + this.month + "-" + this.day);
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public static void main(String[] args) {
        Date d = new Date(2021, 6, 9);
        System.out.println(d.year + "-" + d.month + "-" + d.day);
    }
}

输出：

1900-1-1
2021-6-9

字段的变化过程：

阶段	`year`	`month`	`day`
默认初始化	0	0	0
就地初始化后	1900	1	1
构造方法赋值后	2021	6	9

传入参数不等于自动给字段赋值。 如果把构造方法体留空，即使写了 new Date(2021, 6, 9)，字段仍然是就地初始化得到的 1900、1、1。必须通过 this.year = year 等语句把参数保存到对象中。

6. 打印对象：`toString()`

直接打印自定义对象的引用：

System.out.println(person);

如果没有自定义 toString()，通常会看到类似内容：

Person@1b6d3586

默认格式是 类的全限定名 + @ + 哈希码的十六进制表示。全限定名包含类所属的包名；没有包名时就是类名。后面的数字不应直接当作对象的内存地址，也不需要背下来。

如果希望打印对象的属性，就在类中重写 toString()：

public class Person {
    public String name;
    public String gender;
    public int age;

    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
    }

    public static void main(String[] args) {
        Person person = new Person("Jim", "男", 18);
        System.out.println(person);
    }
}

输出：

[Jim,男,18]

这里先掌握三点即可：

Java 的 Object 类提供了默认的 toString()；这里的“重写”可以先理解为，为当前类重新提供对象转成字符串的实现，继承与重写的完整规则后续再学。
@Override 是一个标记，让编译器检查是否正确重写了已有方法。
toString() 要返回字符串，不能改成 void，也不要只在里面打印而不返回。打印非空对象引用时，println 会使用它返回的字符串。

7. 用本章练习检查易错点

7.1 判断下面的说法

说法	判断与原因
一个类只能实例化一个对象	错。一个类可以创建多个对象
一个引用可以同时指向多个对象	错。一个引用变量在同一时刻只能引用一个对象，或为 `null`
`Person p = null;` 表示引用指向一个空对象	错。`null` 表示没有引用任何对象
类中没写构造方法，就不会有构造方法	错。此时编译器会提供默认无参构造方法

7.2 创建对象时，参数必须匹配构造方法

如果 Person 类只提供了下面这个构造方法：

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

那么：

// Person p1 = new Person();           // 错：没有无参构造方法
// Person p2 = new Person("zhangfei"); // 错：没有只接收 String 的构造方法
Person p3 = new Person("lisi", 9);     // 正确

最直接的修改方式是按已有构造方法传参：

Person p1 = new Person("zhangsan", 10);
Person p2 = new Person("zhangfei", 10);
Person p3 = new Person("lisi", 9);

如果确实需要无参或单参数的创建方式，则应补写对应的构造方法。不能指望先用不存在的构造方法创建对象，再通过赋值补救。

Java 数组的定义与使用

Homlander — Wed, 11 Nov 2026 13:46:03 +0000

1. 用一个数组管理一组数据

数组用于保存一组相同类型的数据。例如，保存 5 个学生的成绩，不必分别定义 5 个变量：

int[] scores = {70, 80, 85, 60, 90};

这里，int[] 是数组类型，scores 是数组变量，数组中有 5 个 int 元素。

可以把数组理解为一排连续编号的格子：每个格子保存一个元素，通过编号直接访问。这个编号叫作下标（索引），从 0 开始。

下标：  0   1   2   3   4
元素： 70  80  85  60  90

一个数组创建后，长度就固定了；元素的值可以修改。

1.1 创建与初始化

动态初始化：指定长度，元素先使用默认值。

int[] numbers = new int[3];        // 3 个 int 元素，初始值都是 0
double[] prices = new double[5];   // 5 个 double 元素
String[] words = new String[3];    // 3 个 String 元素

通用格式是 元素类型[] 数组名 = new 元素类型[长度];。new 在这里用于创建数组。

“动态初始化”并不意味着长度可以随意增长，而是创建时指定长度。

静态初始化：直接给出元素，长度由元素个数决定。

int[] a = new int[]{10, 20, 30};
int[] b = {10, 20, 30};            // 声明时可以简写
String[] words = {"Hello", "Java"};

元素值必须能赋给数组的元素类型。指定元素时，不再在方括号中填写长度：

// 错误：不能同时指定长度和初始化列表
// int[] a = new int[3]{10, 20, 30};

声明和赋值可以分开，但分开后不能只写 {...}：

int[] a;
a = new int[3];
a = new int[]{10, 20, 30};

// 错误：这种简写只能在声明时使用
// a = {10, 20, 30};

int a[] 也是合法写法，但推荐 int[] a，更容易看出变量的类型是 int[]。

1.2 数组元素的默认值

使用 new 类型[长度] 创建数组后，即使没有逐个赋值，元素也已经有默认值：

元素类型	默认值
`byte`、`short`、`int`、`long`	`0`
`float`	`0.0f`
`double`	`0.0`
`char`	`'\u0000'`，不是字符 `'0'`，也不是空格
`boolean`	`false`
引用类型，例如 `String`	`null`，表示没有引用对象

注意区分：int[] a; 只是声明了局部变量，没有创建数组，也不能直接使用这个尚未赋值的变量；int[] a = new int[3]; 才创建了包含 3 个零的数组。

1.3 访问元素与获取长度

int[] a = {10, 20, 30};
System.out.println(a[0]);      // 10：读取第一个元素
a[1] = 99;                    // 修改第二个元素
System.out.println(a[1]);      // 99
System.out.println(a.length); // 3

a.length 是元素个数，没有括号。
合法下标为 0 到 a.length - 1。
最后一个元素是 a[a.length - 1]，不是 a[a.length]。

对于上面的数组，访问 a[3] 或 a[-1] 都会发生 ArrayIndexOutOfBoundsException（数组下标越界异常）。异常可以先理解为程序运行时报告的错误。

1.4 遍历数组

遍历就是依次访问数组中的所有元素。

需要下标或需要修改元素时，用普通 for 循环：

int[] a = {10, 20, 30};
for (int i = 0; i < a.length; i++) {
    a[i] += 1;
    System.out.println(a[i]); // 依次输出 11、21、31
}

条件写成 i < a.length，不能写成 i <= a.length；使用 a.length 也比把长度写死更方便。

只需要依次读取元素时，可以用增强 for（for-each）：

int[] a = {10, 20, 30};
for (int x : a) {
    System.out.println(x);
}

每次循环，x 都取得当前元素的值，它不是下标。对于这里的 int 数组，给 x 赋值只会改变循环变量，不会修改数组元素；要修改元素，应使用 a[i]。

1.5 一次打印整个数组

Arrays 是 java.util 包中的数组工具类，提供了操作数组的方法。使用前在 Java 文件的类定义上方写：

import java.util.Arrays;

Arrays.toString(a) 把一维数组的内容转换成便于阅读的字符串：

int[] a = {10, 20, 30};
String text = Arrays.toString(a);
System.out.println(text); // [10, 20, 30]

直接 System.out.println(a) 不会按上面的形式输出数组元素。

2. 数组变量保存的是引用

2.1 先分清“变量”和“数组对象”

int number = 10;
int[] a = {1, 2, 3};

number 是基本类型变量，直接保存数值 10。
a 是引用类型变量，保存的是数组对象的引用，不是三个元素本身。

引用可以暂时理解为找到对象的“地址线索”，不必把它当成可直接操作的真实内存地址。

number 中保存：10
a 中保存的引用 ──→ 数组对象 [1, 2, 3]

JVM（Java 虚拟机）负责运行 Java 程序，其运行时内存按用途划分：

区域	本章需要知道的作用
虚拟机栈	方法调用时创建栈帧，保存局部变量等执行信息；方法结束时对应栈帧出栈
堆	存放数组等对象
程序计数器	记录当前线程执行字节码的位置
本地方法栈	为本地方法服务；本地方法是由 Java 以外的语言实现的方法
方法区	保存类信息、方法字节码等数据

本章重点是栈和堆。 按这里的入门模型，方法内的局部变量 number、a 位于该方法的栈帧中，而 a 引用的数组对象位于堆中。其他区域的内部细节暂不展开。

2.2 数组赋值不会复制元素

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

System.out.println(a[0]); // 99

b = a 复制的是引用，因此两个变量指向同一个数组：

a ──┐
    ├──→ [99, 2, 3]
b ──┘

通过 a 或 b 修改元素，改的都是同一个数组对象。

但重新给引用变量赋值，只会改变这个变量的指向：

b = new int[]{7, 8};
System.out.println(a[0]);     // 99：a 仍指向原数组
System.out.println(b[0]);     // 7：b 指向新数组
System.out.println(a.length); // 3
System.out.println(b.length); // 2

这里不是原数组长度从 3 变成了 2，而是 b 改为引用另一个数组。

2.3 `null`：目前没有引用任何数组

int[] a = null;
// System.out.println(a[0]);     // 空指针异常
// System.out.println(a.length); // 空指针异常

null 表示空引用。此时没有可访问的数组对象，读取元素或长度会发生 NullPointerException（空指针异常）。null 也不等于数值 0。

要区分下面两种情况：

写法	含义
`int[] a = null;`	没有引用数组，不能读取 `a.length`
`int[] a = new int[0];`	引用了长度为 0 的数组，`a.length` 为 0，但没有可访问的元素

3. 数组与方法配合使用

下面的 public static 方法定义在类中，与 main 并列；调用语句放在 main 等方法内部。

3.1 作为参数：传入的是引用的副本

Java 的参数传递都是值传递：基本类型复制数值，引用类型复制引用值。

先看基本类型：

public static void changeNumber(int x) {
    x = 10;
}

int number = 0;
changeNumber(number);
System.out.println(number); // 0

形参 x 和变量 number 各自保存一份数值，修改 x 不影响 number。

再看数组：

public static void changeArray(int[] a) {
    a[0] = 10;
}

int[] arr = {1, 2, 3};
changeArray(arr);
System.out.println(arr[0]); // 10

形参 a 得到了 arr 中引用的副本，二者仍指向同一个数组，所以 a[0] = 10 会改变外部看到的元素。

如果只是让形参指向新数组，外部变量不会跟着改变：

public static void replaceArray(int[] a) {
    a = new int[]{7, 8, 9};
}

int[] arr = {1, 2, 3};
replaceArray(arr);
System.out.println(arr[0]); // 1

记住：a[i] = ... 修改数组元素；a = ... 修改形参自己的引用值。 传递数组时也不需要复制整组元素。

3.2 作为返回值：返回一组计算结果

方法的返回类型写成 int[]，就可以返回一个整型数组的引用。

例如，生成斐波那契数列的前 n 项：前两项为 1、1，从第三项开始，每项等于前两项之和。

public static int[] fib(int n) {
    if (n <= 0) {
        return null;
    }

    int[] result = new int[n];
    result[0] = 1;
    if (n >= 2) {
        result[1] = 1;
    }

    for (int i = 2; i < n; i++) {
        result[i] = result[i - 1] + result[i - 2];
    }
    return result;
}

调用：

int[] result = fib(6);
if (result != null) {
    System.out.println(Arrays.toString(result)); // [1, 1, 2, 3, 5, 8]
}

n == 1 时只能访问 result[0]，不能直接给 result[1] 赋值。
本例约定 n <= 0 返回 null，调用方使用前先判断。
方法结束后，局部变量会离开作用域，但返回的数组仍被调用方引用，因此还能使用。
本例使用 int，只适合结果未超出 int 范围的项数；从第 47 项开始会溢出。

4. 数组拷贝：创建一份独立的数组

4.1 `Arrays.copyOf` 与 `Arrays.copyOfRange`

b = a 只复制引用。如果需要独立修改一个 int 数组，可以创建新数组并复制元素：

int[] a = {10, 20, 30, 40};
int[] b = Arrays.copyOf(a, a.length);
b[0] = 99;

System.out.println(Arrays.toString(a)); // [10, 20, 30, 40]
System.out.println(Arrays.toString(b)); // [99, 20, 30, 40]

Arrays.copyOf(原数组, 新长度) 的第二个参数是新数组的长度。新长度较小时截取前面的元素，较大时多出来的 int 元素为 0；原数组的长度不变。

复制部分元素可以使用：

int[] part = Arrays.copyOfRange(a, 1, 3);
System.out.println(Arrays.toString(part)); // [20, 30]

范围是 [起始下标, 结束下标)，左闭右开。因此 [1, 3) 复制下标 1、2，不包含下标 3。

4.2 用循环实现拷贝

public static int[] copyOf(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[i];
    }
    return result;
}

关键是先 new 一个数组，再逐个复制元素；如果直接 return arr，返回的仍是原数组的引用。

以上“修改互不影响”针对 int[] 这样的基本类型数组。若元素本身是引用，复制元素时复制的仍是引用，涉及的对象可能继续共享；这属于后续的深浅拷贝问题，本章不展开。

5. 用数组练习查找、排序与逆序

以下方法均假定传入的数组不是 null；长度为 0 的数组可以正常处理。

5.1 顺序查找：从头逐个比较

不要求数组有序。找到目标就返回下标，全部检查后仍没找到则返回 -1。

public static int find(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

int[] arr = {1, 2, 3, 10, 5, 6};
System.out.println(find(arr, 10)); // 3
System.out.println(find(arr, 8));  // -1

-1 不是合法下标，适合表示未找到。它必须放在循环结束之后：当前元素不相等，不代表后面也没有。若目标出现多次，这个方法返回第一次出现的位置。

5.2 二分查找：每次排除一半范围

前提：数组已经有序。下面的代码只适用于升序数组。 升序指元素从小到大排列，允许相等；降序则相反。

用 left、right 表示待查找范围的左右边界，两端都包含在范围内。取中间下标 mid：

目标小于 arr[mid]：目标只可能在左半边，令 right = mid - 1。
目标大于 arr[mid]：目标只可能在右半边，令 left = mid + 1。
相等：返回 mid。

public static int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (target < arr[mid]) {
            right = mid - 1;
        } else if (target > arr[mid]) {
            left = mid + 1;
        } else {
            return mid;
        }
    }
    return -1;
}

例如，在 {1, 2, 3, 4, 5, 6} 中查找 6：

轮次	`left`	`right`	`mid`	比较与下一步
1	0	5	2	`6 > 3`，令 `left = 3`
2	3	5	4	`6 > 5`，令 `left = 5`
3	5	5	5	`6 == 6`，返回下标 `5`

三个边界要理解：

left == right 时还有一个元素没检查，所以循环条件是 <=。
中间元素已经比较过，下一轮必须排除它，因此使用 mid - 1 或 mid + 1。
left > right 表示范围为空，才确定未找到。

left + (right - left) / 2 能避免直接计算 left + right 可能造成的整数溢出。每轮约缩小一半范围，对 10000 个元素最多约需比较 14 次。若有重复目标值，这个实现不保证返回第一次出现的位置。

5.3 冒泡排序：把较大的元素逐步换到右边

按升序排序时，从左到右比较相邻元素；前面的更大就交换。一趟结束后，尚未排好部分的最大值会到达该部分最右端。

以 {9, 5, 2, 7} 的第一趟为例：

[9, 5, 2, 7]
 交换 9 和 5 → [5, 9, 2, 7]
 交换 9 和 2 → [5, 2, 9, 7]
 交换 9 和 7 → [5, 2, 7, 9]

9 已到最终位置，下一趟只需处理前 3 个元素；第二趟后得到 [2, 5, 7, 9]。

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

i 表示已经完成的趟数，最多需要 长度 - 1 趟。
每完成一趟，右侧多一个已就位的元素，因此内层范围减去 i。
内层要访问 arr[j + 1]，所以条件为 j < arr.length - 1 - i。
交换时用 temp 暂存原值，避免赋值覆盖后丢失数据。
若要降序，将比较条件改为 arr[j] < arr[j + 1]。

调用后，原数组会直接改变：

int[] arr = {9, 5, 2, 7};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // [2, 5, 7, 9]

冒泡排序便于理解，但效率较低。需要排序时，可以使用工具方法：

int[] arr = {9, 5, 2, 7};
Arrays.sort(arr); // 直接把原 int 数组按升序排列
System.out.println(Arrays.toString(arr)); // [2, 5, 7, 9]

Arrays.sort 的内部排序算法留到后续学习，本章掌握调用方式即可。

5.4 数组逆序：两端向中间交换

逆序是把原来的先后顺序颠倒，不等于降序排序。例如，{3, 1, 2} 逆序后是 {2, 1, 3}。

public static void reverse(int[] arr) {
    int left = 0;
    int right = arr.length - 1;

    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

例如，{1, 2, 3, 4} 先交换首尾，得到 {4, 2, 3, 1}，再交换中间两个元素，得到 {4, 3, 2, 1}。

每次交换后两端各向中间移动一步。相遇时是同一个元素，无需交换，因此条件为 left < right。

6. 二维数组：数组的元素也是数组引用

6.1 创建、访问与长度

二维数组可以按“行、列”理解，但本质是：外层数组的每个元素，保存着一个一维数组的引用。

int[][] a = new int[2][3]; // 2 行，每行 3 个 int，初始值均为 0

也可以直接给出数据：

int[][] a = {
    {1, 2, 3},
    {4, 5, 6}
};

完整写法可以使用 new int[][]{{1, 2, 3}, {4, 5, 6}}，但不能写成 new int[2][3]{{...}, {...}}。

System.out.println(a[0][1]); // 2：第 1 行、第 2 列
a[1][2] = 99;
System.out.println(a[1][2]); // 99
System.out.println(a.length);    // 2：外层长度，即行数
System.out.println(a[0].length); // 3：第 0 行的长度

a[row][col] 可以分两步看：先由 a[row] 找到这一行的数组，再用 [col] 取出该行中的元素。行下标和列下标都从 0 开始，都不能越界。

6.2 遍历二维数组

外层循环遍历行，内层循环遍历当前行的元素：

int[][] a = {
    {1, 2, 3},
    {4, 5, 6}
};

for (int row = 0; row < a.length; row++) {
    for (int col = 0; col < a[row].length; col++) {
        System.out.print(a[row][col] + " ");
    }
    System.out.println(); // 一行输出完后再换行
}

输出：

1 2 3
4 5 6

内层条件必须看 a[row].length，它表示当前行的列数；a.length 表示的是行数。

6.3 不规则二维数组

每一行都是独立的一维数组，所以各行长度可以不同：

int[][] a = new int[2][];
a[0] = new int[3];
a[1] = new int[5];

a[0] ──→ [0, 0, 0]
a[1] ──→ [0, 0, 0, 0, 0]

也可以直接初始化：

int[][] a = {
    {1, 2, 3},
    {4, 5, 6, 7, 8}
};

需要注意：

按长度创建时，可以写 new int[2][]，但不能写 new int[][3]。
只执行 new int[2][] 时，外层数组已创建，但两个元素都是 null；此时不能访问 a[0][0] 或 a[0].length。
为每行创建数组后，前面的双重循环同样适用，因为它使用的是各行自己的长度。

7. 复习时抓住这几组区别

容易混淆的操作	实际含义
`a.length` / `a.length - 1`	元素个数 / 最后一个元素的下标（非空数组）
`b = a` / `Arrays.copyOf(a, a.length)`	共享同一个数组 / 创建新数组并复制元素
`a[i] = value` / `a = new int[...]`	修改原数组元素 / 让变量引用另一个数组
数组传参时修改元素 / 给形参重新赋值	外部可见元素变化 / 外部变量的指向不变
顺序查找 / 二分查找	不要求有序 / 本文实现要求升序
排序 / 逆序	按大小排列 / 颠倒原有先后顺序
`a.length` / `a[row].length`（二维数组）	行数 / 当前行的列数

07 Java 调试案例讲解

Homlander — Wed, 11 Nov 2026 13:40:03 +0000

一、调试究竟在做什么

调试（Debugging）就是查找并改正程序错误的过程。 核心是观察程序的实际执行过程，逐步缩小问题范围，找到“从哪一步开始，实际结果与预期不一致”。

常见方式有两种：

阅读代码、添加打印语句：代码较少时，按执行顺序检查，或用 System.out.println() 输出中间结果。
使用调试器：让程序在指定位置停下来，查看变量，再控制它一步步执行。代码较复杂、需要反复观察时更方便。

以下使用 IntelliJ IDEA，Java 环境沿用课件中的 JDK 17。快捷键按课件的 Windows 键位说明；若自行修改过键位，以按钮提示为准。

二、先让程序在断点处停下来

1. 准备示例

新建 Test.java，后面的操作都围绕这段代码展开：

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);       // 断点 A
        System.out.println(ret);  // 断点 B，后面再添加
    }

    public static int add(int x, int y) {
        System.out.println("进入 add");
        return x + y;
    }
}

正常运行时输出：

进入 add
30

2. 设置断点并启动 Debug

断点是告诉调试器“执行到这里先停一下”的标记。

在 int ret = add(a, b); 所在行的行号旁边单击，出现红点，即设置了断点 A。
在编辑区右键，选择 Debug 'Test.main()'。
程序运行到断点 A 时暂停，下方出现 Debug 窗口。

再次单击红点可以删除该断点。要让断点起作用，应使用 Debug 启动。

3. 看懂“停在这一行”

刚命中行断点时，该行通常还没有执行。

本例停在断点 A 时：

a = 10、b = 20 已执行，可以查看它们的值。
add(a, b) 尚未执行，ret 还没有完成初始化。
控制台还没有输出“进入 add”和 30。

红点表示断点位置，执行高亮表示程序当前停留的位置。判断某个结果为什么还没出现，先检查产生结果的语句是否已经执行。

三、暂停后先看什么

1. Debugger：看变量和调用堆栈

变量区显示当前选中方法中的变量及其值。例如，停在 main 中可以查看 a、b；进入 add 后，可以查看 x、y。

调用堆栈表示当前有哪些方法正在调用、等待返回。例如：

add:行号
main:行号

表示 main 调用了 add，当前正在执行 add，main 正在等待它返回。最上方通常是当前执行的方法，下面是调用它的方法。

点击不同的方法记录，可以查看该次调用对应的变量。后面的数字是代码行号，不是调用次数。

2. 表达式求值与监视

程序暂停时，在 Debugger 中的 Evaluate expression ... or add a watch 输入区域填写表达式，按回车可查看结果。

例如停在 add 方法内部、x = 10、y = 20 时：

x + y        // 结果：30
(x + y) * 2  // 结果：60

求值：临时计算一次，检查当前结果。
监视（Watch）：把表达式加入监视列表，后续暂停时方便反复查看。

表达式中的变量必须在当前查看的位置可用。例如选中 add 时使用 x、y，选中 main 时使用 a、b。

3. Console：看输入输出

Console 显示控制台的输入输出，Debugger 用来观察执行状态。

只有输出语句执行之后，Console 才会出现对应内容。程序停在 System.out.println(ret); 这一行时，并不表示 30 已经打印。

四、用单步操作控制执行过程

1. 先区分四个操作

操作	快捷键	作用
Step Over（步过／逐过程）	`F8`	执行当前行；遇到方法调用时，通常不进入方法内部逐步查看
Step Into（步入／逐语句）	`F7`	进入当前行调用的方法，查看内部执行过程
Force Step Into（强制步入）	`Alt + Shift + F7`	进入普通步入可能因过滤规则而跳过的方法
Step Out（步出／跳出）	`Shift + F8`	执行完当前方法剩余部分，返回调用它的位置

2. 用同一段代码理解 F8、F7 和 Shift + F8

情况一：只关心方法的返回结果，用 F8。

停在断点 A 时按 F8，add(a, b) 会正常执行。到达下一行 System.out.println(ret); 时：

ret = 30。
Console 已输出“进入 add”。
30 还没输出，再执行当前行才会输出。

步过只是通常不进入方法内部逐步查看，方法本身仍然执行。 如果方法内部另有断点，也可能在内部停下来。

情况二：想检查方法内部的计算过程，用 F7。

重新调试，在断点 A 按 F7：

进入 add，停在 System.out.println("进入 add");。
变量区可以看到 x = 10、y = 20。
按 F8，执行打印语句，停在 return x + y;。
此时可以求值 x + y，确认结果为 30。
继续执行返回语句，返回 main；调用及赋值完成后，ret 才得到 30。

情况三：已经进入方法，但不想继续逐行看，用 Shift + F8。

如果刚进入 add 就使用步出，剩余的打印和 return 仍会执行，然后回到 main 的调用位置。

步出不会取消这次调用，也不会丢掉剩余代码。 返回后界面可能仍高亮调用所在行，继续单步即可观察后续赋值和输出。

3. 强制步入用在什么地方

普通 F7 可能按调试器的过滤规则跳过某些 Java 类库方法，例如 System.out.println() 的内部实现。确实需要查看这些方法时，可以使用 Alt + Shift + F7。

“强制”是指绕过普通步入的过滤规则，并不意味着任何方法都一定有可供查看的源码。本章只需掌握它与普通步入的区别。

上述步进操作的含义可对照 IDEA 官方说明。

五、不想逐行执行时怎么做

1. 继续运行到下一个断点：F9

在 System.out.println(ret); 这一行再设置断点 B。

程序停在断点 A 时，按 F9（Resume Program），程序继续正常执行，命中断点 B 后暂停。此时 ret = 30，但 30 尚未打印。

如果后续没有命中其他断点，程序就会继续运行，直到结束或因其他原因暂停。

“到下一个断点”按实际执行顺序判断，不是按编辑器中红点的上下顺序判断。

2. 运行到光标处：Alt + F9

只想临时运行到某一行，可以：

在程序暂停时，把编辑光标放到目标代码行。
按 Alt + F9（Run to Cursor）。

例如停在断点 A 时，把光标放到 System.out.println(ret);，执行后会在这行暂停，便于查看 ret。

目标位置之前的代码仍会执行；如果途中先命中其他断点，会先在那个断点暂停。目标行也必须是本次执行能够到达的位置。

3. 重新调试与停止

操作	快捷键	含义
Rerun（重新调试）	`Ctrl + F5`	从头重新启动当前调试配置，适合重新观察执行过程
Stop（停止）	`Ctrl + F2`	终止当前程序，结束这次运行

Ctrl + F2 是停止，不是可继续执行的暂停。 停止之后，要再次运行就需要重新启动。参见 IDEA 调试会话说明。

六、管理断点与设置条件断点

1. 查看、禁用和屏蔽断点

View Breakpoints：Ctrl + Shift + F8。集中查看、编辑、启用、禁用或删除断点。
Mute Breakpoints（屏蔽断点）：在 Debug 工具栏点击该按钮，临时屏蔽所有断点；再次点击可解除屏蔽。断点仍然保留，不需要重新添加。

禁用适合暂时保留某个断点，删除适合不再需要的断点，屏蔽适合临时让程序不因这些断点而停下。

2. 条件断点：只在关心的那一次暂停

循环执行很多次时，普通断点会反复暂停。如果只想检查 i == 20 的情况，可以设置条件断点。

把 main 方法中的代码替换为：

for (int i = 0; i < 100; i++) {
    System.out.println(i); // 在这一行设置断点
}

操作步骤：

在 System.out.println(i); 行设置断点。
右键单击断点红点，在 Condition 中填写 i == 20。
启动 Debug。

程序会正常执行前面的循环，直到 i == 20 时，才在该断点暂停。此时：

Debugger 中的 i 为 20。
Console 已输出 0 到 19。
20 还没有输出，因为当前打印语句尚未执行。

条件应是结果为 true 或 false 的表达式。这里写 i == 20，不是赋值表达式 i = 20，也不需要写 if 或分号。

条件断点只控制是否暂停，不会让条件不满足时的代码停止执行。

七、把调试操作用来定位错误

假设加法示例中的返回语句误写成：

return x - y;

预期结果是 30，实际却输出 -10。可以这样定位：

在 int ret = add(a, b); 处打断点并 Debug。
查看 a = 10、b = 20，确认调用前的数据正确。
按 F7 进入 add，确认 x = 10、y = 20，参数传递也正确。
执行到返回语句，对比预期的 x + y 与实际代码 x - y，发现运算符写错。
改为 return x + y;，重新调试，确认 ret = 30，最终输出正确。

调试时每一步都应带着一个检查目标：输入是否正确、哪一步计算有误、返回结果是否符合预期。 找到第一个出现偏差的位置，通常就能明显缩小错误范围。

Java 方法的使用：定义、传参、重载与递归

Homlander — Wed, 11 Nov 2026 13:39:31 +0000

1. 方法是什么，怎样定义和调用

方法就是把完成某个功能的代码放在一起，起一个名字，需要时通过这个名字调用。 同一段逻辑可以反复使用，也能把复杂任务拆成几个更容易理解的小任务。

理解一个方法，先看三件事：接收什么数据（参数）、完成什么操作（方法体）、交回什么结果（返回值）。 方法也可以没有参数，或者没有返回值。

1.1 从一个完整程序入手

public class MethodDemo {
    public static void main(String[] args) {
        System.out.println("调用前");
        int result = add(10, 20);
        System.out.println("调用后，结果为：" + result);
    }

    public static int add(int x, int y) {
        System.out.println("正在计算");
        return x + y;
    }
}

输出：

调用前
正在计算
调用后，结果为：30

add 的定义可以这样读：

部分	含义
`public static`	修饰符，本章先按这个固定写法使用，具体含义后续学习
`int`	返回值类型，表示方法交回一个 `int` 结果
`add`	方法名，通常使用小驼峰命名，如 `isLeapYear`
`int x, int y`	参数列表，表示调用时需要提供两个整数
`{ ... }`	方法体，调用时要执行的代码
`return x + y;`	把计算结果交回调用处，并结束本次方法调用

一般格式为：

public static 返回值类型 方法名(参数类型 形参名, 参数类型 形参名, ...) {
    方法体
}

没有参数时，括号写成 ()；有多个参数时，用逗号分隔，每个参数都要写类型。
没有返回值时，返回值类型写 void。
本章的方法写在类的 {} 内，与 main 并列，不能把方法直接定义在另一个方法内部。
同一个类中，方法写在 main 前面或后面都可以，不需要在调用前另写一条声明。

1.2 一次调用到底怎样执行

对上面的 int result = add(10, 20);：

把 10 和 20 分别传给 x、y。
进入 add，输出“正在计算”。此时 main 等待这次调用完成。
执行 return x + y;，得到 30，结束本次 add 调用。
回到原调用位置，相当于完成 int result = 30;。
main 继续执行下一条语句。

定义方法不会自动执行方法体，调用才会执行；方法结束后，会回到调用处继续执行。 同一个方法可以被多次调用，每次使用这次传入的数据重新执行。

2. 返回值：把结果交回去，不是打印出来

2.1 返回、接收、打印是三件事

假设 add 只负责计算，不包含打印语句：

public static int add(int x, int y) {
    return x + y;
}

下面的语句放在同一个类的 main 中：

add(1, 2);                       // 执行计算，但丢弃返回值，不会输出
int result = add(1, 2);           // 用变量保存返回值
System.out.println(result);      // 输出 3
System.out.println(add(3, 4));    // 直接输出返回值 7
int twice = add(1, 2) * 2;        // 返回值参与运算，twice 为 6

有返回值不代表一定要用变量接收，但不使用它，就得不到这次计算的后续用途。 是否输出，取决于有没有执行打印语句。

例如，求 1 + 2 + ... + n 后再乘以 2：

public static int getSum(int n) {
    return (1 + n) * n / 2;
}

在 main 中调用 int result = getSum(10) * 2;，先得到 55，再计算出 110。

2.2 返回值类型必须兼容

方法返回的数据，要能赋给声明的返回值类型；接收结果的变量，也要能保存这个结果。

int a = add(1, 2);       // 正确
double b = add(1, 2);    // 正确：int 可以自动转换为 double

因此，“类型匹配”不等于必须逐字相同。反过来，不能把一个 double 返回值直接赋给 int 变量。

返回值也可以是布尔值。例如判断闰年：

public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}

条件表达式本身就是 true 或 false，可以直接返回。调用 System.out.println(isLeapYear(2024)); 会输出 true。

执行到 return 就会结束本次方法调用，不会继续向后执行。 对本章这些有返回值的方法，要保证每条可能正常结束的分支都能返回结果，不能只在某个 if 分支中返回，其他情况却没有返回值。

2.3 不需要交回结果时，用 `void`

public static void print(int x, int y) {
    System.out.println("x = " + x + "，y = " + y);
}

在 main 中：

print(10, 20);                 // 正确：直接调用
// int result = print(10, 20); // 错误：void 方法没有值可以赋给变量

void 不表示“返回 0”，而是不返回任何值。这种方法可以执行到末尾结束，也可以使用不带值的 return; 提前结束。

选择返回值时，问自己：调用者是否还要使用计算结果？需要就返回；如果任务只是打印内容，不需要交回结果，就可以用 void。

3. 参数传递：形参拿到的是实参值的副本

3.1 分清形参和实参

public static int add(int x, int y) { // x、y 是形参
    return x + y;
}

调用 add(a, 20) 时，a 和 20 是实参。

形参：定义方法时写的变量，用来接收传入的数据。
实参：调用方法时实际提供的值，可以是常量、变量或表达式。
调用时按位置传递：第一个实参给第一个形参，第二个给第二个，依此类推。
实参与形参的个数、顺序和类型要匹配；类型允许合法的自动转换。

例如，只有 getSum(int n) 时，getSum(10) 合法，而 getSum(10.9) 会编译失败，因为 double 不能直接传给 int 形参。

形参不要求与调用处的变量同名。add(a, b) 中的 a、b 与方法里的 x、y 是不同变量。

3.2 为什么 `swap(a, b)` 交换不了 `a`、`b`

public class SwapDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println("a = " + a + "，b = " + b);
    }

    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
        System.out.println("x = " + x + "，y = " + y);
    }
}

输出：

x = 20，y = 10
a = 10，b = 20

执行过程：

阶段	`main` 中的变量	`swap` 中的变量
调用时复制值	`a = 10`，`b = 20`	`x = 10`，`y = 20`
交换形参后	`a = 10`，`b = 20`	`x = 20`，`y = 10`
调用结束后	`a = 10`，`b = 20`	本次调用中的局部变量不再使用

Java 始终按值传递参数。 对这里的 int 来说，复制的是整数值，x、y 不是 a、b 的别名，所以交换的是副本。

本章先掌握基本类型参数的这个结论；借助类和对象处理类似需求的方法，留到相应章节。

4. 用方法拆分任务：计算阶乘之和

计算 1! + 2! + 3! + 4! + 5!，可以拆成两个职责：

factorial(n)：只负责求一个数的阶乘。
main：依次调用，再把结果相加。

public class FactorialSumDemo {
    public static int factorial(int n) {
        int result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += factorial(i);
        }
        System.out.println(sum); // 153
    }
}

五次调用依次返回 1、2、6、24、120，相加得到 153。每次进入 factorial，都会重新创建并初始化自己的 result，不会沿用上一次的值。

这样写是把内部循环封装进方法，使任务更清楚；并没有消除内部循环，也没有自动减少运算次数。

5. 方法重载：同一个名字，接收不同参数

5.1 为什么需要重载

两个整数相加、两个小数相加、三个小数相加，做的都是“相加”，没必要分别起三个名字。可以使用同一个方法名，通过参数列表区分。

public class OverloadDemo {
    public static int add(int x, int y) {
        return x + y;
    }

    public static double add(double x, double y) {
        return x + y;
    }

    public static double add(double x, double y, double z) {
        return x + y + z;
    }

    public static void main(String[] args) {
        System.out.println(add(1, 2));           // 3
        System.out.println(add(1.5, 2.5));       // 4.0
        System.out.println(add(1.5, 2.5, 3.5));  // 7.5
    }
}

本章在同一个类中判断重载：方法名相同，参数列表不同。 编译器根据调用处的参数个数和类型等信息，确定调用哪个方法。

5.2 怎样才算“参数列表不同”

下面只比较方法名和参数类型，省略方法体：

变化	示例	能否构成重载
参数个数不同	`add(int, int)` 与 `add(int, int, int)`	能
参数类型不同	`add(int, int)` 与 `add(double, double)`	能
参数类型的排列顺序不同	`add(int, double)` 与 `add(double, int)`	能
只改变形参名字	`add(int x, int y)` 与 `add(int a, int b)`	不能
只改变返回值类型	`int add(int, int)` 与 `double add(int, int)`	不能

前三种差异满足一种即可，并不是要求同时满足。把两个 int 形参换个位置，类型序列仍是 (int, int)，也不能构成重载。

返回值类型不参与重载的区分。 例如 double result = add(1, 2);，在上例中调用的仍是 add(int, int)，然后把返回的 int 转换成 double，不会因为左边是 double 就选择小数版本。

5.3 方法签名与字节码中的描述符

对于本章的普通方法，方法签名可以理解为“方法名 + 参数类型列表”，不包括形参名字和返回值类型。例如 add(int, int) 与 add(double, double) 的签名不同，所以可以重载。参见 Java 语言规范：方法签名。

编译后，.class 字节码中还会使用方法描述符记录参数类型和返回值类型。它与源代码层面的方法签名不是同一概念，也不是把方法名改成一个长名字。

可使用 JDK 自带的 javap 查看。先编译，再进入 .class 所在目录执行：

javac OverloadDemo.java
javap -v OverloadDemo.class

描述符的格式是 (参数类型)返回值类型。例如：

方法	描述符	读法
`int add(int x, int y)`	`(II)I`	接收两个 `int`，返回 `int`
`double add(double x, double y)`	`(DD)D`	接收两个 `double`，返回 `double`
`void main(String[] args)`	`([Ljava/lang/String;)V`	接收 `String` 数组，没有返回值

描述符中的符号：

符号	含义
`V`	`void`，用于返回值位置
`Z`	`boolean`
`B`	`byte`
`C`	`char`
`S`	`short`
`I`	`int`
`J`	`long`
`F`	`float`
`D`	`double`
`[`	数组，一个 `[` 表示一维，如 `[I` 表示 `int[]`
`L类的内部名;`	类类型，如 `Ljava/lang/String;` 表示 `String`

数组可以先理解为存放一组同类型数据的结构；这里的类名使用 / 分隔包名，记住 String 对应的写法即可，具体用法后续学习。

描述符包含返回值类型，并不意味着 Java 源代码允许仅凭返回值类型重载。 这两层规则要分开理解。参见 Java 虚拟机规范：方法描述符。

6. 递归：把问题交给规模更小的自己

6.1 递归的两个关键条件

一个方法在执行过程中调用自身，就是递归。 它适合把原问题转化成“规模更小、解法相同”的子问题。

写递归前，先回答：

什么时候直接得到答案，不再调用自己？ 这是递归出口。
怎样把问题缩小，并利用子问题的结果？ 每次调用都要向出口靠近。

只有出口但永远到不了出口，也不能正确结束。

6.2 递归求阶乘

对正整数 n：

1! = 1，作为出口。
n! = n × (n - 1)!，把求 n! 转化为求 (n - 1)!。

public static int factor(int n) {
    if (n == 1) {
        return 1;
    }
    return n * factor(n - 1);
}

调用 factor(5) 得到 120。这个版本的输入要求是 n >= 1，不能传入 0 或负数，否则 n - 1 会不断远离出口；示例还要求结果不超出 int 范围。

6.3 重点：递进去之后，还要逐层返回

以 factor(4) 为例：

向下调用：
factor(4) 等待 4 * factor(3)
factor(3) 等待 3 * factor(2)
factor(2) 等待 2 * factor(1)
factor(1) 返回 1，停止继续调用

向上返回：
factor(2) 得到 1，计算 2 * 1，返回 2
factor(3) 得到 2，计算 3 * 2，返回 6
factor(4) 得到 6，计算 4 * 6，返回 24

return n * factor(n - 1); 不是遇到 return 就立刻跳走，而是先算出它后面的表达式，再把结果返回。因此，必须等待 factor(n - 1) 完成，才能乘以本层的 n。

每一层调用都有自己的 n。进入 factor(3) 不会把上一层的 n = 4 改成 3。

可以加入输出，观察进入和返回的顺序：

public static int factorTrace(int n) {
    System.out.println("进入：" + n);
    if (n == 1) {
        System.out.println("返回：1");
        return 1;
    }
    int result = n * factorTrace(n - 1);
    System.out.println("返回：" + result);
    return result;
}

调用 factorTrace(3) 的输出：

进入：3
进入：2
进入：1
返回：1
返回：2
返回：6

6.4 调用栈为什么能记住每一层

每次方法调用都会建立一个栈帧，保存这次调用的参数、局部变量、执行位置等信息；这些尚未结束的调用组成调用栈。

可以把它想成一叠记录纸：调用新方法时放上一张，方法返回时取走最上面一张，继续处理下面那张。因而，最后进入的方法先返回。

在最深处，调用关系是 main → factor(4) → factor(3) → factor(2) → factor(1)。factor(1) 返回后，恢复的是 factor(2)，不会直接跳过中间几层回到 main。在 IDEA 调试时，可以通过调用栈查看这些层次。

7. 递归练习：从拆分规律写出代码

以下方法都写在类中，在 main 中调用。示例使用非负整数或正整数，具体范围见各题；计算结果需在 int 能表示的范围内。

7.1 按顺序打印一个非负整数的每一位

对 1234，num / 10 得到前面的 123，num % 10 得到最后一位 4。要从左到右打印，就先处理前面的部分，再打印当前最后一位。

public static void printDigits(int num) {
    if (num > 9) {
        printDigits(num / 10);
    }
    System.out.println(num % 10);
}

调用 printDigits(1234)，会分四行输出 1、2、3、4。

printDigits(1234)：先处理 123，等它结束再打印 4
printDigits(123) ：先处理 12，等它结束再打印 3
printDigits(12)  ：先处理 1，等它结束再打印 2
printDigits(1)   ：不再递归，直接打印 1

返回时依次打印 2、3、4。递归调用之前的代码在向下调用时执行，之后的代码在返回后执行。 如果把打印放到递归调用前，就会先打印末位，顺序变为 4、3、2、1。

这里没有显式写 return 作为出口：当 num <= 9 时，跳过递归调用，打印后方法自然结束。输入 0 也会正确打印 0。

7.2 求 `1 + 2 + ... + n`

输入要求 n >= 1。设结果为 sumTo(n)：

出口：sumTo(1) = 1。
拆分：sumTo(n) = n + sumTo(n - 1)。

public static int sumTo(int n) {
    if (n == 1) {
        return 1;
    }
    return n + sumTo(n - 1);
}

sumTo(10) 返回 55。它和递归求阶乘的结构相同，只是把乘法换成了加法。

7.3 求一个非负整数的各位数字之和

对 1729，把问题拆成“最后一位 9 + 前面 172 的各位数字之和”。剩下一位数时，直接返回这个数。

public static int digitSum(int num) {
    if (num < 10) {
        return num;
    }
    return num % 10 + digitSum(num / 10);
}

digitSum(1729)
= 9 + digitSum(172)
= 9 + 2 + digitSum(17)
= 9 + 2 + 7 + digitSum(1)
= 9 + 2 + 7 + 1
= 19

注意两类题的区别：求 1 到 n 的和，每次用 n - 1；处理一个整数的各位数字，每次用 num / 10 去掉最后一位。

7.4 求斐波那契数列第 `n` 项

本题从第 1 项开始计数：1，1，2，3，5，8，13，...。前两项为 1，从第三项起，每项等于前两项之和，输入要求 n >= 1。

public static int fib(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    return fib(n - 1) + fib(n - 2);
}

例如 fib(6) 返回 8。

这个写法简洁，但会重复计算相同的子问题。

fib(5)
├── fib(4)
│   ├── fib(3)
│   └── fib(2)
└── fib(3)       ← 同一个 fib(3) 又算了一次

输入越大，重复计算越严重。计算一次 fib(40) 会得到 102334155，其中 fib(3) 会被调用 39088169 次。

若要统计次数，可以在类中、方法外定义 public static int count = 0;，并在 fib 的出口判断之后、递归调用之前加入：

if (n == 3) {
    count++;
}

count 是静态成员变量，这里只需理解为各次调用共同使用的计数器；每次重新统计前将其设为 0，调用结束后打印它。不能在 fib 内定义一个普通局部变量 count = 0 代替，因为每层调用都会有自己独立的计数。

本题可以用循环避免重复计算，只保留前两项：

public static int fibLoop(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    int last2 = 1; // 当前要计算的项的前两项
    int last1 = 1; // 当前要计算的项的前一项
    int current = 0;
    for (int i = 3; i <= n; i++) {
        current = last2 + last1;
        last2 = last1;
        last1 = current;
    }
    return current;
}

每次先算出新的一项，再把“前两项、前一项”向后移动：

本次计算	更新前 `last2`	更新前 `last1`	`current`
第 3 项	1	1	2
第 4 项	1	2	3
第 5 项	2	3	5
第 6 项	3	5	8

递归适合表达问题的拆分关系，但不代表一定更高效。判断时既要看能否到达出口，也要看是否反复计算相同的子问题。

Java 输入输出：控制台输出、键盘输入与多组输入

Homlander — Wed, 11 Nov 2026 13:33:07 +0000

一、把数据输出到控制台

1.1 print 和 println：是否自动换行

写法	作用
`System.out.print(内容);`	输出内容，不自动换行
`System.out.println(内容);`	输出内容后自动换行
`System.out.printf(格式字符串, 数据...);`	按指定格式输出，不自动换行

它们不只能输出字符串，也可以输出数字、表达式的结果等。下面的代码片段放在 main 方法中运行。

System.out.print("Java");
System.out.println("输入输出");
System.out.println(10 + 20);
System.out.print("A\nB");

输出：

Java输入输出
30
A
B

println 在输出后自动换行；\n 是写在字符串中的换行符。 print 虽然不自动换行，但遇到 \n 仍然会换行。单独写 System.out.println(); 表示只换行。

1.2 printf：把数据放到指定位置

格式字符串中的 %d、%f 等是占位符，后面的数据按顺序填入对应位置。

String name = "张三";
int age = 18;
float salary = 1000.5f;

System.out.printf("姓名：%s，年龄：%d，工资：%.2f\n", name, age, salary);

输出：

姓名：张三，年龄：18，工资：1000.50

写法	含义
`%s`	输出字符串
`%d`	按十进制输出整数
`%f`	输出浮点数，默认保留 6 位小数
`%.2f`	输出浮点数，保留 2 位小数
`%%`	输出一个 `%`，不需要对应的数据

使用时注意：

占位符与数据的类型要匹配，例如 %d 对应整数，%f 对应浮点数。
printf 不自动换行，需要换行时可在格式字符串中加 \n。
%.2f 控制的是显示格式，不会改变变量中保存的值。

其他格式符不必背诵，用到时查阅即可，这里不逐项展开。

二、使用 Scanner 读取键盘输入

2.1 先准备输入工具

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 在这里读取输入

        sc.close();
    }
}

暂时只需理解这三步：

import java.util.Scanner;：导入 Scanner 类，写在类定义之前，让程序能使用这个输入工具。
Scanner sc = new Scanner(System.in);：创建输入工具，命名为 sc。System.in 表示标准输入，通常来自键盘；new 在这里用于创建对象。
sc.close();：全部输入结束后关闭它。它也会关闭关联的 System.in，所以不要在还需要键盘输入时提前调用。

2.2 根据数据类型选择读取方法

方法	读取内容	返回类型
`sc.nextInt()`	下一个整数	`int`
`sc.nextFloat()`	下一个浮点数	`float`
`sc.nextLine()`	从当前位置读到本行结束，返回内容不包含行末换行符	`String`

读取方法会取走本次读取的输入。程序执行到读取语句时，如果还没有可读取的完整输入，通常会停下来等待。

nextInt()、nextFloat() 默认用空格、换行等空白字符分隔数据。例如依次读取年龄和工资时，输入 18 1000.5，或把两个数分行输入，都可以。

键盘输入要符合读取方法要求的类型。 nextInt() 不能读取 18.5 或 张三，否则会报输入不匹配的异常；异常处理后续再学。用 nextFloat() 读取时，键盘输入 1000.5 即可，不需要像 Java 代码中的浮点数字面量那样加 f。

2.3 完整示例：输入姓名、年龄和工资

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("请输入姓名：");
        String name = sc.nextLine();

        System.out.print("请输入年龄：");
        int age = sc.nextInt();

        System.out.print("请输入工资：");
        float salary = sc.nextFloat();

        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("工资：" + salary);

        sc.close();
    }
}

依次输入 张三、18、1000.5，每次按回车，最终输出：

姓名：张三
年龄：18
工资：1000.5

2.4 为什么先读年龄，再读姓名会出问题？

假设改成下面的顺序，并要求年龄、姓名分别输入一行：

int age = sc.nextInt();
String name = sc.nextLine();

输入 18 后按回车，name 往往直接得到空字符串，程序没有等待输入姓名。

原因在于两个方法的读取规则不同：

nextInt() 读取整数前会跳过空白，但读完 18 后，不会顺便取走它后面的换行符。
nextLine() 从当前位置读取到本行结束，并取走行末换行符。此时当前位置已经在 18 后面，所以读到的本行剩余内容为空。

可以把输入理解为：

输入：                  18[换行]
nextInt() 读取后剩下：   [换行]
nextLine() 读取结果：    ""

解决方法：在读取姓名前，先用一次 nextLine() 结束年龄所在的这一行。

将上一个完整示例的输入部分改为：

System.out.print("请输入年龄：");
int age = sc.nextInt();
sc.nextLine(); // 读走年龄这一行剩余的内容和换行符

System.out.print("请输入姓名：");
String name = sc.nextLine();

System.out.print("请输入工资：");
float salary = sc.nextFloat();

注意两点：

nextFloat() 后接 nextLine() 时，也可能遇到同样的问题。
额外的 nextLine() 会读走本行所有剩余内容，不只是换行符。上面的写法要求年龄和姓名分行输入；如果输入 18 张三，这一行中的姓名也会被丢弃。

三、循环处理多组输入

3.1 hasNextInt() 判断，nextInt() 读取

不知道总共有多少个整数时，可以边判断、边读取：

while (sc.hasNextInt()) {
    int num = sc.nextInt();
    // 处理 num
}

两者的区别是：

hasNextInt()：判断接下来是否有可读取的 int，返回 true 或 false，不会取走这个整数。
nextInt()：真正读取并取走这个整数。

如果循环中只判断却不读取，输入位置不会前进，就可能一直对同一个整数重复判断。

暂时没有输入，不等于输入已经结束。 在键盘交互时，hasNextInt() 可能等待后续输入；遇到非整数内容，或到达输入末尾时，才会返回 false。

3.2 完整示例：求若干整数的和与平均值

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int sum = 0;
        int count = 0;

        while (sc.hasNextInt()) {
            int num = sc.nextInt();
            sum += num;
            count++;
        }

        System.out.println("sum = " + sum);
        if (count > 0) {
            double avg = (double) sum / count;
            System.out.println("avg = " + avg);
        } else {
            System.out.println("没有输入整数，无法计算平均值");
        }

        sc.close();
    }
}

输入下面的内容并按回车：

10 20 21 end

输出：

sum = 51
avg = 17.0

前三个整数被依次累加，count 变为 3。接下来遇到 end，hasNextInt() 返回 false，循环结束。这里的 end 不是 Java 规定的结束符，只是一个不能作为整数读取的内容；循环不会读走它。

计算时要注意：

sum / count 两边都是整数时会执行整数除法。例如输入 10 11 end，直接相除只能得到 10；写成 (double) sum / count 才能得到 10.5。
必须先判断 count > 0，避免没有读入数据就计算平均值。
这个程序只处理整数。输入 40.0、50.5 等内容时，hasNextInt() 会返回 false，不会继续累加。

3.3 如何真正结束键盘输入？

除了输入非整数让上述循环退出，也可以发送“输入结束”信号（EOF）：

Windows 的 CMD：通常在新行按 Ctrl + Z，再按回车。
Linux、macOS 的终端：通常在空行按 Ctrl + D。
IDEA 控制台：使用发送 EOF 的操作，具体快捷键取决于系统和键位设置。

按回车只是提交一行，不代表全部输入结束；强制停止程序也不等于发送 EOF。 发送 EOF 后，循环才能正常结束，并继续执行后面的统计输出。

四、综合练习：猜数字游戏

程序随机生成一个 1～100（包含两端） 的整数。用户反复输入猜测值，程序提示“低了”或“高了”，猜对后结束。

4.1 使用 Random 生成目标数字

import java.util.Random;

导入后，在 main 中使用：

Random random = new Random();
int target = random.nextInt(100) + 1;

Random 是生成随机数的工具，使用方式和 Scanner 类似：先创建对象，再调用方法。

random.nextInt(100) 的范围是 0～99，包含 0、不包含 100；加 1 后才是 1～100。

注意：sc.nextInt() 从输入中读取整数；random.nextInt(100) 生成随机整数。虽然方法名相同，但所属工具不同，作用也不同。

4.2 完整代码

import java.util.Random;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        Scanner sc = new Scanner(System.in);
        int target = random.nextInt(100) + 1;

        while (true) {
            System.out.print("请输入猜测的数字（1～100）：");
            int num = sc.nextInt();

            if (num < target) {
                System.out.println("低了");
            } else if (num > target) {
                System.out.println("高了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }

        sc.close();
    }
}

假设本次生成的目标是 63：

请输入猜测的数字（1～100）：50
低了
请输入猜测的数字（1～100）：75
高了
请输入猜测的数字（1～100）：63
猜对了

目标数字必须在循环外生成，只生成一次。 如果放到循环内，每猜一次目标就可能改变，用户就无法根据提示逐步缩小范围。猜对时通过 break 退出循环，然后关闭输入工具。

Java 程序逻辑控制：分支、循环与典型练习

Homlander — Wed, 11 Nov 2026 13:32:35 +0000

一、程序的三种基本结构

结构	作用	本章用到的语句
顺序结构	按代码顺序执行	普通语句
分支结构	根据条件选择执行哪些代码	`if`、`switch`
循环结构	重复执行一段代码	`while`、`for`

顺序结构就是从上往下执行，调整语句的位置，执行顺序也会改变。

System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");

以上代码依次输出 aaa、bbb、ccc，每次输出后换行。

下文 Java 示例彼此独立，放在 main 方法中即可运行；标为错误的示例仅用于分析。

public class Main {
    public static void main(String[] args) {
        // 将要运行的示例放在这里
    }
}

二、if：根据条件决定执行哪条分支

if 括号中的条件必须得到 boolean 结果，即 true 或 false，不能直接用整数代替。

2.1 单分支：满足条件才执行

int score = 92;
if (score >= 90) {
    System.out.println("优秀");
}
System.out.println("判断结束");

条件为 true：执行 {} 内的代码，再继续往下执行。
条件为 false：跳过 {}，继续往下执行。

因此，无论成绩是多少，最后都会输出“判断结束”。

2.2 双分支：两个分支选一个

int num = 10;
if (num % 2 == 0) {
    System.out.println("偶数");
} else {
    System.out.println("奇数");
}

条件成立执行 if 分支，否则执行 else 分支，两者只执行一个。else 后面不写条件。

判断奇偶时用 num % 2 == 0 判断偶数，其余为奇数，负整数也适用。

2.3 多分支：从上往下，命中一个就结束选择

int num = -3;
if (num > 0) {
    System.out.println("正数");
} else if (num < 0) {
    System.out.println("负数");
} else {
    System.out.println("零");
}

执行规则：依次判断，遇到第一个成立的条件就执行对应分支，后面的条件不再判断。全部不成立时，执行最后的 else；如果没有 else，则整个分支结构不执行任何分支。

注意：多个独立的 if 会分别判断，可能执行多个分支；if-else if 链最多执行一个分支。

示例：按分数划分等级

int score = 85;
if (score < 0 || score > 100) {
    System.out.println("错误数据");
} else if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 70) {
    System.out.println("中等");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

先排除不在 0～100 范围内的数据，避免把 101 也判断为优秀。

为什么第二个等级只写 score >= 80，不用再写 score < 90？

因为能走到这里，就说明前面的 score >= 90 不成立。此时已经确定分数小于 90，所以这一分支实际对应的是 80 ≤ score < 90。

按“从高到低”的顺序判断，前面的条件会帮助后面的分支缩小范围。 如果先判断 score >= 60，那么 95 也会先进入这一分支。

2.4 嵌套 if：先判断大条件，再判断小条件

判断闰年的规则：

能被 100 整除的年份，还必须能被 400 整除。
不能被 100 整除的年份，能被 4 整除即可。

int year = 2000;
if (year % 100 == 0) {
    if (year % 400 == 0) {
        System.out.println("闰年");
    } else {
        System.out.println("平年");
    }
} else {
    if (year % 4 == 0) {
        System.out.println("闰年");
    } else {
        System.out.println("平年");
    }
}

例如：2000 是闰年，1900 是平年，2024 是闰年。只判断能否被 4 整除，会误判 1900。

2.5 大括号和分号：两个常见错误

1. 省略大括号时，分支只控制紧跟着的一条语句。

嵌套时，else 与前面最近的、尚未匹配 else 的 if 配对，缩进不能改变配对关系。

int x = 10;
int y = 20;
if (x == 10)
    if (y == 10)
        System.out.println("A");
    else
        System.out.println("B");

这里的 else 属于 if (y == 10)，所以输出 B。如果 x 不等于 10，则什么也不输出。

实际写代码时统一加 {}，并把左大括号放在 if、else 所在行，明确每个分支的范围。

2. 不要在 if (条件) 后多写分号。

// 错误示例：本想条件成立才输出，却多写了分号
int x = 20;
if (x == 10); {
    System.out.println("A");
}

这个分号本身就是一条“什么也不做”的空语句，成为了 if 控制的内容。后面的 {} 已经与 if 无关，因此即使条件为 false，也会输出 A。

三、switch：根据一个值选择分支

3.1 基本写法与执行过程

switch 适合“一个值对应多个固定选项”的场景，例如根据数字输出星期。

int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    case 4:
        System.out.println("星期四");
        break;
    case 5:
        System.out.println("星期五");
        break;
    case 6:
        System.out.println("星期六");
        break;
    case 7:
        System.out.println("星期日");
        break;
    default:
        System.out.println("输入有误");
        break;
}

执行过程：

计算 switch 括号内表达式的值。
找到与该值相等的 case，从对应位置开始执行。
遇到 break，退出当前 switch，执行其后的代码。
没有匹配的 case 时，从 default 开始执行；如果也没有 default，直接跳过整个 switch。

case 后面写常量，常量值不能重复；default 用于处理未匹配的情况，可以省略。

3.2 漏写 break：会继续向下执行

int day = 1;
switch (day) {
    case 1:
        System.out.println("星期一");
        // 此处没有 break
    case 2:
        System.out.println("星期二");
        break;
    default:
        System.out.println("输入有误");
}

输出：

星期一
星期二

匹配到 case 1 后，如果没有 break，程序会继续向下执行，不会再检查 day 是否等于 2。 这种现象叫作“贯穿”，直到遇到 break 或执行到 switch 末尾才结束。

如果只想执行一个选项，就在对应分支末尾写上 break。

3.3 类型限制与适用场景

本章沿用传统的 case 常量: 写法，先掌握课件涉及的类型：

基本类型：byte、short、char、int。
其他类型：String、枚举类型。

String 表示字符串，switch 中可以使用字符串变量，不局限于直接写字符串常量。枚举表示一组固定的可选值，例如星期一到星期日，本章暂不展开定义方式。

在本章所用的传统规则下，不能用 long、float、double、boolean 作为 switch 表达式的类型。

判断需求	更适合的写法
是否等于几个固定值，如星期编号	`switch`
范围判断，如 `num > 10 && num < 20`	`if`
多个条件组合判断	`if`

传统 case 不能直接写范围条件。switch 可以嵌套，但可读性较差，本章不展开嵌套写法。

四、while：满足条件就重复执行

4.1 先判断，再执行

int num = 1;
while (num <= 10) {
    System.out.println(num);
    num++;
}

执行顺序是：

初始化 → 判断条件 → 条件为 true 则执行循环体 → 回到条件判断
           ↓ 条件为 false
         结束循环

上例中：

num 为 1，满足条件，输出 1，再变成 2。
重复判断、输出、自增，直到输出 10。
num 变成 11，条件为 false，退出循环。

每轮执行循环体之前都要判断条件。第一次判断就为 false，循环体一次也不会执行。

写循环时先想清楚三件事：从哪里开始、什么时候继续、每轮如何推进到结束条件。

4.2 累加：计算 1～100 的和

int n = 1;
int sum = 0;
while (n <= 100) {
    sum += n;
    n++;
}
System.out.println(sum); // 5050

n 表示本轮要加的数，sum 保存已经累加的结果。

累加器从 0 开始，不影响后面的加法。
sum 放在循环外初始化，才能保留上一轮的结果；每轮重新设为 0 就无法累计。
输出放在循环后，得到最终结果；放在循环内则会输出每一步的中间结果。

4.3 累乘：计算 5 的阶乘

5! 表示 1 × 2 × 3 × 4 × 5。

int n = 1;
int result = 1;
while (n <= 5) {
    result *= n;
    n++;
}
System.out.println(result); // 120

累加通常从 0 开始，累乘通常从 1 开始。 如果把 result 初始化为 0，之后乘任何数，结果都还是 0。

4.4 死循环：条件始终成立

上面打印数字的例子如果漏掉 num++，num 就一直是 1，程序会不停输出 1。

还有一种错误是多写分号：

// 错误示例：不要运行，循环无法结束
int num = 1;
while (num <= 10); {
    System.out.println(num);
    num++;
}

此时真正的循环体只有空语句 ;，后面的 {} 不属于循环。num 始终为 1，程序一直重复判断条件，既没有输出，也到不了后面的自增语句。

与 if 一样，while 的循环体建议始终加 {}，条件后不要多写分号。

五、break 与 continue：结束循环还是跳过本轮

语句	在循环中的作用	下一步去哪里
`break`	立即结束所在循环	循环后的代码
`continue`	跳过本轮剩余代码	按循环规则进入下一轮

5.1 break：找到第一个结果就停止

找出 100～200 中第一个 3 的倍数：

int num = 100;
while (num <= 200) {
    if (num % 3 == 0) {
        System.out.println(num); // 102
        break;
    }
    num++;
}

100、101 不满足要求，继续尝试；102 满足要求，输出后执行 break，不再检查后面的数。

这里的 break 退出的是最内层包围它的循环或 switch。 它不会因为写在 if 里面就只是退出 if，也不会一次退出所有外层循环。

5.2 continue：不符合要求就跳过本轮

找出 100～200 中所有 3 的倍数：

int num = 100;
while (num <= 200) {
    if (num % 3 != 0) {
        num++;
        continue;
    }
    System.out.println(num);
    num++;
}

输出 102、105、108……198，每个数占一行。

不是 3 的倍数：先自增，再执行 continue，跳过本轮的输出和末尾自增。
是 3 的倍数：输出，再执行末尾的自增。

两条路径每轮都只自增一次。

为什么 continue 前还要写一次 num++？

因为 while 遇到 continue 后会直接回到条件判断，底部的 num++ 不会执行。若少了前面的自增，程序会一直停在 num == 100，形成死循环。

六、for：把循环的三个要素写在一起

6.1 执行顺序

for (初始化; 循环条件; 更新操作) {
    循环体
}

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

执行顺序：

初始化（只执行一次）
    ↓
判断条件 ── false → 结束循环
    ↓ true
执行循环体
    ↓
执行更新操作
    ↓
回到条件判断

i++ 在循环体之后执行，不是在循环体之前。 上例先输出 1，再执行自增。

for 与 while 都能完成计数、求和、求阶乘等任务。需要明确地遍历一段范围时，for 通常更直观；主要围绕某个条件反复执行时，可以用 while。

例如，求 1～100 的和：

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println(sum); // 5050

改成求 5! 时，把累乘结果初始化为 1，循环到 5，每轮执行 result *= i 即可。

6.2 for 中的 break 和 continue

break：直接退出循环，更新操作也不再执行。
continue：跳过本轮剩余的循环体，先执行更新操作，再判断条件。

因此，前面寻找所有 3 的倍数的代码可以写成：

for (int num = 100; num <= 200; num++) {
    if (num % 3 != 0) {
        continue;
    }
    System.out.println(num);
}

这里不必在 continue 前手动自增，因为 for 头部的 num++ 仍然会执行。

6.3 注意分号和省略条件

for 括号中的两个分号是分隔符，必须保留；右括号后不要额外加分号，否则循环体会变成空语句。

省略中间的条件，相当于条件始终为 true，不会因为条件不满足而停止，但仍可以用 break 退出：

for (int i = 1; ; i++) {
    if (i > 3) {
        break;
    }
    System.out.println(i);
}

这段代码依次输出 1、2、3 后结束。因此，“省略条件”并不一定代表程序永远无法退出。

七、嵌套循环：计算 1! + 2! + 3! + 4! + 5!

把任务拆成两层：

外层决定这一轮计算谁的阶乘，并把结果加入总和。
内层从 1 乘到当前数字，算出这一个阶乘。

int sum = 0;
for (int i = 1; i <= 5; i++) {
    int factorial = 1;
    for (int j = 1; j <= i; j++) {
        factorial *= j;
    }
    sum += factorial;
}
System.out.println(sum); // 153

执行过程：

外层的 i	内层计算	本轮 factorial	累加后的 sum
1	1	1	1
2	1 × 2	2	3
3	1 × 2 × 3	6	9
4	1 × 2 × 3 × 4	24	33
5	1 × 2 × 3 × 4 × 5	120	153

理解嵌套循环时，抓住三点：

外层每执行一轮，内层都要完整执行一遍。 不是外层走一步、内层走一步。
factorial 放在外层循环内部，每次计算新的阶乘前重置为 1；内层的 j 也重新从 1 开始。
sum 放在两层循环外，保留总和；sum += factorial 放在内层循环结束后，因为此时这个阶乘才算完整。

while 也能嵌套，思路相同，只需手动安排好两层循环变量的初始化和更新。

do-while 在课件中属于选学，使用较少，本章不展开；以上题目使用 while 和 for 即可完成。

八、综合练习

8.1 判断一个整数是否为素数

素数是大于 1，且只有 1 和自身两个正因数的整数。 0、1、负整数都不是素数。

最直接的做法是尝试用 2～num-1 中的整数去除 num：

只要找到一个能整除的数，就能确定不是素数，无需继续尝试。
全部尝试完都不能整除，才是素数。

int num = 29;
boolean isPrime = true;

if (num <= 1) {
    isPrime = false;
} else {
    for (int i = 2; i < num; i++) {
        if (num % i == 0) {
            isPrime = false;
            break;
        }
    }
}

if (isPrime) {
    System.out.println("是素数");
} else {
    System.out.println("不是素数");
}

isPrime 用来记录判断结果：先假设是素数，再用检查结果推翻这一假设。

num == 9：试到 3 时可以整除，标记为不是素数，退出循环。
num == 2：循环条件 2 < 2 一开始就不成立，保留 true，正确判断为素数。
上界必须写 i < num，不能写 i <= num，否则会把自身也作为排除依据。

不要因为某一次不能整除，就立即判定为素数。 例如 9 不能被 2 整除，但能被 3 整除。

8.2 输出 0～999 中所有水仙花数

本题中的水仙花数指：一个三位数，各位数字的立方和等于它本身。

例如：153 = 1 × 1 × 1 + 5 × 5 × 5 + 3 × 3 × 3。

虽然题目范围是 0～999，但根据“三位数”的定义，只需检查 100～999。

对三位整数 num 拆位：

数位	写法	num = 153 时
百位	`num / 100`	1
十位	`num / 10 % 10`	5
个位	`num % 10`	3

for (int num = 100; num <= 999; num++) {
    int hundreds = num / 100;
    int tens = num / 10 % 10;
    int units = num % 10;

    int sum = hundreds * hundreds * hundreds
            + tens * tens * tens
            + units * units * units;

    if (sum == num) {
        System.out.println(num);
    }
}

输出：

Java 中 ^ 不是乘方运算，计算一个数的立方应写成 x * x * x，不能写成 x ^ 3。

DEV Community: Homlander

Java 多态：重写、类型转换与动态绑定

1. 先理解多态解决什么问题

2. 方法重写：让子类提供自己的实现

2.1 什么是重写

2.2 重写和重载不要混淆

3. 理解多态的关键：声明类型与实际对象

静态绑定与动态绑定

4. 向上转型：统一当作父类使用

4.1 直接赋值

4.2 方法传参

4.3 方法返回

5. 向下转型：使用子类特有的方法

5.1 强制转换不会改变对象的实际类型

5.2 用 instanceof 判断后再转换

6. 多态为什么能减少分支、方便扩展

7. 构造方法中的陷阱：对象还没初始化完，就调用了子类方法

8. 复习自查

11 继承

一、继承解决什么问题

二、先看权限：父类的成员能不能访问

2.1 private：子类不能直接访问

2.2 protected：重点看跨包情况

三、再看名字：到底访问哪个成员

3.1 成员变量：同名时优先使用子类的

3.2 成员方法：不能只看方法名

3.3 super 的作用

四、创建子类对象：先初始化父类部分

4.1 用 super(...) 选择父类构造方法

4.2 没写 super(...)，为什么有时可以、有时报错

4.3 this(...) 与 super(...) 的关系

五、有继承时，代码块按什么顺序执行

六、Java 支持哪些继承关系

七、final：限制修改、重写和继承

7.1 修饰变量

7.2 修饰类

7.3 修饰方法

八、继承与组合：是一个，还是有一个

九、复习自检

Java 类和对象（二）：包、封装、static 与代码块

1. 包：给类分类，也给类名加上范围

1.1 声明包与创建目录

1.2 使用其他包中的类

1.3 通配导入与同名冲突

1.4 常见包

2. 访问权限与封装：把数据的使用规则放进类里

2.1 先分清哪些地方能访问成员

2.2 封装解决什么问题

2.3 封装的价值

3. static：属于类，还是属于某个对象

3.1 实例变量各有一份，静态变量共同使用一份

3.2 静态方法与静态成员的封装

3.3 为什么静态方法不能直接访问实例成员

3.4 静态变量如何初始化

3.5 静态导入：省略静态成员前的类名

4. 代码块：位置不同，执行时机不同

4.1 普通代码块：限制局部变量的作用范围

4.2 实例代码块：每个对象都会执行的初始化

4.3 静态代码块：类初始化时执行一次

4.4 用一次完整运行看清执行顺序

5. 复习自查

Java 类和对象（一）

1. 从“完成哪些步骤”到“让哪个对象做什么”

2. 类、对象与成员

2.1 类描述“有什么”和“能做什么”

2.2 类是模板，对象是具体实例

3. 创建对象并访问成员

3.1 用 new 实例化对象

3.2 用 . 访问成员

3.3 null 不是“空对象”

4. this：当前对象的引用

4.1 为什么 year = year 没有修改成员变量？

4.2 谁调用方法，this 就引用谁

5. 对象中的数据如何初始化？

5.1 成员变量有默认值，局部变量不能照搬

5.2 就地初始化：声明字段时直接赋值

5.3 构造方法：创建对象时完成初始化

5.4 默认构造方法：什么情况下会自动生成？

5.5 构造方法重载与 this(...)

5.6 把初始化顺序串起来

2.1 `private`：子类不能直接访问

2.2 `protected`：重点看跨包情况

3.3 `super` 的作用

4.1 用 `super(...)` 选择父类构造方法

4.2 没写 `super(...)`，为什么有时可以、有时报错

4.3 `this(...)` 与 `super(...)` 的关系

七、`final`：限制修改、重写和继承

3.1 用 `new` 实例化对象

3.2 用 `.` 访问成员

3.3 `null` 不是“空对象”

4. `this`：当前对象的引用

4.1 为什么 `year = year` 没有修改成员变量？

4.2 谁调用方法，`this` 就引用谁

5.5 构造方法重载与 `this(...)`

6. 打印对象：`toString()`

2.3 `null`：目前没有引用任何数组

4.1 `Arrays.copyOf` 与 `Arrays.copyOfRange`

2.3 不需要交回结果时，用 `void`

3.2 为什么 `swap(a, b)` 交换不了 `a`、`b`