I am having trouble understanding what is actually happening when I declare the array in the following code.
class Type1 {
}
class Type2 extends Type1 {
public void method2() {
}
}
class Test {
public static void main(String[] args) {
Type1[] x = new Type2[2];
x[0] = new Type1(); // runtime error
x[1] = new Type2();
x[1].method2(); // syntax error
}
}
I thought since the right-hand side of the array declaration is new Type2[2] that the array would consist of reference variables of the type Type2. If this is true, the first error makes sense because I cannot have a subtype referring to a supertype.
However, why does the second error occur two lines after that? Isn't method2() known by Type2, so the method is known by the reference variable? It seems it is because Type1 doesn't know method2, so does that mean the array consists of reference variables of the type Type1? If this is true, why does the first error occur as it is no longer a subtype referring to a supertype?
Also, why is the first error a runtime error while the other is a syntax error?
Please note I am only in my second programming course, so my terminology may be a little off.
Edit: The question here does not answer my question because it does not answer why an element of an array like x cannot invoke method2() even though an element of x of Type 2. My question is different because of this and because my question also asks why the first error occurs when the second error also occurs (why an element of x cannot refer to and object of the type Type1 and at the same time cannot invoke method2()). I originally thought that if one error occurred, then the other cannot occur. I wanted a comparison between the two errors and a more in-depth explanation than simply the rules of polymorphism.
This is one of those weird things that Java allows you to do, assigning an array of a derived class to a variable of array of the base class.
In your code, x at compile time is of type Type1[]. That's what the compiler thinks it is. At runtime, x is of type Type2[], but the compiler does not know that.
The first error occurs at runtime because as you said, you can't assign Type1 to a variable of type Type2.
But the second error occurs at compile time because the compiler still thinks that x is of type Type1, and there is no method called method2 in Type1, even though x actually holds a Type2[] at runtime.
To call method2, you need to tell the compiler that x[1] is of type Type2 by casting:
((Type2)x[1]).method2();
Lesson of the day? Don't do this:
Superclass[] array = new Subclass[2];
You'll get yourself in trouble.