K&B book page 286 table 4-1: Is the array instnaceof result correct?

[Joseph Zhou]

Line 5 in the table says: Foo[] object instanceof Foo, Bar, Face, result is false. Actually, it should fail to compile. Did I miss anything?

[Deepak Bala]

Can you please post the entire code snippet so that every one can answer your question ?

[Joseph Zhou]

Here it is:

Table 4-1 summarizes the use of the instanceof operator given the following:
interface Face { }
class Bar implements Face{ }
class Foo extends Bar { }

table 4-1 Operands and Results Using instanceof Operator.

First Operand instanceof Operand Result
(Reference Being Tested) (Type We�re Comparing the
Reference Against)
Foo[] Foo, Bar, Face false

[Brad Clarke]

This is what I came up with that compile clean and gives the expected results as indicated in table 4-1. No idea if this is the type of code they had intended to result in the output though.

Foo foo = new Foo();
Bar bar = new Bar();
Foo[] fooarr = new Foo[2];
fooarr[1] = new Foo();
 
System.out.println("foo instanceof Foo: " + (foo instanceof Foo));
System.out.println("foo instanceof Bar: " + (foo instanceof Bar));
System.out.println("foo instanceof Face: " + (foo instanceof Face));    
System.out.println("foo instanceof Object: " + (foo instanceof Object));
System.out.println("\n");
 
System.out.println("bar instanceof Bar: " + (bar instanceof Bar));
System.out.println("bar instanceof Face: " + (bar instanceof Face));    
System.out.println("bar instanceof Object: " + (bar instanceof Object));
System.out.println("\n");
 
System.out.println("bar instanceof Foo: " + (bar instanceof Foo));
System.out.println("\n");
 
System.out.println("Foo[] instanceof Foo: " + (fooarr[0] instanceof Foo));
System.out.println("Foo[] instanceof Bar: " + (fooarr[0] instanceof Bar));
System.out.println("Foo[] instanceof Face: " + (fooarr[0] instanceof Face));        
System.out.println("\n");
 
System.out.println("Foo[] instanceof Object: " + (fooarr instanceof Object));        
System.out.println("\n");
 
System.out.println("Foo[1] instanceof Foo: " + (fooarr[1] instanceof Foo));
System.out.println("Foo[1] instanceof Bar: " + (fooarr[1] instanceof Bar));
System.out.println("Foo[1] instanceof Face: " + (fooarr[1] instanceof Face));        
System.out.println("Foo[1] instanceof Object: " + (fooarr[1] instanceof Object));        

[Joseph Zhou]

From my point of view, we should use fooarr, not fooarr[0] here:

System.out.println("Foo[] instanceof Foo: " + (fooarr[0] instanceof Foo));
System.out.println("Foo[] instanceof Bar: " + (fooarr[0] instanceof Bar));
System.out.println("Foo[] instanceof Face: " + (fooarr[0] instanceof Face));

Just as in:
System.out.println("Foo[] instanceof Object: " + (fooarr instanceof Object));

Because both are Foo[].

[Brad Clarke]

Maybe so, but the code won't compile if you do that.

D:\Development\Java5\InstanceTest.java:28: inconvertible types
found : Foo[]
required: Foo
System.out.println("Foo[] instanceof Foo: " + (fooarr instanceof Foo));

[Joseph Zhou]

Thank you Brad. Actually, that just was my question:-)

[Manfred Klug]

Hi,

do it this way and it will compile:

Object fooarrObj = fooarr;
 
System.out.println("Foo[] instanceof Foo[]: " + (fooarrObj instanceof Foo[]));
System.out.println("Foo[] instanceof Foo: " + (fooarrObj instanceof Foo));
System.out.println("Foo[] instanceof Bar: " + (fooarrObj instanceof Bar));
System.out.println("Foo[] instanceof Face: " + (fooarrObj instanceof Face));        
System.out.println("\n");
 
System.out.println("Foo[] instanceof Object: " + (fooarrObj instanceof Object));        
System.out.println("\n");

[Joseph Zhou]

Thanks you to find a way to make it compile-able, but it is not what I want to say.

When you look at the table:

First Operand_____________|instanceof Operand________|Result
(Reference Being Tested)__|(Type We�re Comparing the_|
__________________________|Reference Against)________|
Foo[]_____________________| Foo, Bar, Face___________| false

it's the Foo[] object, not Object, instanceof Foo, Bar, Face, get result false.

I think this is not a correct result, because you can't pass the compile.

[Manfred Klug]

Originally posted by Joseph Zhou:
it's the Foo[] object, not Object, instanceof Foo, Bar, Face, get result false.

I think this is not a correct result, because you can't pass the compile.

I think you confuse two things.

The instanceof check, which will be correct even if you use a parent type for the reference variable, and the compile error which will always occur if there is no relation between the classes. For example:

class Bar { }
class Foo { }
 
class Test {
    public static void main (String [] args) {
        Foo foo = new Foo();
        System.out.println("foo instanceof Bar: " + (foo instanceof Bar));
    }
}

The compilation will fail, since the compiler knows that it is impossible that foo IS A Bar.

[Joseph Zhou]

Repeat my question: Is the line in the table at the page correct?

[Manfred Klug]

Originally posted by Joseph Zhou:
Repeat my question: Is the line in the table at the page correct?

Yes, since nobody forces you to use a reference variable of type Foo[]. For the test you need only an object of type Foo[].

[Joseph Zhou]

Sorry Manfred, I think we are forced, otherwise there is "Object" in the table, not Foo[].