Polymorphism -- This should be easy right --- or am I missing somthing obvi

Question

Hello from sunny Wales,
I thought the polymorphic capabilities of Java would allow this. Am I doing something wrong.
For the example below assume that value and value2 are strings representing some value be it a decimal (Double) or a String. That we have already worked out what data type resides in the strings value and value2 as stored in the variable type.
With this code my compiler is telling me that the operator >= cannot be used on Object x. I thought that this object would now be handled as a Double due to polymorphism.
This is possible right?? or am I missing something really obvious?
Code:
=============================
Object x;
Object y;
if ( type.equals("double"))
x = new Double (value);
y = new Double (value2);
else (type.equals("String"))
x = new String(value);
y = new String(value2);
boolean b = x >= y;================================
Thanks
Andrew.
Message was edited by:
scottie_uk

Answer 1

Hello.
This is possible right?? or am I missing something really obvious?It's not possible. You are missing a number of things.
* Polymorphism means that you can call a method that is defined in a superclass or interface that is the declared type (e.g. Object) and the implementation of the actual type (e.g. Double, String) gets called. For example, Object has a toString(), which means you can call that method on an Object and whichever actual implemention gets called. It does not mean that the compiler would allow you to call a method on an Object variable that is not defined in class Object. Otherwise, you could call anything on anything.
* Object does not define operator >=, and in fact Java does not support operator overloading. String has some operator support (not >= though) but that's it. Class Double also does not support any operators.
* In Java 1.5 however, there is a feature called autoboxing which converts primitives (e.g. double) to wrappers (e.g. Double), and because of this conversion it effectively appears you can use operators on these wrapper types.
Now, there is a way to accomplish what you want, by using interface Comparable. Both Double and String implement this interface.
Comparable x;
Comparable y;
if ( type.equals("double"))
x = new Double (value);
y = new Double (value2);
else if(type.equals("String"))
x = new String(value);
y = new String(value2);
int diff = x.compareTo(y);
boolean b = (diff >= 0);
http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Comparable.html
Message was edited by:
Loko