Question

instanceof可用于测试对象是否是给定类的直接或后代实例。 instanceof也可以与接口一起使用，即使接口不能像类一样实例化。任何人都可以解释instanceof的工作原理吗？

Answer 1

首先，我们可以在instances中存储实现特定interface的{{1}}个类。

interface reference variable

即，任何实现特定接口的运行时实例都将通过package com.test; public class Test implements Testeable { public static void main(String[] args) { Testeable testeable = new Test(); // OR Test test = new Test(); if (testeable instanceof Testeable) System.out.println("instanceof succeeded"); if (test instanceof Testeable) System.out.println("instanceof succeeded"); } } interface Testeable { }测试

修改

和输出

instanceof

@RohitJain

您可以使用匿名内部类（如
）创建接口实例
instanceof succeeded instanceof succeeded

并且您使用Runnable runnable = new Runnable() { public void run() { System.out.println("inside run"); } };运算符测试该实例的接口类型

instanceof

，结果为'true'

Answer 2

object instanceof object_interface将产生true。

Answer 3

您针对instanceof对reference进行instance检查，并检查特定instance指向的reference的类型。< / p>

现在，您可以创建interface的引用，该引用指向实现class的实例（与Super class reference相同的概念指向subclass instance）。因此，您可以对其进行instanceof检查。

例如： -

public interface MyInterface {
}

class ImplClass implements MyInterface {

    public static void main(String[] args) {
        MyInterface obj = new ImplClass();

        System.out.println(obj instanceof ImplClass);   // Will print true.
    }
}

Answer 4

- 首先，instanceof用于比较保存对象的对象引用变量是否属于某种类型。

<强>例如

public void getObj(Animal a){ // a is an Object Reference Variable of type Animal if(a instanceof Dog){ } }

- 如果是interface，则<{>}实施的class可以与instanceof一起使用。

<强>例如

public interface Brush{

  public void paint();
}

public class Strokes implements Brush{

       public void paint(){

          System.out.println("I am painting");

    }


}

public class Test{


  public static void main(String[] args){

          Brush b = new Strokes();

         if(b instanceof Strokes){


           b.paint();
       }
  }

}

Answer 5

hi以下将为instanceOf：

生成True

•   If S is an ordinary (nonarray) class, then:
    •   If T is a class type, then S must be the same class as T, or S must be a subclass of T;
    •   If T is an interface type, then S must implement interface T.
•   If S is an interface type, then:
    •   If T is a class type, then T must be Object.
    •   If T is an interface type, then T must be the same interface as S or a superinterface of S.
•   If S is a class representing the array type SC[], that is, an array of components of type SC, then:
    •   If T is a class type, then T must be Object.
    •   If T is an interface type, then T must be one of the interfaces implemented by arrays (JLS §4.10.3).
•   If T is an array type TC[], that is, an array of components of type TC, then one of the following must be true:
         - TC and SC are the same primitive type. 
         - TC and SC are reference types, and type SC can be cast to TC by these run-time rules

请转到此链接以获得明确的想法：

http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.instanceof

Answer 6

public class Programmers {

    public static boolean hasReallife(Programmer programmer) {
        return programmer instanceof Reallife; ══════════════════╗
    }                                                            ║
                                                                 ║
}                                                                ║
                                                                 ▼
public class ReallifeProgrammer extends Programmer implements Reallife {

    public ReallifeProgrammer() {
        diseases.get("Obesity").heal();
        diseases.get("Perfectionism").heal();
        diseases.get("Agoraphobia").heal();
    }

    @Override
    public void goOut() {
        house.getPC().shutDown();
        wife.argue();
    }

    @Override
    public void doSports() {
        goOut();
        BigWideWorld.getGym("McFit").visit();
    }

    @Override
    public void meetFriends() {
        goOut();
        BigWideWorld.searchFriend().meet();
    }

}

Answer 7

我知道这是一个非常古老的问题，有许多好的答案。我只想指出理解这个算子的最简单方法（至少对我来说是最容易的）。

如果o instanceof t返回true，那么 t castedObj = (t) o;不会抛出ClassCastException，castedObj也不会null。

如果您希望稍后从castedObj访问字段或方法，这是非常重要/有用的 - 您知道通过instanceof检查，您将来不会遇到任何问题。

唯一的缺点是，这可以用于没有泛型的类型。

Answer 8

instanceof运算符将告诉您第一个参数是否是实现第二个参数的对象。不明白为什么你不能直接实例化界面。

Integer num = 1;
if (num instanceof Number) {
  System.out.println("An integer is a number!");
}

这就是你所需要的一切。

instanceof如何在接口上工作

8 个答案: