In Java, an Object
can have a runtime type (which is what it was created as) and a casted type (the type you have casted it to be).
I\'m wondering what
In this case, A
is the reference type while B
is the instance type
To determine a
is object of which class you can use:
/*The java.lang.Object.getClass() method returns the runtime class of an object*/
System.out.println("a is object of: "+a.getClass());
The Java Language Specification speaks about a variable's declared type, the javadoc of getClass()
about an object's runtime class.
Note that there is no such thing as a runtime type in Java; List<String>
and List<Integer>
are different types, but their instances share the same runtime class.
The type of the variable a
is A
. There's no changing that, since it's a reference. It happens to refer to an object of type B
. While you're referring to that B
object through an A
reference you can only treat it as though it were of type A
.
You can later cast it to its more specific type
B b = (B)a;
and use the B
methods on that object.
Section 15.5. Expressions and Run-Time Checks differentiates between
For example,
If the type of an expression is a reference type, then the class of the referenced object, or even whether the value is a reference to an object rather than null, is not necessarily known at compile time. There are a few places in the Java programming language where the actual class of a referenced object affects program execution in a manner that cannot be deduced from the type of the expression...
[snip]
An expression whose type is a reference type may be tested using
instanceof
to find out whether the class of the object referenced by the run-time value of the expression
Hence, applying the above language to
A a = new B();
we might say something like
The static type of the expression
a
isA
, despite the fact the value stored ina
is a reference to the object of runtime classB
.
Personally, I interpret the two concepts in the following manner (but beware I am unsure of its correctness):
The terminology you are looking for is the Apparent Type and the Actual Type.
A a = new B();
The Apparent Type is A because the compiler only knows that the object is of type A. As such at this time you cannot reference any of the B specific methods.
The Actual Type is B. You are allowed to cast the object (that is change its apparent type) in order to access the B specific methods.