I try to explain for myself "What is an instanceof", with subclasses?

[Nico van de Kamp]

This is giving me headache. Sometimes I think I understand and a moment later I'm asking myself were am I looking at. I had this question wrong and I spent much time on it.

public class TestClass {
    public static void main(String[] args) {
        B b = new C();                /** declared var. b is of type B, is pointing to instance C */
        A a = b;                      /** declared var. a is of type A, pointing to same instance C */
        if (a instanceof B b1) b1.b();
        if (a instanceof C c1) c1.c();
        if (a instanceof D d1) d1.d();
    }
}
class A {void a() {System.out.println("a");} }
class B extends A { void b() {System.out.println("b");} }
class C extends B { void c() {System.out.println("c");} }
class D extends C { void d() {System.out.println("d");} }

The type of the variable a is A and therefore, a may point to an instance of A or any of its subclasses (B, C, D).

I will try to explain to myself:
The declared variabeles  a and b are refering to the same instance of C

So, a is refering to an instance of C, that explains that

a instanceof C

will be true
and because of C "IS-A" B explains that

a instanceof B

will als be true
But C "IS-NOT-A" D makes that  

a instanceof D

is false

Is my explanation correct? (This hard for me to understand, I'm asking than what is going on? What does the type mean in relation to the (sub) class instance here? Than I'm getting a mess in my head and mixing things.)

[Paul Clapham]

Looking at the output when you run that code should help you considerably, I think. So what do you see when you run it?

[Tim Holloway]

At the risk of giving away the plot, "instanceof" is an operator, just like "+". except that it has a longer name. It's a binary operator, so like the '%" operator. it has a left-hand side and a right-hand side. The left-hand side of "instanceof" is an object. The right-hand side is the name of a class, which can either be simple ("String") or fully-qualified ("java.sql.Date"). The output of this operation will be a binary value (true/false).

One thing that might not be intuitive is that a "class" is not just literally a class, but in Java, so is an Interface.

Thus, if you say "a instanceof  Foo", then you are checking to see if "a" is either an actual instance of class Foo OR an instance of a class which has Foo as a parent class OR the class that a actually belongs to (or one of its parents) implemenents Foo.

Thus, instanceof is a very powerful operator as it allows you to check whether an object has certain properties or methods without you having to use introspection to peer into its innards. I can feed it it an object that has been down-cast to generic java.lang.Object and easily tell if I can do "Foo" things with it, regardless of whether it's a FooUp, a FooDown, a DummyFoo and know that I can't do Foo things if the object was actually a Bar.

[Campbell Ritchie]

The instanceof operator might be powerful, but it usually makes me suspicious. Why do you need to check whether an object can of cannot be cast to a particular type? Is there something peculiar about the inheritance of the class in question? If you find yourself using instanceof in real‑life code, start thinkging whether you have got the inheritance right.
One place, other than in cert exams, where instanceof is definitely respectable to use, even essential, is when writing an equals() method.