Printable View
Im wondering why the line marked // fails causes the program not to compile. b = a now a can reference MySubclass. b = a MySubclass back intoCode:public class MyClass{
public static void main(String[] args){
MyClass a;
MySubclass b;
a = new MyClass();
b = new MySubclass();
a = b;
b = a; // fails
a = new MySubclass();
b = new MyClass();
}
}
class MySubclass extends MyClass{}
MySubClass reference. :confused:
A base class reference can reference a derived class, but not vice versa.
Yes i understand that.Quote:
Posted by CornedBee
A base class reference can reference a derived class, but not vice versa.
I think i am misinterpreting the assignments. In a = b what is actually going on? I know it's a widening conversion or upcast whatever you want to call it but is seems that in this line ie.. a = b references seem to stay the same because b = a, a is still the supertype and b is still the sub type where the assignment is illegal because as you said a derived class cannot refrence a base class.
Here's the main function again, with places marked for comments.
At pos 1, there are no objects, simple enough.Code:public static void main(String[] args){
// Pos 1
MyClass a;
MySubclass b;
// Pos 2
a = new MyClass();
b = new MySubclass();
// Pos 3
a = b;
// Pos 4
b = a; // fails
// Pos 5
a = new MySubclass();
// Pos 6
b = new MyClass(); // fails
// Pos 7
}
At pos 2, there are two references. a is a reference to a MyClass, b is a reference to a MySubclass, which derives from MyClass. Both references point to nothing.
At pos 3, a points to an object of type MyClass on the heap, let's call it W. b points to an object of type MySubclass on the heap, called X. This is no problem, because a is a ref to MyClass and b to MySubclass.
At pos 4, a has been assigned the value of b. This means that both a and b now point to X, W has been abandoned and will eventually be garbage collected. a can point to X because MySubclass is a subclass of MyClass. The downcast on the reference is performed automatically. This has absolutely no effect on X itself, though.
At pos 5, it has been attempted to assign the value of a back to b. However, a is a ref to MyClass, b to MySubclass. An upcast cannot be performed implicitely, you must explicitely cast it:
b = (MySubclass)a;
This delays the type check from compile time, where only the reference types are used, to runtime, where the actual object types are used. If you remove the a=b line now, this line will throw a InvalidCastException (or is it ClassCastException?).
Anyway, at pos 6, a new object Y of type MySubclass has been assigned to a, which is again possible because of the implicit downcast.
The last line again fails to compile, because new MyClass produces a reference of type MyClass, which needs a cast to be assigned to a reference of type MySubclass. This time, however, the cast is doomed to fail, because the underlying object Z is simply a MyClass, not a MySubclass.
What i don't understand is why the downcast is implicit. When assigning smaller type to a larger type the cast is always implicit. Visa versa cast mandatory.Quote:
Posted by CornedBee
At pos 4, a has been assigned the value of b.
This means that both a and b now point to X,
W has been abandoned and will eventually be garbage collected.
a can point to X because MySubclass is a subclass of MyClass.
The downcast on the reference is performed automatically.
This has absolutely no effect on X itself, though.
Now you said that both a and b now point to x(which is MySubclass) soQuote:
Posted by CornedBee
At pos 5, it has been attempted to assign the value of a back to b.
However, a is a ref to MyClass, b to MySubclass. An upcast cannot be performed implicitely, you must explicitely cast it:
b = (MySubclass)a;
why would the assignment b = a fail? You are just storing a which now
references MySubclass(from the previous a = b assignment)
into b which still references MySubclass. Plus
also in the second quote i think you mean a downcast cannot be performed implicitely.
Ill have to wait till i get home to take a good look at all of this
right now im at work and i keep having to get up every five seconds. :lol: Thanks for replying. :thumb:
The terms widening and narrowing conversions only apply to primitives.Quote:
I thought this was a widening conversion.
It fails at compile-time, because the compiler doesn't know that a really points to a MySubclass. The assignment is insecure, which is why the explicit cast is required.Quote:
Now you said that both a and b now point to x(which is MySubclass) so
why would the assignment b = a fail?
Maybe. I use downcast to mean from derived class to base class and upcast to mean from base class to derived class. Using this definition, my quote is correct.Quote:
also in the second quote i think you mean a downcast cannot be performed implicitely.
Yeah sorry i have a bad habbit of using widening and narrowing to loosely. :blush:Quote:
Posted by CornedBee
The terms widening and narrowing conversions only apply to primitives.
This is one thing that i have never understood. Why would the compiler not be able to determine what object a variable references?Quote:
Posted by CornedBee
It fails at compile-time, because the compiler doesn't know that a really points to a MySubclass. The assignment is insecure, which is why the explicit cast is required.
Because at compile-time it doesn't reference anything. Here's an example:
How would the compiler know whether the marked assignment is valid? If i is 0 then it is, otherwise it isn't.Code:class Base {}
class A extends Base {}
class B extends Base {}
class C extends Base {}
public class Core {
public static void main(String[] args) {
int i = (int)(Math.random()*3.0);
Base b;
switch(i) {
case 0:
b = new A();
break;
case 1:
b = new B();
break;
case 2:
b = new C();
break;
}
A a = b; // !!!
}
}
Neither does a = b. But it's still allowed at compile time.Quote:
Posted by CornedBee
Because at compile-time it doesn't reference anything.
Code:public class MyClass{
public static void main(String[] args){
MyClass a;
MySubclass b;
a = new MyClass();
b = new MySubclass();
a = b; // allowed
b = a; // fails
}
}
class MySubclass extends MyClass{}
Under the context of the code you provided of course the compiler would not be able to determine if the assignment is valid. Under the above code there is no ambiguity(not at least the way i look at it)Quote:
Posted by CornedBee
How would the compiler know whether the marked assignment is valid? If i is 0 then it is, otherwise it isn't.
Because it's safe. Whatever b references, a can reference too, that much is guaranteed. But not all that a can reference can be referenced by b, that's why it's an unsafe cast and requires the explicit cast.Quote:
Neither does a = b. But it's still allowed at compile time.
Indeed not, but your code is unrealistic. 90% of the cases, the compiler won't be able to determine the true type at compile-time, which is why it doesn't even try in the first place.Quote:
Under the context of the code you provided of course the compiler would not be able to determine if the assignment is valid. Under the above code there is no ambiguity(not at least the way i look at it)