instanceof关键字

在java中可以使用instanceof关键字判断一个对象到底是那个类的实例，格式如下：

对象  instanceof  类->返回boolean类型

范例：

package InstanceofDemo;
 
class A {
    public void fun1() {
        System.out.println("A-->fun1");
    }
 
    public void fun2() {
        this.fun1();
    }
}
 
class B extends A {
    public void fun1() {
        System.out.println("B-->fun1");
    }
 
    public void fun3() {
        System.out.println("B-->fun3");
    }
}
 
public class InstanceofDemo01 {
    public static void main(String[] args) {
        A a1 = new B(); // 向上转型实例化A类对象
        System.out.println("A a1=new B():" + (a1 instanceof A));
        System.out.println("A a1=new B():" + (a1 instanceof B));
 
         B b1=(B)a1; //向下转型实例化A类对象
         System.out.println("A a1=new B():"+(a1 instanceof A));
         System.out.println("A a1=new B():"+(a1 instanceof B));
 
        A a2 = new A();// 通过A类的构造实例化本类对象
        System.out.println("A a2=new B():" + (a2 instanceof A));
        System.out.println("A a2=new B():" + (a2 instanceof B));
    }
}
//由于通过子类实例化的对象同时是子类和父类的实例，所以可以直接进行向上或者相信转型，但如果直接使用了父类的实例化对象，则一定就不在是子类实例化
//所以是不能转型的

　结果：

A a1=new B():true
A a1=new B():true
A a1=new B():true
A a1=new B():true
A a2=new B():true
A a2=new B():false

范例：在向下转型钱进行验证

package test;
 
class A {
    public void fun1() {
        System.out.println("A-->public void fun1(){}");
    }
 
    public void fun2() {
        this.fun1();
    }
}
 
class B extends A {
    public void fun1() {
        System.out.println("B-->public void fun1(){}");
    }
 
    public void fun3() {
        System.out.println("B-->public void fun3");
    }
}
 
class C extends A {
    public void fun1() {
        System.out.println("C-->public void fun1(){}");
    }
 
    public void fun5() {
        System.out.println("C--->public void fun3(){}");
    }
}
 
public class InstanceDemo02 {
    public static void main(String[] args) {
        fun(new B());//传递b类实例，产生向上转型
        fun(new C());//传递C类实例，产生向上转型
    }
 
    public static void fun(A a) {//此方法可以分别调用各自子类单独定义的方法
        a.fun1();
        if (a instanceof B) {//判断是否是B类实例
            B b = (B) a;//进行向下转型
            b.fun3();//调用子类自己定义的方法
        }
        if (a instanceof C) {//判断是否是C类实例
            C c = (C) a;//进行向下
            c.fun5();
        }
    }
}

结果：

B-->public void fun1(){}
B-->public void fun3
C-->public void fun1(){}
C--->public void fun3(){}

在上面的fun（）方法中因为要调用各个子类自己的方法，所以必须进行对象的向下转型，但是为了保证程序在运行时不出现类转换异常，所以在发生向下转型前要使用instanceof关键字判断是那个子类的实例，以保证程序正常运行。

***********

在类的设计中重点在于父类的设计，而且在类的设计中，永远不要去继承一个已经实现好的类，只能继承抽象类或实现接口，因为一旦发生对象的向上转型后，所调用的方法一定是被子类所覆写过的方法。

转自：

http://www.cnblogs.com/bokun-wang/archive/2011/12/06/2278353.html