Question on casting

[Veena Pointi]

According to R&H book the following are run time rules for object casting.
newtype nt;
oldtype ot;
nt=(newtype)ot;
1.If newtype is class the class of the expression being converted to must inherit from newtype.
2.If newtype is Interface,the class of the expression being converted to must implement that interface.
What about the following scenario?
When old type is interface & new type is class
What is the run time rule for object casting in the above scenario?
Thanks
Veena

[Sridhar Srikanthan]

Veena
Does this help ?

 public class Cast {
public static void main(String [] args ) {
Inter i = new Class() ; //valid no casting required
//Class c = new Inter() ; // compiler error, interface cannot be instantiated
Class c1 = new Class();
Inter j = (Inter) c1 ; // This is the way to cast
j.meth();  // nothing great...just calls the method in the class
}
}
interface Inter { void meth(); }  //interface name Inter --- old type
class Class implements Inter {    // class name Class which implements the interface--- new type
public void meth() {
System.out.println("Hello meth");
}
} 

Sri

[Veena Pointi]

u have given me example of when oldtype is class & newtype is interface,but I have asked viceversa situation.I mean oltype is interface & newtype class.I want some defined rule.
Thanks
Veena

[Veena Pointi]

Can anybody answer to this question?I can easily solve casting questions other than the scenario I explained above.I don't know exactly what rule applies when casting from interface type to class type.
Thanks
Veena

[Junilu Lacar]

Here's what the JLS says about Casting Conversions: http://java.sun.com/docs/books/jls/second_edition/html/conversions.doc.html#175725
If you find that a bit too formal and confusing...
Using an interface reference to refer to an object does not change that object's runtime type. Therefore, the runtime type of the object referred to by the interface reference should be assignment compatible with the object reference you are assigning it to.
That is, if you have
List someList = new ArrayList();
Then,
ArrayList obj1 = (ArrayList) someList; // legal - the object being referenced is an ArrayList
AbstractList obj2 = (AbstractList) someList // legal - the object being referenced is a subclass of AbstractList
LinkedList obj3 = (LinkedList) someList // runtime error - the object referenced is an ArrayList which is not assignment compatible with LinkedList

There are additional restrictions when dealing with references to final classes but I'll leave that as an exercise for you.

[alzamabar]

I could try to guess:
how could you cast an interface if the interface cannot be istantiated?
Marco

[Veena Pointi]

Actually concept is still not clear to me.
Veena

[alzamabar]

I'll try to be clever with another example.
Let's assume you have:
MyInterface myInt = new MyInterfaceImpl();//This creates an object MyInterfaceImpl of type MyInterface
What actually happens here is that at runtime first an instance of MyInterfaceImpl is being created and then an upcasting to its interface is done.
The same result could be accomplished doing the following:
MyInterfaceImpl myObj = new MyInterfaceImpl();
MyInterface driver = (MyInterface)myObj;
Since you cannot create an instance of an interface like:
MyInterface myInt = new MyInterface();
as an interface cannot accomplish any work because its methods don't contain any implementation and therefore there is no logic in creating an instance of an interface
trying something like:
MyInterfaceImpl myImpl =(MyInterfaceImpl) myInt; would attempt to create an instance of MyInterface first then trying to cast it to a class; but we told before that an interface cannot be instantiated, therefore such a casting is not possible.
Hope it will help,
Marco

[Junilu Lacar]

Originally posted by Marco Tedone:

...
The same result could be accomplished doing the following:
MyInterfaceImpl myObj = new MyInterfaceImpl();
MyInterface driver = (MyInterface)myObj;

The cast is not required. As long as myObj implements MyInterface, the following are equivalent:
// 1
MyInterface driver = new MyInterfaceImpl();
// 2
MyInterfaceImpl myObj = new MyInterfaceImpl();
MyInterface driver = myObj;


MyInterfaceImpl myImpl =(MyInterfaceImpl) myInt; would attempt to create an instance of MyInterface first then trying to cast it to a class; but we told before that an interface cannot be instantiated, therefore such a casting is not possible.

Such a casting is in fact possible. In a way, you are right: You are not actually casting the interface, but the object behind the interface. Remember, an interface reference is just another way of "seeing" an object. You only "see" what the interface defines. The underlying object can have other capabilities. Which is why this would work:

interface Bird {
   void fly();
}
 
interface Horse {
   void gallop();
}
 
interface Lizard {
   void slither();
}
 
class Pegasus implements Bird, Horse {
   public void fly() {}
   public void gallop() {}
}
 
class Dragon implements Bird, Lizard {
   public void fly();
   public void slither();
   public void breathFire();
}
 
public class Test {
   public static void main(String[] args) {
  
      // interface references
      Horse h;
      Bird b;
      Lizard l;
  
      // object references
      Pegasus p = new Pegasus();
      Dragon d = null;
   
      // legal
      h = p;   // Pegasus implements Horse
  
      // interface h's underlying object is p, a Pegasus-type object
      h.gallop();  // legal - invokes Pegasus.gallop()
    
      /* The following is not legal because
         although Pegasus can fly, a plain
         Horse cannot */
      // h.fly();
  
      // This is legal because h refers to an instance of Pegasus, which also implements Bird.
      // You aren't casting the Horse interface,
      // you're casting the Object reference by it.
      b = (Bird) h; 
      b.fly();  // calls Pegasus.fly()
  
      // a Dragon can fly so we try this
      try {
         d = (Dragon) b; 
      } catch (ClassCastException e) {
         // the underlying object, a Pegasus, is NOT a Dragon!
         System.out.println("Bad Cast!");
      }
  
      // this is legal - cast an interface type reference to an object type
      p = (Pegasus) b;
  
      // all this time, the only real object we
      // have dealt with is an instance of Pegasus
  
      // Now let's have some fun with a Dragon
      d = new Dragon();
      b = d;  // legal bec. Dragon implements Bird
      b.fly();
  
      /* The following is commented out because 
         it would cause a compile-time error:
         interface Bird does not define slither() */
      // b.slither(); 
  
      l = (Lizard) b; // legal bec. underlying object, a Dragon, also implements Lizard
      l.slither();  // still refering to Dragon, calls Dragon.slither()
  
      /* The following is commented out because 
         it would cause a compile-time error:
         interface Lizard does not define fly() */
      // l.fly();
  
      /* The following is illegal because although
         the underlying object is a Dragon and it
         has a breathFire() method, you are still
         "seeing" it as a Lizard */
      // l.breathFire();
   
      /* But if you cast it, i.e. change the way
         you "see" the Lizard (an interface),
         back to a Dragon then you have full
         access to the objects methods */
          
      d = (Dragon) l;  
 
      // now you "see" this Lizard for what it 
      // truly is and all these are legal
      d.slither();
      d.fly();
      d.breathFire();
   }
}

Hope this helps clarify the concepts a bit.
[ February 12, 2003: Message edited by: Junilu Lacar ]

[alzamabar]

Originally posted by Junilu Lacar:
Originally posted by Marco Tedone:

...
The same result could be accomplished doing the following:
MyInterfaceImpl myObj = new MyInterfaceImpl();
MyInterface driver = (MyInterface)myObj;

The cast is not required. As long as myObj implements MyInterface, the following are equivalent:
// 1
MyInterface driver = new MyInterfaceImpl();
// 2
MyInterfaceImpl myObj = new MyInterfaceImpl();
MyInterface driver = myObj;


MyInterfaceImpl myImpl =(MyInterfaceImpl) myInt; would attempt to create an instance of MyInterface first then trying to cast it to a class; but we told before that an interface cannot be instantiated, therefore such a casting is not possible.

Such a casting is in fact possible. In a way, you are right: You are not actually casting the interface, but the object behind the interface. Remember, an interface reference is just another way of "seeing" an object. You only "see" what the interface defines. The underlying object can have other capabilities. Which is why this would work:

interface Bird {
   void fly();
}
 
interface Horse {
   void gallop();
}
 
interface Lizard {
   void slither();
}
 
class Pegasus implements Bird, Horse {
   public void fly() {}
   public void gallop() {}
}
 
class Dragon implements Bird, Lizard {
   public void fly();
   public void slither();
   public void breathFire();
}
 
public class Test {
   public static void main(String[] args) {
  
      // interface references
      Horse h;
      Bird b;
      Lizard l;
  
      // object references
      Pegasus p = new Pegasus();
      Dragon d = null;
   
      // legal
      h = p;   // Pegasus implements Horse
      [My comment] Yes, this is legal because
      p has been created first and as your code
      created an alternate view on the object,
      then a class object on this interface view
      is legal; my points was: no object, no
      casting. Thank you for your explanation
      anyway, as now i learned that an interface
      assignment could be done on an implementing
      object without an interface casting.
      [/My comment]
  }

Hope this helps clarify the concepts a bit.
[ February 12, 2003: Message edited by: Junilu Lacar ]