第 4 章 面向对象编程基础：创造你的第一个机器人​¶

┌────────────────────────────┐
│   Robot Class (机器人蓝图)  │
│  ┌────────────────────┐    │
│  │ 成员变量           │    │
│  │ - 名字 (name)      │    │
│  │ - 电量 (battery)   │    │
│  └────────────────────┘    │
│  ┌────────────────────┐    │
│  │ 构造器             │    │
│  │ + Robot(initialName)│   │
│  │ (如何制造一台新机器人)│ │
│  └────────────────────┘    │
│  ┌────────────────────┐    │
│  │ 方法               │    │
│  │ + drive()          │    │
│  │ + charge()         │    │
│  │ (机器人能做什么)    │    │
│  └────────────────────┘    │
└────────────────────────────┘

/**
 * Robot.java
 * 定义一个“机器人”类（FTC机器人蓝图）
 */
public class Robot {
    // 属性 (成员变量)：描述这个机器人有什么
    String name;
    double power; // 动力，范围 0.0 (停止) 到 1.0 (全速)

    // 行为 (方法)：描述这个机器人能做什么
    public void drive() {
        System.out.println(name + "号机器人正在以 " + (power * 100) + "% 的动力前进！");
    }
}

/**
 * Test.java
 * 这里是我们的机器人测试场，我们在这里创造并指挥机器人
 */
public class Test {
    public static void main(String[] args) {
        // 1. 创建对象：根据 Robot 蓝图，用 `new` 关键字创造一个机器人对象
        Robot robot1 = new Robot();

        // 2. 设置属性：给这台机器人赋值
        robot1.name = "先锋号";
        robot1.power = 0.8; // 设置 80% 的动力

        // 3. 调用行为：命令它执行任务
        robot1.drive(); // 输出：先锋号机器人正在以 80.0% 的动力前进！

        // 我们可以根据同一份蓝图，再造一台完全独立的机器人
        Robot robot2 = new Robot();
        robot2.name = "守护者";
        robot2.power = 0.5;
        robot2.drive(); // 输出：守护者号机器人正在以 50.0% 的动力前进！
    }
}

/**
 * Robot.java (带方法的版本)
 */
public class Robot {
    String name;

    /**
     * 这是一个没有返回值(void)且有参数的方法
     * @param seconds 需要行驶的秒数
     */
    public void driveFor(double seconds) {
        System.out.println(this.name + " 开始前进，持续 " + seconds + " 秒。");
    }

    /**
     * 这是一个有返回值(String)且没有参数的方法
     * @return 返回机器人的状态报告
     */
    public String getStatus() {
        // 使用 return 关键字返回一个字符串结果
        return "机器人 " + this.name + " 当前状态正常。";
    }
}

public class Robot {
    // name 是成员变量，代表机器人的核心属性，它的生命周期和机器人对象一样长
    private String name = "先锋号"; 

    public void driveFor(double seconds) {
        // distance 是局部变量，它只是为了完成本次driveFor任务临时使用的“草稿纸”
        // 一旦 driveFor 方法执行完毕，distance 就会被销毁
        double distance = 0.5 * seconds; 

        System.out.println(name + " 行驶了 " + distance + " 米。");
    }

    public void test() {
        // System.out.println(distance); // 错误！这里无法访问 driveFor 方法的局部变量
    }
}

/**
 * Robot.java (封装升级版)
 */
public class Robot {
    // 1. 将属性设为私有，外部无法直接访问
    private String name;
    private double power;

    // ... 构造器将在后面介绍 ...

    /**
     * 2. 提供一个公共的、安全的方法来设定动力 (Setter方法)
     */
    public void setPower(double p) {
        // 在公共方法里设置“安全门卫”，检查传入值的合法性
        if (p >= 0.0 && p <= 1.0) {
            this.power = p; // 合法，接受赋值
        } else {
            System.out.println("错误：动力值 " + p + " 超出范围 (0.0 - 1.0)！");
        }
    }

    /**
     * 3. 提供一个公共方法让外部读取动力值 (Getter方法)
     */
    public double getPower() {
        return this.power;
    }

    // ... 其他方法 ...
}

/**
 * Test.java
 */
public class Test {
    public static void main(String[] args) {
        Robot myRobot = new Robot();
        // myRobot.power = 999; // 编译错误！power 是 private 的，无法直接访问。

        // 必须通过我们提供的安全按钮来操作
        myRobot.setPower(0.75);       // 安全的操作
        myRobot.setPower(999);        // 危险的操作被安全卫士阻止了
    }
}

/**
 * Robot.java (带有构造器)
 */
public class Robot {
    private String name;
    private double power;

    /**
     * 这是 Robot 类的构造器。
     * 在 `new Robot(...)` 的时候自动运行。
     * @param robotName 这是给新机器人起的名字
     */
    public Robot(String robotName) {
        this.name = robotName; // 将传入的名字赋给 name 属性
        this.power = 0.0;      // 默认初始动力为 0
        System.out.println("一台名为【" + this.name + "】的机器人被制造出来了！");
    }

    // ... 其他 getter/setter 方法 ...
}

/**
 * Test.java
 */
public class Test {
    public static void main(String[] args) {
        // 创建对象时，必须在括号里提供构造器需要的参数
        Robot robot1 = new Robot("闪电号"); // 调用构造器
        // Robot robot2 = new Robot(); // 错误！因为已经定义了有参构造器，默认的无参构造器就失效了。
    }
}

public class Robot {
    private String name;
    private double power;

    // 1. 无参数的构造器
    public Robot() {
        // this(...) 可以调用本类中其他的构造器，必须放在第一行！
        // 这里调用了下面的有参构造器，给了一个默认名字
        this("无名氏"); 
    }

    // 2. 有参数的构造器
    public Robot(String name) {
        this.name = name;
        this.power = 0; // 初始化动力
        System.out.println("【" + this.name + "】诞生了！");
    }
}

public class Test {
    public static void main(String[] args) {
        Robot r1 = new Robot(); // 调用无参构造器
        Robot r2 = new Robot("探路者"); // 调用有参构造器
    }
}

/**
 * Motor.java (父类)
 */
public class Motor {
    // protected 关键字表示这个属性可以被自己和所有子类访问
    protected int port;
    protected double power;

    public Motor(int port) {
        this.port = port;
        System.out.println("端口 " + port + " 上的电机已初始化。");
    }

    public void setPower(double power) {
        this.power = power;
        System.out.println("端口 " + port + " 电机功率设为 " + power);
    }
}

/**
 * DriveMotor.java (子类)
 * extends 关键字表示 DriveMotor 继承自 Motor
 */
public class DriveMotor extends Motor {
    /**
     * 子类的构造器
     * @param port 电机连接的端口号
     */
    public DriveMotor(int port) {
        // super() 用来调用父类的构造器，必须放在第一行
        super(port);
    }

    // 子类可以有自己的专属方法
    public void goForward() {
        // setPower 方法是从父类 Motor 继承来的
        setPower(1.0);
        System.out.println("驱动电机全速前进！");
    }
}

/**
 * Test.java
 */
public class Test {
    public static void main(String[] args) {
        // 创建一个驱动电机对象
        DriveMotor leftMotor = new DriveMotor(0);
        leftMotor.setPower(0.8); // 调用继承来的方法
        leftMotor.goForward();   // 调用自己的方法
    }
}

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音...");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("小狗汪汪叫！");
    }
}
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("小猫喵喵叫！");
    }
}

public class Zoo {
    // 这个方法可以接收任何“动物”
    public static void hearSound(Animal animal) {
        animal.makeSound();
    }

    public static void main(String[] args) {
        // 父类引用 指向 子类对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // 虽然myDog是Animal类型，但它实际指向Dog，所以执行Dog的方法
        myCat.makeSound(); // 同理，执行Cat的方法

        System.out.println("--- 使用一个方法处理不同对象 ---");
        hearSound(new Dog()); // 传入狗对象
        hearSound(new Cat()); // 传入猫对象
    }
}

/**
 * Attachment.java (父类/接口)
 * 代表所有可以被“激活”的机器人附件
 */
public class Attachment {
    public void activate() {
        System.out.println("一个附件被激活了...");
    }
}

/**
 * Claw.java (子类1：爪子)
 * @Override 注解告诉编译器，我们要重写父类的方法
 */
public class Claw extends Attachment {
    @Override
    public void activate() {
        System.out.println("爪子闭合，夹取成功！");
    }
}

/**
 * Launcher.java (子类2：发射器)
 */
public class Launcher extends Attachment {
    @Override
    public void activate() {
        System.out.println("发射器启动，发射像素！");
    }
}

/**
 * Test.java (万能遥控器)
 */
public class Test {
    public static void main(String[] args) {
        // 创建一个爪子和一个发射器
        Claw myClaw = new Claw();
        Launcher myLauncher = new Launcher();

        // --- 这就是多态的体现 ---
        // pressButton 方法接收的是通用的 Attachment 类型
        // 就像万能遥控器的“启动”按钮
        pressButton(myClaw);     // 传入爪子对象
        pressButton(myLauncher); // 传入发射器对象
    }

    /**
     * 这个方法就是我们的“万能遥控器按钮”
     * 它不关心具体是什么附件，只知道它是一个 Attachment，并且能被 activate()
     * @param attachment 任何继承了 Attachment 的对象
     */
    public static void pressButton(Attachment attachment) {
        System.out.print("按下按钮 -> ");
        attachment.activate();
    }
}

/**
 * Phone.java
 */
public class Phone {
    // 1. 私有属性
    private String brand;
    private double price;

    // 2. 构造器
    public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    // 3. brand 的 getter 和 setter
    public String getBrand() {
        return this.brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }

    // 4. price 的 getter 和 setter
    public double getPrice() {
        return this.price;
    }
    public void setPrice(double price) {
        if (price > 0) { // setter 里可以加一些保护逻辑
            this.price = price;
        } else {
            System.out.println("价格无效！");
        }
    }

    // 5. 公共方法
    public void call(String contact) {
        System.out.println("正在给 " + contact + " 打电话...");
    }
}

/**
 * Test.java
 */
public class Test {
    public static void main(String[] args) {
        // 创建 Phone 对象
        Phone myPhone = new Phone("华为", 5999.0);

        // 测试 getter
        System.out.println("手机品牌：" + myPhone.getBrand() + ", 价格：" + myPhone.getPrice());

        // 测试 call 方法
        myPhone.call("张三");
    }
}