详解java中instanceof各种的用法

instanceof :
1)、类与类: 判断继承链上的实例,一般使用在强转之前的判断(多态应用时,即多态作为形参时)
2)、接口与类:接口可插拔，类都可以instanceof编译
编译看类型，运行找对象，不能通过编译
注意:final 类 不可能发生多态
已经确定的类体，指匿名子类对象
3)、接口与接口 :存在继承关系
不存在编译问题:主要看可能存在多态
代码体现:

1)String类重写Object类的equals方法(方法签名必须一致)

public boolean equals(Object anObject){     //形参是多态时,才可以使用instanceof判断,因为多态存在于继承体系中
　　if(this==anObject)     //对象地址值相同直接返回真.
　　　　return ture;
　　if(anObject instanceof String){     //判断传入的实参是否为String类型,因为形参类型是固定的(重写的要求),所以需要判断
　　　　String anotherString = (String)anObject;    //强制转换
　　　　int n = count;
　　　　if (n == anotherString.count) {
　　　　char v1[] = value;
　　　　char v2[] = anotherString.value;
　　　　int i = offset;
　　　　int j = anotherString.offset;
　　　　while (n-- != 0) {
　　　　if (v1[i++] != v2[j++])
　　　　　　　return false;
　　　　}
　　　　return true;
　　}
　　return false;
}

 

2)除final修饰的类及匿名子类对象外,几乎所有的类都可以通过instanceof + 接口编译(因为可能存在多态)
能否编译通过,遵循一个原则:是否可能与接口发生多态

public class Test{
　　public static void main(String[] args){
　　　　B1 b1 = new B1();
　　　　B1 b2 = new B2();     //多态
 5　　　　 C1 c = new C1();
　　　　D1 d = new D1();
　　　　D2 d2 = new D2();
　　　　A a1 = new B2();
　　　　System.out.println(b1 instanceof A);    //可以通过编译,因为A是可插拔的,B1的引用可以指向其子类对象,而其子类对象可能会实现了接口A(如B2),,但是运
　　　　　　　　　　　　　　　　　　　　　　　　　　　　//行时就会检验了,结果为false     (B1可能与A发生多态)
11　　　　 System.out.println(b2 instanceof A);//结果为true     (B2已经与A发生多态)
//    System.out.println(b1 instanceof C1);    //编译失败,因为B与C之间不存在继承关系    (C1不可能与C1存在多态,没有继承关系)
//    System.out.println(d1 instanceof A);    //编译失败,因为D不可能有子类,不可能发生多态    (D1不可能与A多态,不可以有子类)
　　　　System.out.println(d2 instanceof A);    //编译通过,结果为true     (D2实现了A,与A产生了多态)
　　　　System.out.println(new B1() instanceof A); //B1的匿名对象,false     (B1可能与A发生多态)
　　　　System.out.println(new B2() instanceof A);    //B1的匿名对象,true     (B2已经与A发生多态)
//    System.out.println(new B1(){} instanceof A);//B1的已经确定类体的,即匿名子类对象,不能通过编译
　　　　System.out.println(new B2(){} instanceof A);//B2的虽未匿名子类对象,但是却属于A的实现类,所以编译通过,结果为true
//    System.out.println(new B3() instanceof A);    //抽象类是不可以进行实例化的,编译失败
//    System.out.println(new B3(){} instanceof A);//抽象类要产生匿名子类对象,必须复写所有抽象方法,编译失败
//    System.out.println(new B3(){public void test(){}} instanceof A);//非A的匿名子类对象,编译失败
　　　　System.out.println(new B4(){public void method(){}} instanceof A);//编译通过,结果为true
　　}
}
interface A{
　　void method();
}

class B1{

}
class B2 extends B1 implements A{
　　public void method(){}
　　}
abstract class B3
36 {
　　abstract void test();
}
abstract class B4 implements A
{

}
class C1{

}
final class D1
{
}
final class D2 implements A{
　　public void method(){}
}

3)接口与接口间,使用instanceof不存在编译问题,但是若使用匿名内部类则会编译失败

public class Test{
　　public static void main(String[] args){
　　A a =new C();
　　System.out.println(a instanceof B);    //编译通过.A可能与B发生多态,因为A的实现类有可能实现了B,结果为false
　　System.out.println(new A(){public void test(){}} instanceof B);//编译失败,非B的匿名子类对象,不存在多态
　　}
}
interface A{
}
interface B{
}
class C implements A{
}