一、需求

我们要编写一个 Tank 坦克类，实现坦克的核心功能：

1. 记录坦克的速度（double 类型）和炮弹数量（int 类型）；
2. 实现加速、减速（速度不能为负）功能；
3. 实现设置炮弹数量、获取炮弹数量、获取速度功能；
4. 实现开火功能（有炮弹才能发射，发射后炮弹数量减 1）；
5. 编写测试类 Fight，创建两个坦克对象，测试所有功能。

二、核心知识点

1. 类与对象：类是对象的模板（比如 Tank 是坦克模板），对象是类的实例（比如 tank1、tank2 是具体的坦克）；
2. 成员变量：定义在类中、方法外的变量，用来描述对象的属性（速度、炮弹数量就是坦克的属性）；
3. 成员方法：定义在类中的方法，用来描述对象的行为（加速、减速、开火就是坦克的行为）；
4. 方法调用：通过「对象名。方法名 ()」调用对象的方法，实现对象的行为。

三、完整代码实现

1. Tank 类（坦克模板）

这个类定义了坦克的所有属性和行为，替换模板中的【代码】即可：

public class Tank {
    // 【代码 1】声明 double 型变量 speed，刻画速度
    double speed;
    // 【代码 2】声明 int 型变量 bulletAmount，刻画炮弹数量
    int bulletAmount;

    // 加速方法：参数s为增加的速度值
    void speedUp(int s) {
        // 【代码 3】将 s+speed 赋值给 speed
        speed = s + speed;
    }

    // 减速方法：参数d为减少的速度值，速度不能小于0
    void speedDown(int d) {
        if(speed - d >= 0)
            // 【代码 4】将 speed-d 赋值给 speed
            speed = speed - d;
        else
            speed = 0; // 速度最低为0
    }

    // 设置炮弹数量
    void setBulletAmount(int m) {
        bulletAmount = m;
    }

    // 获取炮弹数量
    int getBulletAmount() {
        return bulletAmount;
    }

    // 获取当前速度
    double getSpeed() {
        return speed;
    }

    // 开火方法：有炮弹才能发射
    void fire() {
        if(bulletAmount >= 1){
            // 【代码 5】将 bulletAmount-1 赋值给 bulletAmount
            bulletAmount = bulletAmount - 1;
            System.out.println("打出一发炮弹");
        }
        else {
            System.out.println("没有炮弹了，无法开火");
        }
    }
}

2. Fight 类（测试类）

创建坦克对象，调用方法测试坦克的所有功能：

public class Fight {
    public static void main(String args[]) {
        // 声明坦克对象引用
        Tank tank1,tank2;
        // 创建具体的坦克对象（实例化）
        tank1 = new Tank();
        tank2 = new Tank();

        // 为两个坦克设置初始炮弹数量
        tank1.setBulletAmount(10);
        tank2.setBulletAmount(10);
        // 打印初始炮弹数量
        System.out.println("tank1 的炮弹数量："+tank1.getBulletAmount());
        System.out.println("tank2 的炮弹数量："+tank2.getBulletAmount());

        // 坦克加速
        tank1.speedUp(80);
        tank2.speedUp(90);
        // 打印加速后的速度
        System.out.println("tank1 目前的速度："+tank1.getSpeed());
        System.out.println("tank2 目前的速度："+tank2.getSpeed());

        // 坦克减速
        tank1.speedDown(15);
        tank2.speedDown(30);
        // 打印减速后的速度
        System.out.println("tank1 目前的速度："+tank1.getSpeed());
        System.out.println("tank2 目前的速度："+tank1.getSpeed());

        // 坦克开火测试
        System.out.println("tank1 开火：");
        tank1.fire();
        System.out.println("tank2 开火：");
        tank2.fire();
        tank2.fire(); // tank2连续开火两次

        // 打印开火后的炮弹数量
        System.out.println("tank1 的炮弹数量："+tank1.getBulletAmount());
        System.out.println("tank2 的炮弹数量："+tank2.getBulletAmount());
    }
}

四、代码关键解析

1. 【代码 1、2】成员变量声明 直接在类中定义变量，不需要写 static，属于对象的属性，每个坦克对象都有独立的速度和炮弹数量。

   double speed; // 速度
   int bulletAmount; // 炮弹数量
   

2. 【代码 3】加速逻辑 速度 = 原有速度 + 增加的速度，直接赋值即可：

   speed = s + speed;
   

3. 【代码 4】减速逻辑 先判断减速后速度是否≥0，满足条件就更新速度：

   speed = speed - d;
   

4. 【代码 5】开火逻辑 每开一次火，炮弹数量减 1，确保有炮弹才能发射：

   bulletAmount = bulletAmount - 1;
   

五、运行结果

运行 Fight 类的 main 方法，控制台输出如下：

tank1 的炮弹数量：10
tank2 的炮弹数量：10
tank1 目前的速度：80.0
tank2 目前的速度：90.0
tank1 目前的速度：65.0
tank2 目前的速度：65.0
tank1 开火：
打出一发炮弹
tank2 开火：
打出一发炮弹
打出一发炮弹
tank1 的炮弹数量：9
tank2 的炮弹数量：8

六、实验总结

通过这个 Tank 坦克实验，我们掌握了 Java 面向对象最核心的基础：

1. 类是模板，对象是实例：Tank 定义了坦克的通用属性和行为，tank1/tank2 是具体的坦克；
2. 成员变量描述属性：speed、bulletAmount 记录坦克的状态；
3. 成员方法描述行为：加速、减速、开火都是坦克的功能，通过方法实现；
4. 对象独立：两个坦克对象的速度、炮弹数量互不影响，这就是面向对象的「封装性」