编写一个汽车类vehicle，包含变量“轮子数量”和“汽车重量”，包含构造方法和输出变量信息方法；小汽车类car是vehicle的子类，继承了父类的变量和方法，有自己的构造方法，并新增了一个变量“载人

这是一段关于车辆类的代码，包括变量“轮子数量”和“汽车重量”，同时还包含构造方法和输出变量信息的方法。小汽车类car是vehicle的子类，继承了父类的变量和方法，有自己的构造方法，同时新增了一个变量“载人”。

相关问题

编写一个汽车类Vehicle，包含变量“轮子数量”和“汽车重量”，包含构造方法和输出变量信息方法；汽车类Car是Vehicle的子类，继承了父类的变量和方法，有自己的构造方法，并新增了一个变量“载人数量”，新增了输出“载人数量”方法；卡车类Truck是Car类的子类，继承了父类的属性和方法，有自己的构造方法，并新增了一个变量“最高载重量”，新增了一个输出“最高载重量”方法。 编写主类，创建Car的对象，对象调用方法输出所有变量信息；创建Truck的对象，对象调用方法输出所有变量信息。

好的，以下是代码实现：

class Vehicle {
    int numOfWheels;
    int weight;

    public Vehicle(int numOfWheels, int weight) {
        this.numOfWheels = numOfWheels;
        this.weight = weight;
    }

    public void printInfo() {
        System.out.println("Number of Wheels: " + numOfWheels);
        System.out.println("Weight: " + weight);
    }
}

class Car extends Vehicle {
    int numOfPassengers;

    public Car(int numOfWheels, int weight, int numOfPassengers) {
        super(numOfWheels, weight);
        this.numOfPassengers = numOfPassengers;
    }

    public void printPassengers() {
        System.out.println("Number of Passengers: " + numOfPassengers);
    }
}

class Truck extends Car {
    int maxLoadWeight;

    public Truck(int numOfWheels, int weight, int numOfPassengers, int maxLoadWeight) {
        super(numOfWheels, weight, numOfPassengers);
        this.maxLoadWeight = maxLoadWeight;
    }

    public void printMaxLoad() {
        System.out.println("Max Load Weight: " + maxLoadWeight);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(4, 1000, 5);
        myCar.printInfo();
        myCar.printPassengers();

        Truck myTruck = new Truck(6, 5000, 3, 10000);
        myTruck.printInfo();
        myTruck.printPassengers();
        myTruck.printMaxLoad();
    }
}

在这个例子中，`Vehicle` 类包含了两个变量 `numOfWheels` 和 `weight`，并且有一个构造方法和一个输出信息的方法 `printInfo()`。`Car` 类是 `Vehicle` 的子类，继承了父类的变量和方法，并且新增了一个变量 `numOfPassengers` 和一个输出方法 `printPassengers()`。`Truck` 类是 `Car` 类的子类，继承了父类的属性和方法，并新增了一个变量 `maxLoadWeight` 和一个输出方法 `printMaxLoad()`。

在主类中，我们创建了一个 `Car` 对象 `myCar`，并调用了它的方法 `printInfo()` 和 `printPassengers()` 来输出所有的变量信息。接着我们创建了一个 `Truck` 对象 `myTruck`，并调用了它的三个方法 `printInfo()`，`printPassengers()` 和 `printMaxLoad()` 来输出所有的变量信息。

（1）编写一个汽车类Vehicle，包含变量“轮子数量”和“汽车重量”，包含构造方法和输出变量信息方法；汽车类Car是Vehicle的子类，继承了父类的变量和方法，有自己的构造方法，并新增了一个变量“载人数量”，新增了输出“载人数量”方法；卡车类Truck是Car类的子类，继承了父类的属性和方法，有自己的构造方法，并新增了一个变量“最高载重量”，新增了一个输出“最高载重量”方法。编写主类，创建Car的对象，对象调用方法输出所有变量信息；创建Truck的对象，对象调用方法输出所有变量信息。用Java编译

以下是代码实现：

// Vehicle类
class Vehicle {
    int numOfWheels;
    double weight;

    Vehicle(int wheels, double weight) {
        numOfWheels = wheels;
        this.weight = weight;
    }

    void printInfo() {
        System.out.println("Number of wheels: " + numOfWheels);
        System.out.println("Weight: " + weight);
    }
}

// Car类
class Car extends Vehicle {
    int passengerCapacity;

    Car(int wheels, double weight, int passengers) {
        super(wheels, weight);
        passengerCapacity = passengers;
    }

    void printPassengerCapacity() {
        System.out.println("Passenger capacity: " + passengerCapacity);
    }
}

// Truck类
class Truck extends Car {
    double maxLoad;

    Truck(int wheels, double weight, int passengers, double maxLoad) {
        super(wheels, weight, passengers);
        this.maxLoad = maxLoad;
    }

    void printMaxLoad() {
        System.out.println("Maximum load: " + maxLoad);
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(4, 1200.0, 5);
        myCar.printInfo();
        myCar.printPassengerCapacity();

        Truck myTruck = new Truck(6, 5000.0, 2, 10000.0);
        myTruck.printInfo();
        myTruck.printPassengerCapacity();
        myTruck.printMaxLoad();
    }
}

输出结果：

Number of wheels: 4
Weight: 1200.0
Passenger capacity: 5
Number of wheels: 6
Weight: 5000.0
Passenger capacity: 2
Maximum load: 10000.0