Java 检查对象是否是类的实例（但不是其子类的实例）

对于此示例：

public class Foo{}

public class Bar extends Foo{}

....

void myMethod(Foo qux){
   if (checkInstance(qux,Foo.class)){
     ....
   }
}

如何检查

qux

是否是Foo的实例（但不是Foo子类的实例）？即:

• checkInstance（qux，Foo.class）=true
• checkInstance（qux，Bar.class）=false

---

是否有类似于此检查的

instanceof

之类的语句？或者我应该使用

qux.getClass（）.equals（Foo.class）

您应该使用instanceof

if(qux instanceof Foo && !(qux instanceof Bar)) {
    ...
}

---

这适用于类和接口，因此在大多数情况下，它应该优先于不适用于接口的

.class

。

如果要查找精确的类匹配，唯一的方法是

qux.getClass（）.equals（Foo.class）

。instanceof对于子类也将返回true。

如果必须这样做，唯一的方法是您建议的

getClass（）.equals（Foo.class）

选项

---

然而，OO设计的目标是允许您以相同的方式处理任何

Foo

。实例是否为子类在普通程序中应该无关紧要。

您已经知道qux是Foo的实例（除非它为null…），所以您只需要一个简单的

qux instanceof Bar

和一个null检查。

我刚刚尝试了下面的代码，它似乎工作正常

    package com.instance;

    public class Foo {
        public void instance(Foo f) {
            System.out.println("---------");
            System.out.println(f.getClass());
            System.out.println(getClass());
            if (f.getClass() == getClass()) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }


package com.instance;

public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Foo f1 = new Foo();
        Foo f2 = new Foo();
        Foo f3 = new Bar();
        f1.instance(f1);
        f1.instance(f2);
        f1.instance(f3);
    }

}

public class BaseClass {

    private String a;

    public boolean isInstanceOf(BaseClass base){
        if(base == null){
            return false;
        }
        else if(getClass() == base.getClass()){
            return true;
        }else{
            return false;
        }
    }

}



public class DervidClass extends BaseClass {


    public boolean isInstanceOf(DervidClass base) {
        if(base == null){
            return false;
        }
        else if(getClass() == base.getClass()){
            return true;
        }else{
            return false;
        }
    }


}

public class myTest {
public static void main(String[] args) throws ParseException {


        BaseClass base = new BaseClass();
        BaseClass base1 = new BaseClass();
        DervidClass derived = new DervidClass();

        BaseClass d1 = new DervidClass();

        System.out.println(base.isInstanceOf(d1));
        System.out.println(d1.isInstanceOf(d1));
        System.out.println((d1 instanceof BaseClass));


    }

---

我已经阅读了所有已经发布的答案，但还没有找到满意的答案。回答此检查是否有类似

instanceof

的语句？或者我应该使用

qux.getClass（）.equals（Foo.class）

问题我会说是的，java中有

instanceof

操作符来检查对象是否是类的实例。下面是一个例子-：

class Vehicle {

}

class Car extends Vehicle {

}

public class Research {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();

        if (vehicle instanceof Vehicle) {
            System.out.println("vehicle instanceof Vehicle : TRUE");
        } else {
            System.out.println("vehicle instanceof Vehicle : FALSE");
        }

        if (vehicle instanceof Car) {
            System.out.println("vehicle instanceof Car : TRUE");
        } else {
            System.out.println("vehicle instanceof Car : FALSE");
        }

        System.out.println();
        Car car = new Car();

        if (car instanceof Vehicle) {
            System.out.println("car instanceof Vehicle : TRUE");
        } else {
            System.out.println("car instanceof Vehicle : FALSE");
        }

        if (car instanceof Car) {
            System.out.println("car instanceof Car : TRUE");
        } else {
            System.out.println("car instanceof Car : FALSE");
        }
    }
}

class Vehicle {

}

class Car extends Vehicle {

}

public class Research {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();

        if (vehicle.getClass().equals(Vehicle.class)) {
            System.out.println("vehicle instanceof Vehicle : TRUE");
        } else {
            System.out.println("vehicle instanceof Vehicle : FALSE");
        }

        if (vehicle.getClass().equals(Car.class)) {
            System.out.println("vehicle instanceof Car : TRUE");
        } else {
            System.out.println("vehicle instanceof Car : FALSE");
        }

        System.out.println();
        Car car = new Car();

        if (car.getClass().equals(Vehicle.class)) {
            System.out.println("car instanceof Vehicle : TRUE");
        } else {
            System.out.println("car instanceof Vehicle : FALSE");
        }

        if (car.getClass().equals(Car.class)) {
            System.out.println("car instanceof Car : TRUE");
        } else {
            System.out.println("car instanceof Car : FALSE");
        }


    }
}

输出-：

vehicle instanceof Vehicle : TRUE
vehicle instanceof Car : FALSE

car instanceof Vehicle : TRUE
car instanceof Car : TRUE

vehicle instanceof Vehicle : TRUE
vehicle instanceof Car : FALSE

car instanceof Vehicle : FALSE
car instanceof Car : TRUE

Description-：

instanceof

运算符告诉您对象是类的实例还是父类的实例（最高级别）。

vehicle instanceof Car:FALSE

输出行表示

instanceof

运算符不会判断对象是否为其子类的实例。

另一种方法是使用

getClass（）.equals（Foo.class）

确定对象是否是类的实例。让我们看看下面的例子-：

class Vehicle {

}

class Car extends Vehicle {

}

public class Research {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();

        if (vehicle instanceof Vehicle) {
            System.out.println("vehicle instanceof Vehicle : TRUE");
        } else {
            System.out.println("vehicle instanceof Vehicle : FALSE");
        }

        if (vehicle instanceof Car) {
            System.out.println("vehicle instanceof Car : TRUE");
        } else {
            System.out.println("vehicle instanceof Car : FALSE");
        }

        System.out.println();
        Car car = new Car();

        if (car instanceof Vehicle) {
            System.out.println("car instanceof Vehicle : TRUE");
        } else {
            System.out.println("car instanceof Vehicle : FALSE");
        }

        if (car instanceof Car) {
            System.out.println("car instanceof Car : TRUE");
        } else {
            System.out.println("car instanceof Car : FALSE");
        }
    }
}

class Vehicle {

}

class Car extends Vehicle {

}

public class Research {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();

        if (vehicle.getClass().equals(Vehicle.class)) {
            System.out.println("vehicle instanceof Vehicle : TRUE");
        } else {
            System.out.println("vehicle instanceof Vehicle : FALSE");
        }

        if (vehicle.getClass().equals(Car.class)) {
            System.out.println("vehicle instanceof Car : TRUE");
        } else {
            System.out.println("vehicle instanceof Car : FALSE");
        }

        System.out.println();
        Car car = new Car();

        if (car.getClass().equals(Vehicle.class)) {
            System.out.println("car instanceof Vehicle : TRUE");
        } else {
            System.out.println("car instanceof Vehicle : FALSE");
        }

        if (car.getClass().equals(Car.class)) {
            System.out.println("car instanceof Car : TRUE");
        } else {
            System.out.println("car instanceof Car : FALSE");
        }


    }
}

输出-：

vehicle instanceof Vehicle : TRUE
vehicle instanceof Car : FALSE

car instanceof Vehicle : TRUE
car instanceof Car : TRUE

vehicle instanceof Vehicle : TRUE
vehicle instanceof Car : FALSE

car instanceof Vehicle : FALSE
car instanceof Car : TRUE

Description-：从上面的示例可以清楚地看出，应该在哪里选择哪一个（以上两个中的哪一个？

重要提示-：

instanceof

运算符不会在引用变量未指向任何对象（即其具有空引用）的情况下引发

NullPointerException

异常

car.getClass（）.equals（car.class）

将在

car

未指向任何对象（即其具有空引用）的情况下引发

NullPointerException

异常。因此，必须对此进行额外的空检查，例如

car！=null&&car.getClass（）.equals（car.class）

以防止它

NullPointerException

instanceof

运算符告知对象是类的实例还是父类的实例（最高级别）

car.getClass（）.equals（car.class）

将判断对象是否只是类的实例（根本不考虑父类和子类）

---

希望这能帮助你使用

qux instanceof Foo

@Selvin使用instanceof并不一定意味着应用程序设计是错误的。例如，当您尝试将数据映射到多个视图类型时，它会在适配器中使用。但检查对象是否为Foo而不是Bar（当Bar扩展Foo时）是错误的应用程序设计。这不会捕捉到

Baz

是

Foo

的子类的情况。是这样吗？

和&

的rhs对于

条

的实例应返回false，无论它扩展了哪些其他类假定

Baz

是

Foo

的直接子类。您的

if

子句的两边都将计算为

true

。您确实看到了

，是吗？是的，我知道<在我的示例中，code>Baz

不是

Bar

的实例。请注意，我稍微扩展了OP的原始示例，以讨论一般情况。一张图片可能会画出千言万语，但一大堆代码肯定会给出一个难看的答案。我认为许多堆栈交换问题都是关于不正常的情况。@WarrenDew我同意。但是，在可能存在更好的解决方案的情况下，很大一部分人正在寻求一种方法来实施他们自己的问题解决方案。当你发现自己在一种面向对象语言中违反了面向对象原则时，这很好地表明你偏离了轨道。我不明白有什么更好的选择符合面向对象原则，我想把

Foo

分为两类

Foo

和

SuperFoo

，并将

Bar

从

SuperFoo

下放到

。所以这可能更糟糕，但我不确定这是否更好。是的，我很欣赏这个答案，但你真的需要避免假设OP为什么会问，并暗示他们做错了什么。这方面的需求有很多有效的案例。