标签: instanceof

我正在玩instanceofChrome,但收到了错误消息.我想我知道为什么(你必须instanceof在创建对象的构造函数之后提供一个函数),但错误消息似乎在说明其他内容:

[1,2,3] instanceof Array
// true

[1,2,3] instanceof []
// TypeError: Expecting a function in instanceof check, but got 1,2,3

这是否意味着我应该[1,2,3]用函数替换？我认为这[1,2,3]是正确的,这[]是问题,应该用一个函数替换,但看起来错误信息正好相反.

有人可以解释我是如何错误地解释错误消息的吗？

我在大学的某个阶段被告知(并且随后在十几个地方读过),使用instanceof应仅用作"最后的手段".考虑到这一点,是否有人能够告诉我以下代码是否是最后的手段.我已经看过堆栈溢出但是找不到类似的场景 - 也许我错过了它？

private void allocateUITweenManager() {
   for(GameObject go:mGameObjects){
      if (go instanceof GameGroup) ((GameGroup) go).setUITweenManager(mUITweenManager);
   }
}

哪里

• mGameObjects是一个数组,只有一些是GameGroup类型
• GameGroup是抽象类的子类GameObject.
• GameGroup使用UITweenable具有方法的接口setUITweenManager()
• GameObject 不使用界面 UITweenable

我想我可以同样(也可能应该)替换GameGroup上面的代码UITweenable- 我会问同样的问题.

还有另一种方法可以避免这种情况instanceof吗？这段代码不能失败,因此(我认为,对吧？),但鉴于坏消息instanceof似乎得到了,我是否已经在我instanceof在这里使用的线路上某处犯了一些OOP的主要罪？

提前致谢!

我有一个接收Object的方法,并根据它检测到的对象类型做一些事情:

void receive(Object object) {
    if (object instanceof ObjectTypeA) {
        doSomethingA();
    }
    else {
        if (object instanceof ObjectTypeB) {
            doSomethingB();
        }
        else {
            if (object instanceof ObjectTypeC) {
                doSomethingC();
            }
            else {
                if (object instanceof ObjectTypeD) {
                    doSomethingD();
                }
                else {
                    // etc...
                }
            }
        }
    }
}

如何降低Cyclomatic Complexity？我四处搜索但找不到任何有用的东西.

在Mozilla开发人员中心,有一个关于该Function.prototype.bind功能的页面,并为不支持此功能的浏览器提供兼容性功能.

但是,在分析此兼容性代码时,我无法找出它们使用的原因instanceof nop.nop已经设定为function() {}.ECMA规范的哪一部分与bind此相对应？什么变量是一个实例function() {}？

以下返回false,因此我不完全知道它的用途.在做instanceof function() {}检查时会发生什么事情？

(function() {}) instanceof (function() {}) // false

代码如下:

Function.prototype.bind = function( obj ) {
    if(typeof this !== 'function')
      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');

    var slice = [].slice,
        args = slice.call(arguments, 1), 
        self = this, 
        nop = function () {}, 
        bound = function () {
          return self.apply( this instanceof …

是否有可能在java中获得与instanceof相反的内容？我试过这样的代码:

if( example !instanceof blarg)....

但它不会让我把!任何地方没有错误,请帮助.

在任何人说什么之前我只是出于好奇而问这个问题; 我不打算根据这个答案做任何过早的优化.

我的问题是关于使用反射和铸造的速度.标准的说法是"反思很慢".我的问题是哪个部分确实很慢,为什么; 特别是在比较某事物是否是另一个实例的父母时.

我非常有信心只是将对象的类与另一个Class对象进行比较的速度与任何比较一样快,大概只是直接比较已经存储在Object状态中的单例对象; 但如果一个班级是另一个班级的父母呢？

我通常认为instanceof它与普通班级检查一样快,但今天我想到了它,似乎有些反思必须在"幕后" instanceof才能发挥作用.我在网上查了一下,发现有人说的instanceof很慢; 大概是因为比较物体的父母所需的反射？

这导致了下一个问题,如何只是铸造.如果我把某事物作为一个物体,那我就得不到了ClassCastException.但是如果将对象转换为自身的父对象,则不会发生这种情况.基本上我正在做一个instanceof电话,或逻辑到那个效果,当我在运行时进行演员表明我不是吗？我从来没有听到过任何人暗示过投射物体之前可能会很慢.不可否认,并非所有演员都是提供对象的父级,但很多演员都是父类.然而,从来没有人暗示这可能会很慢.

那是哪个呢.是instanceof真的没有那么慢？两者都instanceof投射到父类有点慢吗？或者有什么理由可以比instanceof电话更快地完成演员表？

它在Object的.equals(Object)javadoc中声明:

它是对称的:对于任何非空引用值x和y,当且仅当y.equals(x)返回true时,x.equals(y)才应返回true.

在示例代码中几乎无处不在,我看到覆盖的.equals(Object)方法,它instanceof用作第一个测试之一,例如:在重写equals和hashCode时必须考虑哪些问题/陷阱？

public class Person {
    private String name;
    private int age;

    public boolean equals(Object obj) {
        if (obj == null)
            return false;
        if (obj == this)
            return true;
        if (!(obj instanceof Person))
            return false;
        ...
    }

}

现在,随着class SpecialPerson extends Person具有equals:

        if (!(obj instanceof SpecialPerson))
            return false;

我们不保证.equals()是对称的.这里已经讨论过这样的例子:任何理由偏好getclass-over-instanceof-when-generating-equals

Person a = new Person(), b = new SpecialPerson();

a.equals(b);    //sometimes true, since b instanceof Person …

我们所有的typescript类都从(直接或间接)继承:

export class WrObject {
    className:string;

    public instanceOf(name : String) : boolean {
        return this.className === name;
    }
}

然后我们将子类声明为:

export class Section extends WrObject {
    public static CLASS_NAME = 'Section';
    className = Section.CLASS_NAME;

        public instanceOf(name : String) : boolean {
            if (this.className === name)
                return true;
            return super.instanceOf(name);
        }

}

然后你可以检查:

if (obj.instanceOf(Section.CLASS_NAME))

这一切都很棒.但是,如果我们能做到,我认为会更清洁:

if (obj.instanceOf(Section))

有没有办法做到这一点？或者有关更好方法的任何建议？

谢谢 - 戴夫

鉴于Object o和a String className = "org.foo.Foo",我想检查是否o是实例List<className>

我试过这个但不会编译:

Class<?> cls = Class.forName(className);
if (o instanceof List<cls>){ // this gives error: cls cannot be resolved to a type
  doSomething();
}

请注意我的输入是Object o和String className(请注意类型).

我是Java的新手并且在设计问题上苦苦挣扎.我知道使用instanceof可能表示设计缺陷,我理解经常给出的Animal/Dog/Cat类作为例子,替换bark()和meow()使用makenoise()等.

我的问题是,如果我需要根据子类的类型调用没有相应方法的方法,那么什么是合理的设计？例如,如果我想调用一个新方法,biteleash()如果该类是a,Dog但如果它是一个什么都不做,该Cat怎么办？

我确实考虑biteleash()过Animal什么都不做,并且覆盖它Dog,但是有许多这样的方法,所以它似乎是一个笨重的解决方案.类似地,如果调用者需要根据它所拥有的子类做一些不同的事情,例如.如果子类是一个终止Cat？是instanceof可以接受的这里,还是有更好的办法？

public class Animal {

    String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void makeNoise() {
        System.out.println("Some noise for a generic animal!");
    }

}

public class Cat extends Animal {

    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeNoise() {
        System.out.println("Meow"); …