java instanceof关键字

instanceof关键字在java中是一个二元操作符。和==、>、<是一个东东。由于它是由字母组成的，所以也是java的保留字。它的作用是判断操作符左边的对象是否是右边类型的一个实例。instanceof在实际开发中的作用是：在进行类型转换之前，判断一个对象是否是一个类型的实例，如果是进行类型转换，如果不是就不进行类型转换。这样判断程序会更健壮，减少 ClassCastException异常的抛出。代码如下：

package fly.zxy.CollectionJava;

public class InstanceofTest1 {

    public static void main(String[] args) {
        Person student = new Student();
        printType(student); //输出 1、3位置的信息

        Teacher teacher = new Teacher();
        printType(teacher); //输出 1、3位置的信息

        Person person = new Person();
        printType(person);  //输出 3位置的信息
    }

    public static void printType(Person person){
        if(person instanceof Student){
            System.out.println("传入的person对象是Sutdent类的一个实例"); //1
        }else if(person instanceof Teacher){
            System.out.println("传入的person对象是Teacher类的一个实例"); //2
        }

        if(person instanceof Person){
            System.out.println("传入的person对象是Person类的一个实例"); //3
        }
    }

}

class Person{}

class Student extends Person{}

class Teacher extends Person{}

让我们在通过一个例子再来加深一下对instanceof的了解。我们有一个add(Object obj1, Object obj2)方法，当调用这个方法时传入的是两个整型就做加法运算。当传入的是两个字符串就用StringBuilder做字符串连接操作。add的形参是Object类型的，那么怎么才能知道传入的是整型还是String呢？当然是通过instanceof来判断。代码如下：

package fly.zxy.CollectionJava;

public class InstanceofTest2 {

    public static void main(String [] args){
        Object o1 = add(10,22);
        System.out.println("o1:"+o1);

        Object o2 = add("my csdn."," java 关键字 instanceof ");
        System.out.println("o2:"+o2);

    }

    public static Object add(Object obj1, Object obj2){

        if(obj1 instanceof Integer){    //如果是整型就做加法运算
            System.out.println("做加法运算");
            Integer int1 = (Integer) obj1;
            Integer int2 = (Integer) obj2;
            return int1+int2;
        }else if(obj1 instanceof String){   //如果是字符串就用StringBuilder做链接
            System.out.println("StringBuilder做链接");
            StringBuilder sb = new StringBuilder();
            sb.append(obj1).append(obj2);
            return sb.toString();
        }

        return null;
    }
}

其实上面的add()的需求用instanceof来判断传入的类型是为了说明instanceof的用法(ps:可能举add()例子也不是很恰当)。最好的实现方式就是用多态的体现形式中的方法重载和方法覆盖两种形式。
方法重载如下：

package fly.zxy.CollectionJava;

public class InstanceofTest3 {

    public static void main(String [] args){
        Integer o1 = add(10,22);
        System.out.println("o1:"+o1);

        String o2 = add("my csdn."," java 关键字 instanceof ");
        System.out.println("o2:"+o2);

    }

    //用StringBuilder做链接的add方法
    public static String add(String s1, String s2){
        StringBuilder sb = new StringBuilder();
        sb.append(s1).append(s2);
        return sb.toString();
    }

    //做加法运算的add方法
    public static Integer add(Integer i1, Integer i2){
            return i1+i2;
    }
}

方法覆盖，一提到方法覆盖肯定是需要继承类支持的。代码如下：

package fly.zxy.CollectionJava;

public class InstanceofTest4 {

    public static void main(String [] args){
        add(new StringOp("ABC","EFG"));

        add(new IntegerOp(12,10));

    }
    public static void add(Operation op){
        Object o = op.add();
        System.out.println("o:"+o);
    }
}

 abstract class Operation{

    public abstract <T> T add();
}

class StringOp extends Operation {

    private String op1;
    private String op2;

    public StringOp(String op1, String op2){
        this.op1 = op1;
        this.op2 = op2;
    }

    @Override
    public <T> T add() {
        StringBuilder sb = new StringBuilder();
        sb.append(op1).append(op2);
        return (T) sb.toString();
    }
}

class IntegerOp extends Operation{

    private Integer op1;
    private Integer op2;

    public IntegerOp(Integer op1, Integer op2){
        this.op1 = op1;
        this.op2 = op2;
    }

    @Override
    public <T> T add() {
        Integer i = (op1 + op2);
        return (T) i;
    }

}