Java继承 - 可以将超类对象传递给子类进行简化吗？

Question

We know that

String s = new Object();

will result in error:

incompatible types: Object cannot be converted to String

Thus, from the following example, we cannot do:

Car car = new Vehicle();

But what would be wrong for Java having something like this:

Supperclass:

    public class Vehicle {
        String color;
        int numberOfWheels;
        int maxSpeed;
        // etc.
    }

Subclass:

    public class Car extends Vehicle {

        String engineType;
        String transmissionType;
        int numberOfDoors;
        // etc.

        Car(Vehicle vehicle) {
                            // the theoretical idea of passing
                            // the superclass object within a subclass
            super = vehicle;
        }
    }

The 'super = vehicle;' would allow us to pass all values of a previously set superclass (vehicle) to new subclasses (car) at one shot. And the usage would be:

    public class App {

        public static void main(String[] args) {

            Vehicle vehicle = new Vehicle();
            vehicle.color = "GREEN";
            vehicle.maxSpeed = 100;
            vehicle.numberOfWheels = 4;

            Car car = new Car(vehicle);

                                        // this would print: GREEN
            System.out.println("Car color is: " + car.color);
        }
    }

Perhaps there already is a simple way of doing it similarly.

"Enlighten those who are still in dark ... "

Answer 1

You can do something similar to that, but you still need the provide the Car -specific information (either as arguments to the Car constructor, or defaults, or a combination of both).

One fairly common way is to define a copy-constructor for Vehicle in Vehicle :

public Vehicle(Vehicle other) {
    this.color = other.color;
    this.numberOfWheels = other.numberOfWheels;
    this.maxSpeed = other.maxSpeed;
}

Then in Car , you use that copy-constructor and then flesh out the Car details:

public Car(Vehicle v/*, and possibly car-specified args...*/) {
    super(v);
    // ...fill in `Car`-specific information
}

Answer 2

Thus, from the following example, we cannot do:

Car car = new Vehicle();

Yeah, you cannot do that because Vehicle is the parent of Car . So, you can do:

Vehicle car = new Car();

That is part of polymorphism. And the simple way to do what you want to do is,

First add constructor to Vehicle class,

public Vehicle(String color, int numberOfWheels, int maxSpeed) {
     this.color = color;
     //other two assignment
}

Then in Car class constructor,

public Car(String color, int numberOfWheels, int maxSpeed, String engineType, String transmissionType, int numberOfDoors) {
    super(color, numberOfWheels, maxSpeed);
    this.engineType = engineType;
    this.transmissionType = transmissionType;
    this.numberOfDoors = numberOfDoors;
}//keep remember, you can also use constructor overloading.

Now inside main() ,

Vehicle car = new Car(/*arguments*/);

Answer 3

You can do similar as

public Car(Vehicle v){
 super(v)
// assuming super has constructor to copy from Vehicle
}

Answer 4

Doing that would not be good as any methods called on car would be the methods found in the baseclass, or atleast that is what happens in the normal case when it is the otherway around. It's the object's methods that gets called, not the variable's.

Answer 5

Since you declare Vehicle as non-abstract class, JVM look at it as instantiable class.

super and this are references with particular meaning in Object oriented languages. If you were familiar with Object Oriented Compilers and runtime environments, you would be get why you cannot access derived classes.

Imagine you you have to Concrete classes which inherit Vehicle, so which concrete class you want to refer?

Another issue, Compiler take space in heap according to the pattern, it Collect all information (Attributes and behaviors) as a single building block for objects, override Attributes and reserve space for all methods, this reference means all methods which are solidly defined in concert class and non-overriden methods of super class, (Super class is only concept in development, at run time it's space will merge with it's concert class), super reference means all methods which are overriden by it's subclasses but still the method's code space is addressed by the building block.

by these simple issues you will find out that changing super reference or this reference is impossible and will round the OOP Concepts.