0

我已经阅读了我的 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);

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

4

5 回答 5

1

问题是您将引用类型声明为Car您会得到我认为是所需的结果

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

有几个人提出了一个好处，即您实际上并没有重载构造函数。这确实是这里更大的问题。只有当顶层类和继承类的构造函数具有相同的参数时，才会真正发生重载构造函数。因此，每当您包含五个参数时，您总是调用 Ford 构造函数

于 2013-11-11T20:03:23.133 回答
0

您会得到相同的输出，因为car是Carnot类型的引用Ford。因此，您不能将Ford' 方法传递给引用car，因为它的引用类型Car不是Ford。因此，要获得您想要的，您必须将引用变量的引用类型更改car为Ford：

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

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

于 2013-11-11T20:01:31.020 回答
0

根据经验：

  • 在一个方法中，使用你需要的类型（如果你需要福特特定的东西，使用福特，否则使用汽车）
  • 在函数的返回值中，使用您在方法中使用的相同类型
  • 将值作为参数传递时，请在参数声明中使用您需要的类型，例如 print(Car car) 如果您只想使用 Car 特定的东西，否则 print(Ford ford) 如果您需要 Ford 特定的东西
于 2013-11-11T20:04:25.423 回答
0

哪个更可取或更常见？

这取决于您打算如何使用该参考。如果必要的方法只特定于 type Car，那么引用应该这样声明。但是，如果您需要获取与子类关联的详细信息（Ford在您的示例中），那么这就是应该声明的类型。换句话说，始终使用必要的最少特定类型。

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

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

于 2013-11-11T20:09:18.097 回答
0

运行以下示例将打印 8、10 和 10。对象（新）的实例化告诉 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
  }
}
于 2013-11-11T20:15:29.383 回答