Question

我已经阅读了我的java书籍的继承部分，并尝试了以下示例作为练习：

public class Car {
private int wheels;
private int doors;
public Car(int initWheels, int initDoors){
    wheels = initWheels;
    doors = initDoors;
}
public int getWheels(){
    return  wheels;
}
public int getDoors(){
    return doors;
}

protected int calculateMaterials(){
    return wheels + doors;
}
}

public class Ford extends Car{
private String color;
private String type;
private int horsePower;
public Ford(int initWheels, int initDoors, String initColor, String initType, int initHorsePower){
    super(initWheels, initDoors);
    color = initColor;
    type = initType;
    horsePower = initHorsePower;
}
public String getColor(){
    return color;
}
public String getType(){
    return type;
}

protected int calculateMaterials(){
    return getWheels() + getDoors() + horsePower;
}
}

主要：

public class Main {
public static void main(String [] args){
    Car car = new Car(4,4);
    Car myCar = new Ford(6,2,"black", "pickup", 2);
    System.out.println(myCar.getWheels());
    System.out.println(myCar.calculateMaterials());
  }
}

然而，在重新查看代码后，我开始质疑我自己是否可能：Car myCar = new Ford(6,2,"black", "pickup", 2);。。。我运行它，看到输出完全相同，现在我想知道是否：

Car myCar = new Ford(6,2,"black", "pickup", 2);

和这个

Ford myCar = new Ford(6,2,"black", "pickup", 2);

同样的事情，如果是这样的话更可取或更常见？如果不是我怎么得到相同的输出？

Answer 1

问题是你将引用类型声明为Car你会得到我认为的理想结果

Ford myCar = new Ford(6,2,"black", "pickup", 2);

有些人提出了一个好处，即你实际上没有重载构造函数。这确实是一个更大的问题。只有当顶级类和继承类的构造函数具有相同的参数时，才会真正重载构造函数。因此，只要包含五个参数

，就会始终调用Ford Constructor

Answer 2

您获得相同的输出，因为car是Car而非Ford类型的引用。因此，您无法将Ford的方法传递给引用car，因为它的引用类型为Car而不是Ford。因此，要获得所需内容，您必须将引用变量car的引用类型更改为Ford，例如：

Ford fordCar = new Ford(6,2,"black", "pickup", 2);

但是，这个：Car myCar = new Car(6,2,"black", "pickup", 2);根本不应该编译，因为Car构造函数没有Car中定义的5参数构造函数

Answer 3

根据经验：

在一个方法中，使用您需要的类型（如果您需要福特特定的东西，请使用福特，否则使用汽车）
在函数的返回值中，使用与方法
将值作为参数传递时，请在参数声明中使用您需要的类型，例如：打印（汽车）如果你只想使用汽车专用的东西，否则打印（福特福特）如果你需要福特特定的东西

Answer 4

哪个更好或更常见？

这取决于您打算如何使用该引用。如果必要的方法仅特定于Car类型的某些东西，则应该如此声明引用。但是，如果您需要获取与子类（示例中为Ford）相关的详细信息，那么这就是应该声明的类型。换句话说，始终使用必要的最少特定类型。

如果不是我怎么得到相同的输出？

因为您在两种情况下都使用仅与类型Car关联的值。如果您不向Ford添加任何类型特定的信息，那么它可能不应该是它自己的类型。

Answer 5

运行以下示例将打印8,10和10.对象（new）的实例化告诉JVM运行哪个代码，而不是类型。在这个例子中，myCar和myCarToo都被实例化为Ford类型，即使它们存储在变量类型为Car和Ford中。

主要：

public class Main {
public static void main(String [] args){
    Car car = new Car(6,2);
    Car myCar = new Ford(6,2,"black", "pickup", 2);
    Ford myCarToo = new Ford(6,2,"black", "pickup", 2);

    System.out.println(car.calculateMaterials());  //Car.calculateMaterials
    System.out.println(myCar.calculateMaterials());  //Ford.calculateMaterials
    System.out.println(myCarToo.calculateMaterials());  //Ford.calculateMaterials
  }
}

将对象声明为超类与其类之间的区别？

5 个答案: