Question

如何在本练习中实现继承？

汽车经销商希望计算机系统管理其车辆的数据并按类型对其进行分类。

所有汽车都有以下数据
1. 引擎序列号
2. 品牌
3. 年
4. 价格
车辆分为紧凑型车，豪华车，卡车和货车。
对于汽车和货车，存储乘客数量也很重要;对于卡车而言，负载能力应控制在kgs。轴数和轮次。
为此系统建模并实例化每个类，通过各自的属性分配数据。向每个类添加一个参数化构造函数以初始化其数据，并从每个派生类的构造函数中调用基类构造函数（不要使用默认构造函数）。
实现toString()方法的覆盖，以显示每种类型的auto的数据。 注意：不允许在类或空类（没有元素）中使用重复的组件。

我尝试过的事情:(我不知道继承是否正确）

interface Passegers {

    int CantidadPasajeros(int n);

    int Pasajeros();
}

class Vehicle {}

class Auto extends Vehicle implements Passegers {

    private int numSerieMotor;
    private String marca;
    private int año;
    private double precio;

    public int CantidadPasajeros(int n) {
        return n;
    }
}

class CompactAutos extends Auto {
    public int CantidadPasajeros(int n) {
        return n;
    }
}

class LuxuryAutos extends Auto {
    public int CantidadPasajeros(int n) {
        return n;
    }
}

class Truck extends Auto {
    private int capacity;
    private int axes;
    private int rounds;
}

class Wagon extends Vehicle implements Passegers {
    public int CantidadPasajeros(int n) {
        return n;
    }
}

public class Tarea22ago {
    public static void main(String[] args) {
        Vehicle x[] = new Vehicle[3];
        x[0] = new Auto();
        x[1] = new Wagon();
        x[2] = new Truck();
    }
}

但是，班级Vehicle将为空。我仍然需要在每个类中编写构造函数，但我只想确定继承的这种用法是否正确。

Answer 1

我只需查看您的代码并从上到下进行评论。一般说明是遵循Java代码约定。

你的界面很好，但是命名和setter没有返回值的约定使它

interface Passengers {
    void setPassengers(int count);
    int getPassengers();
}

你也可以在有负载的车辆上投入界面。

interface LoadVehicle {
    int getCapacity();
    int getAxes();
    int getRounds(); // what is this anyway?
}

请注意，此界面中没有setter;这些项目不会改变（请参阅下面的GhostCat评论）。

Vehicle类也可能是一个标记界面（＆＃34;标记＆＃34;说它只是表示它是一种载体，但没有定义任何方法）。

interface Vehicle {}

（这可以使其他两个接口扩展它，如interface Passengers extends Vehicle和interface LoadVehicle extends Vehicle）。

Auto类没有所需的构造函数。并非所有Autos似乎都有乘客，所以不需要实现该接口。

class Car implements Vehicle {
    private int motorNumber, makeYear;
    private String brand;
    // add getter/setters for the price? This is something that can change.
    private double price;

    // constructor. This needs to be called from all subclasses as well
    Car(String brand, int year, int engNum, double price) {
        // assign parameters to variables
    }            
}

我没有看到创建CompactCar和LuxuryCar课程的重点，因为他们似乎并没有这样的区别。一般班级应该这样做。

class PassengerCar extends Car implements Passengers {
    // add getter and setter for this to implement the interface
    private int passengers;
    PassengerCar(String brand, int year, int engNum, double price) {
        super(brand, year, engNum, price);
    }
}

您可以创建LuxuryCars或Compacts作为其实例。

同样，您现在可以为卡车创建一辆汽车。

class LoadCar extends Car implements LoadVehicle {
    // again, getters for these for the interface
    private int capacity, axes, rounds;
    // and constructor
    LoadCar(String brand, int year, int engNum, double price, 
        int cap, int axCount, int roundCount) {
        super(brand, year, engNum, price);
        // assigs the other parameters to variables
    }
}

如果没有其他区别，可以将卡车创建为LoadCar。

现在对于旅行车来说，你的Wagon类没有所需的加载功能。您必须决定是否继承LoadCar或PassengerCar;毕竟，这两者都是。在任何一种情况下，您都需要实现其他缺少的接口。我选择这个因为乘客界面更简单：

class Wagon extends LoadCar implements Passengers {
    // again, getter and setter for this for the interface
    private int passengers;
    Wagon(String brand, int year, int engNum, double price, 
        int cap, int axCount, int roundCount) {
        super(brand, year, engNum, price, cap, axCount, roundCount);
}

扩展哪个系统并不重要，因为在您使用这些类的系统中，您只能使用接口。

编辑：所以，这就是你如何创建对象：

// create a luxury car
PassengerCar luxuryCar = new PassengerCar("BMW", 2017, 322131, 49_999.99);
// create a compact
PassengerCar compactCar = new PassengerCar("Smart", 2014, 55231, 25_999.99);
// create a truck
LoadCar truck = new LoadCar("Mercedes", 2014, 2113321, 99_999.99, 10_000, 6, 4);
// create a wagon
Wagon wagon = new Wagon("Dodge", 2005, 551223, 19_999.99, 3_000, 6, 4);

并且可能显示这种继承的效果：

List<Vehicles> vehicles = new ArrayList<>();
List<Passenger> passengerVehicles = new ArrayList<>();
List<LoadCar> loadVehicles = new ArrayList<>();

// everything is a vehicle:
vehicles.add(luxuryCar); // fine
vehicles.add(compactCar); // fine
vehicles.add(truck); // fine
vehicles.add(wagon); // fine

// you can only add passenger vehicles the the passenger car list:
passengerVehicles.add(luxuryCar); // fine
passengerVehicles.add(compactCar); // fine
passengerVehicles.add(wagon); // fine
passengerVehicles.add(truck); // NO! a truck is not a passenger car.

// you can only add load cars to the load car list:
loadVehicles.add(luxuryCar); // NO! a PassengerCar is not a LoadCar.
loadVehicles.add(compactCar); // NO, same reason
loadVehicles.add(wagon); // fine
loadVehicles.add(truck); // fine

顺便提一下，这是另一个列表：

List<Car> cars = new ArrayList<>();
// everything is a car:
cars.add(luxuryCar); // fine
cars.add(compactCar); // fine
cars.add(truck); // fine
cars.add(wagon); // fine

那么车辆和汽车之间的区别是什么？好吧，让我们说你开始卖船......

class Boat implements Vehicle, Passenger {
    // add getter/setter
    private int passengers;
    public Boat(int keelDepth) {
    }
}

这意味着：

Boat boat = new Boat(15);
vehicles.add(boat); // fine
cars.add(boat); // NO! it's not a car.
passengerVehicles.add(boat); // well yes that works.

Answer 2

这个概念可能会对你有所帮助：

public interface IVehicle{
  int getNumberOfWheels();
}

public interface IPassenger{
  void getGender();
  void getType(); // Driver or customer
}

public class Vehicle implements IVehicle{

  protected ArrayList<Passenger> _passengers;

  public Vehicle(int numberOfPassengers){
    _passengers = new ArrayList<Passenger>(numberOfPassengers);
  }

}

public class Passenger implements IPassenger{
}

public interface IVehicleAuto implements IVehicle{
}

public abstract class VehicleAuto extends Vehicle implements IVehicleAuto{
}

public class Car extends Vehicle {
}

public class CarAuto extends Car implements IVehicleAuto {
}

Answer 3

抛弃乘客界面，而是让车辆类具有称为乘客的实例变量。让车辆抽象化。你正在做的子类。将任何常见的实例变量重构到车辆类中。为每个类添加构造函数。

继承实现

3 个答案: