Java中如何区分何时声明自身或父类对象实例？新手求详解及示例

Hey there! As someone who fumbled through these exact questions when I was starting out with Java, let's break this down in plain terms—no confusing jargon, just clear examples and reasoning.

First Question: When to Declare an Instance of the Class Itself vs Its Parent? #

The short answer boils down to what functionality you need and how flexible you want your code to be:

• Use the child class (e.g., Car) as the reference type when you need to access methods or properties unique to the child class (things Vehicle doesn't have, like openTrunk() for Car).
• Use the parent class (e.g., Vehicle) as the reference type when you only need the shared functionality defined in the parent, or when you want to leverage polymorphism (treating different child classes the same way, which makes your code more reusable and easier to maintain).

Think of it like this: If you just need a "vehicle" to drive around, any Vehicle (Car, Truck, Motorcycle) works. But if you specifically need to open a car's trunk, you have to refer to it as a Car.

Second Question: Breaking Down the 4 Declaration Syntax #

Let's assume we have these classes for context:

class Vehicle {
    public void startEngine() {
        System.out.println("Vehicle engine starts");
    }
}

class Car extends Vehicle {
    public void openTrunk() {
        System.out.println("Car trunk opened");
    }

    @Override
    public void startEngine() {
        System.out.println("Car engine roars to life");
    }
}

1) Car car = new Car(); #

You said you already get this one, but just to recap:

• Is it correct? Yes, 100%.
• Use case: When you need full access to everything Car offers—both inherited methods from Vehicle (startEngine()) and Car-specific methods (openTrunk()).
• Example:

  car.startEngine(); // Outputs "Car engine roars to life"
  car.openTrunk();   // Works perfectly, since car is a Car reference
  

2) Car car = new Vehicle(); #

• Is it correct? No, this will throw a compiler error.
• Why? A parent class instance (Vehicle) doesn't have the extra functionality that a child class (Car) adds. You can't treat a generic vehicle like a car—it might not have a trunk, for example. Java prevents this because it would lead to runtime errors if you tried to call openTrunk() on a Vehicle instance.
• What happens if you try? The compiler will yell at you with something like: incompatible types: Vehicle cannot be converted to Car.

3) Vehicle car = new Car(); #

This is the core of polymorphism in Java—super useful once you get the hang of it.

• Is it correct? Yes.
• Use case: When you want to work with the shared Vehicle interface, but need the behavior of a Car. This is great for writing flexible code that works with any Vehicle subclass (like Truck, Motorcycle, etc.).
• Key note: You can only call methods that are defined in Vehicle (like startEngine()) directly. To call Car-specific methods, you need to cast the reference back to Car first.
• Example:

  car.startEngine(); // Outputs "Car engine roars to life" (polymorphism at work!)
  // car.openTrunk(); // This would throw a compiler error—Vehicle doesn't have openTrunk()
  
  // To access Car-specific methods, cast it:
  if (car instanceof Car) {
      Car actualCar = (Car) car;
      actualCar.openTrunk(); // Now this works!
  }
  

• Perfect scenario: Imagine a method that takes any Vehicle and starts its engine—you don't care if it's a Car or Truck:

  public static void startAnyVehicle(Vehicle vehicle) {
      vehicle.startEngine();
  }
  
  // You can pass both Car and Truck instances here!
  startAnyVehicle(new Car());
  startAnyVehicle(new Truck());
  

4) Vehicle vehicle = new Vehicle(); #

• Is it correct? Yes—assuming Vehicle is not an abstract class (if it were, you couldn't instantiate it directly).
• Use case: When you don't need any subclass-specific functionality. If you just need a basic vehicle with the core features defined in Vehicle, this is the simplest way.
• Example:

  vehicle.startEngine(); // Outputs "Vehicle engine starts"
  // You can't call openTrunk() here—this is a plain Vehicle instance, not a Car
  

内容的提问来源于stack exchange，提问作者Burger Face