2. 成员变量的继承和隐藏
在Java中,继承是一种允许子类获取父类属性和方法的机制。通过使用关键字extends,子类可以继承父类的属性和方法,并且可以通过父类的引用来实现多态,即在运行时选择调用子类的方法。
当子类继承父类时,它会继承父类的成员变量。但是与方法不同,Java不允许子类直接覆盖(隐藏)父类的成员变量。子类可以声明与父类相同名称的成员变量,但它不会真正地覆盖父类的成员变量,而是在子类中创建一个新的成员变量,与父类的成员变量形成隐藏关系。
让我们通过一个具体的例子来说明这一点:
class Vehicle {
int maxSpeed = 100;
void displaySpeed() {
System.out.println("Max speed of the vehicle: " + maxSpeed);
}
}
class Car extends Vehicle {
int maxSpeed = 200;
void displaySpeed() {
System.out.println("Max speed of the car: " + maxSpeed);
}
}
public class Main {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
Vehicle carAsVehicle = new Car();
Car car = new Car();
vehicle.displaySpeed(); // 输出:Max speed of the vehicle: 100
carAsVehicle.displaySpeed(); // 输出:Max speed of the vehicle: 100
car.displaySpeed(); // 输出:Max speed of the car: 200
}
}
在上面的例子中,我们定义了一个Vehicle类和一个Car类,其中Car类是Vehicle类的子类。两个类都有一个名为maxSpeed的成员变量,并且分别提供了一个名为displaySpeed的方法用于显示最大速度。
在Car类中,我们覆盖了displaySpeed方法,并在其中输出了maxSpeed成员变量的值。然而,我们可以注意到,尽管Car类中的maxSpeed和Vehicle类中的maxSpeed拥有相同的名称,但在运行时它们输出的值是不同的。这是因为在Car类中创建了一个新的成员变量,与父类中的maxSpeed成员变量形成了隐藏关系。
在main方法中,我们创建了一个Vehicle对象、一个Car对象,并使用Vehicle类的引用指向一个Car对象。当我们调用displaySpeed方法时,由于Java的动态绑定特性,会根据对象的实际类型来决定调用哪个类的方法。因此,vehicle.displaySpeed()和carAsVehicle.displaySpeed()输出的是Vehicle类的方法,而car.displaySpeed()输出的是Car类的方法。
这个例子展示了继承和隐藏的概念。尽管子类可以在声明中使用相同的名称来隐藏父类的成员变量,但实际上这并不是对父类成员变量的覆盖。如果需要访问父类的成员变量,可以使用super关键字来显式地引用父类的成员变量。
3.多态与方法重写
多态是面向对象编程中的一个重要概念,它允许一个对象表现出多种形态。在Java中,多态通过方法重写来实现。当子类重写(覆盖)了父类的方法时,通过父类的引用调用该方法时,实际上会调用子类中的方法。这个过程称为动态绑定或运行时绑定。
继续使用上面的例子,我们来展示多态是如何工作的:
class Vehicle {
void makeSound() {
System.out.println("Some generic sound");
}
}
class Car extends Vehicle {
void makeSound() {
System.out.println("Car sound: Vroom Vroom!");
}
}
class Motorcycle extends Vehicle {
void makeSound() {
System.out.println("Motorcycle sound: Vroom!");
}
}
public class Main {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
Vehicle carAsVehicle = new Car();
Vehicle motorcycleAsVehicle = new Motorcycle();
vehicle.makeSound(); // 输出:Some generic sound
carAsVehicle.makeSound(); // 输出:Car sound: Vroom Vroom!
motorcycleAsVehicle.makeSound();// 输出:Motorcycle sound: Vroom!
}
}
在上面的例子中,我们定义了一个Vehicle类和两个子类Car和Motorcycle,它们都重写了父类的makeSound方法。
在main方法中,我们创建了一个Vehicle对象、一个Car对象、一个Motorcycle对象,并使用Vehicle类的引用指向Car和Motorcycle对象。当我们调用makeSound方法时,由于多态的特性,会根据对象的实际类型来决定调用哪个类的方法。因此,carAsVehicle.makeSound()调用的是Car类的方法,motorcycleAsVehicle.makeSound()调用的是Motorcycle类的方法。
通过多态,我们可以在父类引用的层面上编写通用的代码,而在运行时根据实际对象的类型来调用适当的方法。这提高了代码的灵活性和可复用性,并使得我们可以在不修改通用代码的情况下扩展和改变程序的行为。
4. 设计决策的原因
为什么Java不允许子类直接覆盖父类的成员变量呢?这涉及到Java语言的一些设计原则和语法约定。
4.1 保护继承的一致性
Java的设计者认为,直接覆盖父类的成员变量可能会导致继承关系的混乱和不一致性。子类通常被视为是父类的扩展,它们应该增加功能而不是完全改变继承的属性。如果允许子类直接覆盖父类的成员变量,可能会导致代码可读性降低、难以理解的bug以及维护困难等问题。
4.2 可通过方法实现灵活性
尽管不能直接覆盖父类的成员变量,子类仍然可以通过方法来访问和修改父类的成员变量。这种间接的方式可以实现灵活性,同时还能维护继承关系的一致性。通过在父类中提供合适的getter和setter方法,子类可以在需要时访问或修改父类的成员变量。
class Parent {
private int parentVariable;
int getParentVariable() {
return parentVariable;
}
void setParentVariable(int value) {
parentVariable = value;
}
}
class Child extends Parent {
void doSomething() {
int value = getParentVariable(); // 通过方法访问父类的成员变量
// ...
}
}
小结
在Java中,父类的成员变量不能被子类直接覆盖。这是出于保护继承关系的一致性和灵活性的考虑。子类可以在自身中声明与父类相同名称的成员变量,但实际上这并不是覆盖,而是创建了一个新的成员变量,与父类的成员变量形成隐藏关系。通过提供适当的getter和setter方法,子类可以间接地访问和修改父类的成员变量,同时保持代码的清晰性和可维护性。
继承是面向对象编程的重要特性,正确理解和使用继承可以帮助我们构建更加健壮和灵活的程序。在设计继承关系时,应该根据具体情况考虑继承的合理性和适用性,避免过度使用继承,以保持代码的可维护性和可扩展性。通过合理地使用继承和方法访问父类成员变量,我们可以构建出更具有复用性和可维护性的面向对象程序。