instanceof operator with an interface versus class

[Thomas Hauck]

Why does compilation for an unrelated interface succeed when using the 'instanceof' operator
but not for class?


For the code below in Example 1,

if (c instanceof X) // line 2
  System.out.println("C is a X");

compiles even though reference variable 'c' has no relation to interface 'X'.

When the same operation is attempted with class 'A',
('c' has no relation to class 'A'), the compilation will not succeed.

if (c instanceof A) // compilation fails  // line 1
   System.out.println("C is a A");

Example 1:

interface X { }

class A implements X { }

class B extends A { }

public class C {

	public static void main(String[] args) {
		X x1 = new B();
		B b1 = new B();
		C c = new C();
		if (x1 instanceof A)
			System.out.println("x1 is a A");

		if (b1 instanceof X)
			System.out.println("b1 is a X");
		/* if (c instanceof A)    // compilation fails  // line 1
                     System.out.println("c is a A");
       */
		if (c instanceof X) // line 2
			System.out.println("c is a X");
	}
}

/* Program Output 
x1 is a A
b1 is a X
*/

Question: Does this have to do with the fact that an interface is purely abstract?

[Paul Clapham]

No, it isn't. At your "// line 2" all the compiler knows is that variable c can be assigned to type C, which is a non-final class. So it's possible that it actually refers to an object of some class D, a subclass of C which implements the interface X. And since that's a possibility, there's no reason to reject it.

On the other hand if C were a final class, then that possibility wouldn't exist and the compiler would fail that line of code. Try it and see.

[Henry Wong]

Thomas Hauck wrote:Why does compilation for an unrelated interface succeed when using the 'instanceof' operator
but not for class?


For the code below in Example 1,

if (c instanceof X) // line 2
  System.out.println("C is a X");

compiles even though reference variable 'c' has no relation to interface 'X'.

What if we change your code somewhat like this?

interface X { }

class A implements X { }

class B extends A { }

class D extends C implements X { }

public class C {

	public static void main(String[] args) {
		X x1 = new B();
		B b1 = new B();
		C c = new D();
		if (x1 instanceof A)
			System.out.println("x1 is a A");

		if (b1 instanceof X)
			System.out.println("b1 is a X");
		/* if (c instanceof A)    // compilation fails  // line 1
                     System.out.println("c is a A");
       */
		if (c instanceof X) // line 2
			System.out.println("c is a X");
	}
}

Then shouldn't those two lines compile?

Henry

[Thomas Hauck]

Thanks for the reply.

I have changed the original Example 1 above and
placed the object creation within TestClass in Example 2.

I. My first observation is 'class C' is independent of
1. interface X and
2. class A.

In example 2, 'class C'

1) does not extend A
2) does not implement X .

Is this observation correct?
----- ----- ----- -----
II. Next observation is that reference variable 'c' of class C,
has no relationship to interface X and will compile when used with the instanceof operator on line 2 .

Is this correct?

--------
III. Reference variable 'c' of class C has no relationship to class A and will not compile when used with the instanceof operator on line 1.
if (c instanceof A) // line 1 // compilation fails
System.out.println("c is a A");
--------

Example 2:

interface X { }

class A implements X { }

class B extends A { }

class C{}

public class TestClass {

	public static void main(String[] args) {
		X x1 = new B();
		B b1 = new B();
		C c = new C();
		if (x1 instanceof A)
			System.out.println("x1 is a A");
		if (b1 instanceof X)
			System.out.println("b1 is a X");
		 /* if (c instanceof A)    // compilation fails  // line 1
		        System.out.println("c is a A"); */
		if (c instanceof X)			// line 2
			System.out.println("c is a X");
	}
}
/* 
x1 is a A
b1 is a X
*/

I wanted to generalize these results to determine if

a) when instanceof is used with an unrelated interface this code will compile. // line 2
b) When instanceof is used with an unrelated class this code will not compile. //line 1

Question: Are statements a) and b) above supported by the code in Example 2?


Thanks in advance.

[Roel De Nijs]

Thomas Hauck wrote:I wanted to generalize these results to determine if

The general conclusion when someExpression instanceof ReferenceType will result in a compiler error is: If a cast of the someExpression to the ReferenceType would be rejected as a compile-time error, then the instanceof relational expression likewise produces a compile-time error. In such a situation, the result of the instanceof expression could never be true (based on JLS 15.20.2. Type Comparison Operator instanceof).

First an obvious example of a compiler error (Incompatible conditional operand types String and Number):

if ("foo" instanceof Number)

Because the cast (Number) "foo" results in a compiler error, so must the expression "foo" instanceof Number

A more subtle example of a simillar compiler error (Incompatible conditional operand types Integer and Cloneable):

Integer myInt = 10;
if (myInt instanceof Cloneable)

Reason why:

Integer is a final class

Integer does not implement Cloneable

So you can't do (Cloneable) anInteger

Thus anInteger instanceof Cloneable will also not compile

But this example compiles without any problem:

Number myNumber = 10;
if (myNumber instanceof Cloneable)

Reason why: the Number class is not final, so there could be a subclass that implements the Cloneable interface. That's also why (Cloneable) aNumber will compile (but will throw a ClassCastException at runtime).

An example with 2 unrelated classes will always result in compiler error (similar to the 1st obvious example):

class Car {}
class Fish {}
Fish myFish = new Fish();
if (myFish instanceof Car)

Hope it helps!
Kind regards,
Roel

[John Lerry]

I would just be sure you have got it right.

Roel De Nijs wrote:
But this example compiles without any problem:

Number myNumber = 10;
if (myNumber instanceof Cloneable)

Reason why: the Number class is not final, so there could be a subclass that implements the Cloneable interface. That's also why (Cloneable) aNumber will compile (but will throw a ClassCastException at runtime).

The code compiles as the Number class is NOT final and then MAY (not sure that it does) implement the interface Cloneable but then a ClassCastException is throws because the JVM sees that the type of the object is an Integer that is a class final and therefore could not implement the interface Cloneable (type cast).
Is that correct?

Roel De Nijs wrote:
An example with 2 unrelated classes will always result in compiler error (similar to the 1st obvious example):

class Car {}
class Fish {}
Fish myFish = new Fish();
if (myFish instanceof Car)

The code does not compile because the class Fish is not in the same class hierarchy Car.
Is that correct?

[Roel De Nijs]

John Lerry wrote:The code compiles as the Number class is NOT final and then MAY (not sure that it does) implement the interface Cloneable but then a ClassCastException is throws because the JVM sees that the type of the object is an Integer that is a class final and therefore could not implement the interface Cloneable (type cast).
Is that correct?

Almost, you are very close! Because Integer IS-NOT-A Cloneable, the JVM throws a ClassCastException at runtime. It doesn't matter if the Integer class is final or not, it only matters if the Integer class implement the Cloneable interface. Because it doesn't, you'll get the ClassCastException at runtime.

Just to be complete: If a class is not final, other classes can extend from this class and you can implement any interface you want. So you could create for example this class

public class MyCoolNumber extends Number implements Cloneable {
  // all cool number code
}

And then you could write this code:

Number n = new MyCoolNumber();
if (n instanceof Cloneable) {
  System.out.println("Yay! It's a cloneable.");
}

That's why you don't get a compiler error if your class isn't final. If the class is final, you can't create any subclasses (which could implement an interface which wasn't implemented by the super class).

John Lerry wrote:The code does not compile because the class Fish is not in the same class hierarchy Car.
Is that correct?

Spot-on!

Hope it helps!
Kind regards,
Roel

[John Lerry]

Let's see if I understand:

Number n = new MyCoolNumber();
if (n instanceof Cloneable) {
  System.out.println("Yay! It's a cloneable.");
}

I try to analyze this code. The code does not return an compile time error because the reference (n) is of type Number that is NOT a final class.
Not even return a runtime error because the object is of type MyCoolNumber that actually implements the interface Cloneable.
Therefore control on the type of class (so if final or not) occurs at compile time while the control on the implementation of interface (if it happens or not) occurs at runtime.

Is that correct?

[Roel De Nijs]

John Lerry wrote:I try to analyze this code. The code does not return an compile time error because the reference (n) is of type Number that is NOT a final class.
Not even return a runtime error because the object is of type MyCoolNumber that actually implements the interface Cloneable.
Therefore control on the type of class (so if final or not) occurs at compile time while the control on the implementation of interface (if it happens or not) occurs at runtime.

Is that correct?

The 1st and 3rd statements are absolutely correct! The 2nd isn't, because you'll never get a runtime exception when you use the instanceof operator: if the object is an instance of the type, the expression evaulates to true, false otherwise. Casting is a risky operation (as you know by now), so to prevent runtime exceptions from occuring, you should use the instanceof operator to verify if the cast is ok (true is returned) or not (false is returned).
Have a look at this code snippet:

public Number create() {
  // returns an instance of a random subclass of Number
}

Number n = create();
System.out.println(n instanceof Cloneable); // line1
System.out.println((Cloneable)n); // line2

Some observations about this code:

no compiler error, because class Number is not final (as you mentioned in your 1st statement)

line1 will always print true or false, depending if the subclass of Number implements Cloneable or not. line1 will never throw a runtime ClassCastException

line2 throws a runtime ClassCastException if the subclass of Number doesn't implement Cloneable (as you mentioned in your 2nd statement). line2 will print to the console (and not throw the runtime ClassCastException) if the subclass of Number implements Cloneable

Hope it helps!
Kind regards,
Roel

[John Lerry]

putting a moment by the instanceof operator, we understand that avoids that there is an exception at runtime, I would understand if I have understood the concept.

I would like to better analyze this code:

public class MyCoolNumber extends Number implements Cloneable {
     ...
}

Number n = new MyCoolNumber();
Cloneable clone = (Cloneable)n;

In general you can make a cast between a class and an interface if the class is NOT declared final, otherwise there will be an error in compilation.
Also should be checked whether or not the class implements the interface.
In the specific example the object is of type MyCoolNumber that implements the interface (Cloneable) then cast from MyCoolNumber to Cloneable not throw an exception at runtime.

Is it correct?

[Roel De Nijs]

John Lerry wrote:In general you can make a cast between a class and an interface if the class is NOT declared final, otherwise there will be an error in compilation.

True! Example:

interface Cute {}
class Cat {}
final class Dog {}  

Cute c1 = (Cute)new Cat(); // no compiler error, always runtime exception
Cute c2 = (Cute)new Dog(); // compiler error

John Lerry wrote:Also should be checked whether or not the class implements the interface.

Indeed! If you want to safely perform a cast, you should always first perform an instanceof check first. Example:

Cat cat = new Cat();
if (cat instanceof Cute) {
  Cute cute = (Cute)cat; // no compiler error, never runtime exception
}

John Lerry wrote:In the specific example the object is of type MyCoolNumber that implements the interface (Cloneable) then cast from MyCoolNumber to Cloneable not throw an exception at runtime.

Exactly! And in this example there was no need to verify if the cast would have been valid, because reference variable n refers to a MyCoolNumber instance (which obviously implement Cloneable). But for example in this code, it's really needed if you want to safely cast without the risk of a runtime exception being thrown.

public Cloneable clone(Number n) {
  if (n instanceof Cloneable) { return (Cloneable)n; }
  return null;
}

Hope it helps!
Kind regards,
Roel