我是Java编程的新手，试图掌握OOP的诀窍。
所以我创建了这个抽象类:
public abstract class Vehicle{....}
和2个子类:
public class Car extends Vehicle{....}
public class Boat extends Vehicle{....}
Car和Boat还拥有一些不常见的独特字段和方法(没有相同的名称，所以我无法在Vehicle中为它们定义抽象方法)。
现在在mainClass中我已经设置了我的新车库:
Vehicle[] myGarage= new Vehicle[10];
myGarage[0]=new Car(2,true);
myGarage[1]=new Boat(4,600);
我对多态性非常满意，直到我尝试访问Car特有的一个字段，例如:
boolean carIsAutomatic = myGarage[0].auto;
编译器不接受。我使用类型转换解决了这个问题:
boolean carIsAutomatic = ((Car)myGarage[0]).auto;
工作……但它对方法没有帮助，只对字段有帮助。意思是我做不到
(Car)myGarage[0].doSomeCarStuff();
我的问题是，我的车库里到底有什么?我试图获得直觉，并理解“幕后”发生了什么。
为了方便以后的读者，以下是对答案的简要总结:
Yes, there's a Car in myGarage[]
Being a static typed language, the Java compiler will not lend access to methods/fields that are non-"Vehicle", if accessing those through a data structure based on the Vehicle super class( such as Vehicle myGarage[])
As for how to solve, there are 2 main approaches below:
Use type casting, which will ease the compiler's concerns and leave any errors in the design to run time
The fact that I need casting says the design is flawed. If I need access to non-Vehicle capabilities then I shouldn't be storing the Cars and Boats in a Vehicle based data structure. Either make all those capabilities belong to Vehicle, or use more specific (derived) type based structures
In many cases, composition and/or interfaces would be a better alternative to inheritance. Probably the subject of my next question...
Plus many other good insights down there, if one does have the time to browse through the answers.
如果你需要在车库中区分Car和Boat，那么你应该将它们存储在不同的结构中。
例如:
public class Garage {
private List<Car> cars;
private List<Boat> boats;
}
然后，您可以定义特定于船或特定于汽车的方法。
那为什么要多态呢?
假设Vehicle是这样的:
public abstract class Vehicle {
protected int price;
public getPrice() { return price; }
public abstract int getPriceAfterYears(int years);
}
每个Vehicle都有一个价格，所以它可以放在Vehicle抽象类中。
然而，决定n年后价格的公式取决于车辆，因此留给实现类来定义它。例如:
public Car extends Vehicle {
// car specific
private boolean automatic;
@Override
public getPriceAfterYears(int years) {
// losing 1000$ every year
return Math.max(0, this.price - (years * 1000));
}
}
Boat类可能对getPriceAfterYears和特定的属性和方法有其他定义。
现在回到Garage类，你可以定义:
// car specific
public int numberOfAutomaticCars() {
int s = 0;
for(Car car : cars) {
if(car.isAutomatic()) {
s++;
}
}
return s;
}
public List<Vehicle> getVehicles() {
List<Vehicle> v = new ArrayList<>(); // init with sum
v.addAll(cars);
v.addAll(boats);
return v;
}
// all vehicles method
public getAveragePriceAfterYears(int years) {
List<Vehicle> vehicules = getVehicles();
int s = 0;
for(Vehicle v : vehicules) {
// call the implementation of the actual type!
s += v.getPriceAfterYears(years);
}
return s / vehicules.size();
}
多态性的兴趣在于能够调用车辆上的getPriceAfterYears而不关心实现。
通常，下倾是设计缺陷的标志:如果需要区分车辆的实际类型，请不要将所有车辆存储在一起。
注:当然这里的设计可以很容易地改进。这只是一个例子来证明这一点。
创建车辆级别字段，这将有助于使每个单独的车辆更加独特。
public abstract class Vehicle {
public final boolean isCar;
public final boolean isBoat;
public Vehicle (boolean isCar, boolean isBoat) {
this.isCar = isCar;
this.isBoat = isBoat;
}
}
将继承类中的Vehicle level字段设置为适当的值。
public class Car extends Vehicle {
public Car (...) {
super(true, false);
...
}
}
public class Boat extends Vehicle {
public Boat (...) {
super(false, true);
...
}
}
实现使用车辆级别字段正确地破译车辆类型。
boolean carIsAutomatic = false;
if (myGarage[0].isCar) {
Car car = (Car) myGarage[0];
car.carMethod();
carIsAutomatic = car.auto;
}
else if (myGarage[0].isBoat) {
Boat boat = (Boat) myGarage[0];
boat.boatMethod();
}
因为你告诉编译器车库中的所有东西都是Vehicle，所以你只能使用Vehicle类级别的方法和字段。如果你想正确地破译车辆类型，那么你应该设置一些类级别的字段，例如isCar和isBoat，这将使你的程序员更好地理解你正在使用的车辆类型。
Java是一种类型安全的语言，所以在处理像Boats和Cars这样已转换的数据之前，最好总是进行类型检查。
