java定义一个车辆类，封装价格属性

在Java中，我们可以定义一个名为`Vehicle`的类，用于封装车辆的基本属性，包括价格。下面是一个简单的示例：

public class Vehicle {
    // 定义价格属性（double类型的实例变量）
    private double price;

    // 构造函数，初始化价格
    public Vehicle(double price) {
        this.price = price;
    }

    // 提供getter方法获取价格
    public double getPrice() {
        return price;
    }

    // 如果需要，可以提供setter方法设置价格
    // 公共访问权限是为了方便外部修改，但在实际项目中，通常会考虑数据封装，只提供get方法
    public void setPrice(double price) {
        this.price = price;
    }
    
    // 可能的其他方法，如描述车辆信息等
    // ...

    // 

相关问题

定义一个 Car 类，封装汽车的属性和方法。 输出汽车信息： 品牌：Toyota 型号：Camry 年份：2024 Toyota Camry 已启动！

为了定义一个名为 `Car` 的类，用于封装汽车的基本属性如品牌、型号和年份，以及一些方法如启动，我们可以按照以下方式编写：

public class Car {
    // 汽车属性
    private String brand;
    private String model;
    private int year;

    // 构造函数
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // 获取汽车信息的方法
    public void displayInfo() {
        System.out.println("品牌：" + brand);
        System.out.println("型号：" + model);
        System.out.println("年份：" + year);
    }

    // 启动方法
    public void start() {
        System.out.println(brand + " " + model + " 已启动！");
    }
}

// 使用示例
public static void main(String[] args) {
    Car toyotaCamry = new Car("Toyota", "Camry", 2024);
    toyotaCamry.displayInfo();
    toyotaCamry.start();
}

在这个例子中，我们创建了一个 `Car` 类，包含了品牌的 `brand`、型号的 `model` 和年份的 `year` 属性。然后定义了构造函数来初始化这些属性，`displayInfo()` 方法用于输出车辆信息，而 `start()` 方法则模拟汽车启动的行为。

运行 `main` 函数时，会看到 Toyota Camry 的相关信息，并显示已启动的消息。

2. 编写一个Vehicle车辆类，将该类置为abstract抽象类，封装车辆类中必要的成员属性，并添加对应的setter（）和getter（）方法。封装一个抽象方法getToll（）实现获取通行费的功能。在两个子类Car类和Truck类中，继承Vehicle类并实现getToll（）方法，实现Car类和Truck类对象不同的收取高速通行费的功能（高速公路收费按照车型单公里的费用X行驶的公里数）。

好的，我理解了你的问题。以下是Vehicle车辆类的代码实现：

public abstract class Vehicle {
    private String licensePlate; // 车牌号
    private double kilometers; // 行驶公里数

    public Vehicle(String licensePlate, double kilometers) {
        this.licensePlate = licensePlate;
        this.kilometers = kilometers;
    }

    public String getLicensePlate() {
        return licensePlate;
    }

    public void setLicensePlate(String licensePlate) {
        this.licensePlate = licensePlate;
    }

    public double getKilometers() {
        return kilometers;
    }

    public void setKilometers(double kilometers) {
        this.kilometers = kilometers;
    }

    public abstract double getToll(); // 获取通行费的抽象方法
}

上述代码中，Vehicle类是一个抽象类，包含了车牌号和行驶公里数两个属性，并且封装了相应的getter和setter方法。此外，还定义了一个抽象方法getToll()用于计算通行费，但是该方法没有具体的实现，需要在子类中实现。

接下来，我们分别实现Car类和Truck类，这里以Car类为例：

public class Car extends Vehicle {
    private double tollPerKilometer; // 每公里的收费

    public Car(String licensePlate, double kilometers, double tollPerKilometer) {
        super(licensePlate, kilometers);
        this.tollPerKilometer = tollPerKilometer;
    }

    public double getTollPerKilometer() {
        return tollPerKilometer;
    }

    public void setTollPerKilometer(double tollPerKilometer) {
        this.tollPerKilometer = tollPerKilometer;
    }

    @Override
    public double getToll() {
        return getKilometers() * tollPerKilometer;
    }
}

在上述代码中，Car类继承自Vehicle类，并实现了getToll()方法。Car类还新增了一个属性tollPerKilometer，表示每公里的收费。在getToll()方法中，通过调用getKilometers()方法获取行驶公里数，并乘以每公里的收费，计算出通行费。

类似地，我们还可以实现Truck类：

public class Truck extends Vehicle {
    private double tollPerKilometer; // 每公里的收费
    private int loadCapacity; // 载重

    public Truck(String licensePlate, double kilometers, double tollPerKilometer, int loadCapacity) {
        super(licensePlate, kilometers);
        this.tollPerKilometer = tollPerKilometer;
        this.loadCapacity = loadCapacity;
    }

    public double getTollPerKilometer() {
        return tollPerKilometer;
    }

    public void setTollPerKilometer(double tollPerKilometer) {
        this.tollPerKilometer = tollPerKilometer;
    }

    public int getLoadCapacity() {
        return loadCapacity;
    }

    public void setLoadCapacity(int loadCapacity) {
        this.loadCapacity = loadCapacity;
    }

    @Override
    public double getToll() {
        return getKilometers() * tollPerKilometer * loadCapacity;
    }
}

Truck类与Car类的实现类似，不同之处在于Truck类新增了一个属性loadCapacity表示载重，并在getToll()方法中乘以载重计算通行费。

最后，我们可以编写一个测试类，测试Car类和Truck类的使用：

public class Test {
    public static void main(String[] args) {
        Vehicle car = new Car("鲁A12345", 100, 0.5);
        System.out.println("小汽车通行费：" + car.getToll());

        Vehicle truck = new Truck("鲁B12345", 100, 0.8, 20);
        System.out.println("卡车通行费：" + truck.getToll());
    }
}

运行上述测试类，将会输出以下结果：

小汽车通行费：50.0
卡车通行费：1600.0

从上述结果可以看出，Car类和Truck类对象的getToll()方法分别计算了不同的通行费用，实现了收取高速通行费的功能。