标签: instanceof

如您所知,"接口程序"设计原则广泛地倾向于使用超类型而不是具体类型或实现.

是否与在Java程序中使用instanceof从超类型派生具体类型的原则一致？

在我的应用程序中,Storehouse是一个抽象的超类型类,包含几个私有变量和公共getter和setter.

ConcreteStorehouseA继承自Storehouse,有很多具体的方法和变量.ConcreteStorehouseB类似但不同.

我的应用程序收到了一个仓库.但是,Storehouse不是一个有用的类型.因为具体类型中只包含真正有用的方法,所以我使用instanceof如下:

if (storehouse instanceof ConcreteStorehouseA) {
    ConcreteStorehouseA concreteStorehouseA = (ConcreteStorehouseA) storehouse;
    // perform operations on the concrete type's useful methods and variables

使用instanceof与原理兼容吗？

编辑:

本质上,该应用程序是桌面RPG,Shadowrun的骰子模拟器.具体类型是不同的测试类型 - 成功测试,反对测试,扩展测试 - 它们的成功操作都有非常不同的因素和参数.超类型基本上包含骰子池!

我有这个方法哪个唯一参数(List elements)设置元素到ListModel,但我需要进行验证,看看泛型类型是否实现可比较,因为这样的事情:

if (elements instanceof List<? extends Comparable>)

是非法的,我不知道如何做正确的验证.

更新

我已经使用以下方法完成了此验证:

(elements.size() > 0 && elements.get(0) instanceof Comparable)

但我想知道是否有更清洁的解决方案,例如使用反射？

提前致谢.

我正在写一段代码,如果它是某个类的实例,我必须转换它.

像往常一样,我用它instanceof来检查兼容性.

问题是从不满足检查,因为对象属于"奇怪"类.

例如; 当我getClass().getSimpleName()在这个对象上调用方法时,它会返回类的名称+ $*(例如,ViewPart$1而不是ViewPart).

这$*意味着什么？有解决方案或解决方法吗？

在我正在编写的基于精灵的游戏中,2D网格中的每个字段都包含一堆精灵.最重要的是最重要的.

在游戏的规则模块中,我有很多这样的代码:

public boolean isGameWon(Board board) {
    for (Point point : board.getTargetPoints())
        if(!(board.getTopSpriteAt(point) instanceof Box))
            return false;
    return true;
}

Upadate: //Do something计算Box每个顶部是否有顶部Target.我不知道如何简单地添加doSomething()到Sprite,除非doSomething()精灵是一个盒子,否则返回1 ,否则返回0.(这与instanceof相同).

我知道instanceof被认为是有害的,因为它杀死了面向对象编程的想法.

我不知道如何在我的情况下修复代码.以下是我的一些想法:

• 我不认为简单isABox()地向Sprite接口添加方法会更好.
• 如果Box是一个接口会有帮助吗,所以其他类可以得到相同的特权？
• 我应该尝试做一些像花样匹配/双重调度这样的东西吗？
• 规则模块是否可以与类型密切配合,只是因为它应该知道它们的语义？
• 规则模块策略模式的整个想法是否有缺陷？
• 将规则构建到Sprite中是没有意义的,因为在添加新类型时它们都必须被更改.

我希望你尝试过类似的东西,并能指出我正确的方向.

今天我碰巧有太多的时间来杀死,我用Node(v0.10.13)命令行玩了一下:

> 1 instanceof Object
false
> (1).__proto__
{}
> (1).__proto__ instanceof Object
true
> (1).__proto__.__proto__ === Object.prototype
true

现在,根据MDN,这instanceof是什么:

instanceof运算符测试对象在其原型链中是否具有构造函数的prototype属性.

但显然Object.prototype是IS 1的原型链.那么为什么是1 instanceof Object假的呢？也许是因为1原始而不是一个开始的对象？

好的,我接受了,我做了更多测试:

> (1).__proto__ === (2).__proto__
true
> 'a'.__proto__ === 'b'.__proto__
true
> (1).__proto__ === 'a'.__proto__
false
> (1).__proto__.__proto__ === 'a'.__proto__.__proto__
true
> (1).__proto__.type = 'number'
'number'
> 'a'.__proto__.type = 'string'
'string'
> (2).type
'number'
> (1.5).type
'number'
> 'b'.type
'string'

显然,所有数字基元都从一个对象继承,并且所有字符串基元都从另一个对象继承.这两个对象都继承自Object.prototype.

现在的问题是,如果数字和字符串被认为是原语,为什么要从其他对象继承它们？或者相反,当它们从其他对象继承时,为什么不考虑它们呢？对我来说,对象的孩子不是对象似乎是荒谬的. …

我知道当对象是特定类的实例时,instanceof返回TRUE.例如:

B extends A
C extends A

B b = new B();
C c = new C();

b instanceof A // returns TRUE

到目前为止一切都很好,所以让我们输入看起来应该返回false的东西:

c instanceof B // won't compile (error: inconvertible types)

这不编译,这是有道理的,因为它允许在编译时捕获疏忽.但是,当DOES instanceof实际返回false时？似乎只有两个选项是TRUE和ERROR.我能想到的唯一例外是:

null instanceof A // returns FALSE

但是通过与上面相同的逻辑,似乎应该在编译时捕获它.

我在这里错过了什么？true/error是唯一可行的选项,还是可以以更有意义的方式实际返回false,除了将null作为引用变量给出？

我想知道现代C++ 11相当于Java的实例.我已经看过这个SO帖子,但它已经很老了,并且想知道在C++ 11中是否有更现代,更好的解决方案？

我希望有可能使用switch结构而不必使用手动枚举类.

class A {

};

class B : public A {

}

class C : public A {

}

on_event(A& obj)
{
    switch (obj) {
       case A:
       case B:
       case C:
    }
}

我的基类没有任何虚拟方法或函数.我代表解析器的表达式树,基类只是一个多态持有者 - 就像Haskell/OCaml中的ADT一样.

typing除了类型提示以外，我在使用Python中的类型时遇到了一些问题：

>>> from typing import List
>>> string_list = ['nobody', 'expects', 'the', 'spanish', 'inqusition']
>>> string_list_class = List[str]

现在我想

1. 检查是否string_list符合string_list_class。
2. 检查是否string_list_class为列表。
3. 如果是这样，请检查课程，这string_list_class是一个列表。

我发现自己无法实现以下任何一个目标：

>>> isinstance(string_list, string_list_class)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/Cellar/python/3.7.0/Frameworks/Python.framework/Versions/3.7/lib/python3.7/typing.py", line 708, in __instancecheck__
    return self.__subclasscheck__(type(obj))
  File "/usr/local/Cellar/python/3.7.0/Frameworks/Python.framework/Versions/3.7/lib/python3.7/typing.py", line 716, in __subclasscheck__
    raise TypeError("Subscripted generics cannot be used with"
TypeError: Subscripted generics cannot be used with class and instance checks

>>> issubclass(string_list_class, …

所以,我使用IntelliJ IDEA在Java中编程,我正在尝试使用关键字instanceof,我的代码看起来最终是这样的:

public class Main {

    public static void main(String args[])
    {
        One one = new One();
        One two = new Two();

        if (one instanceof Two) 
        {
            System.out.println(one);
        }

        if (two instanceof Two) 
        {
            System.out.println(one);
        }

    }
}

class One { }

class Two extends One { }

IntelliJ在线上给了我two instanceof Two一个提示"[...]总是真的",但是对于one instanceof TwoIntelliJ并没有给我一个"[...]总是假的"提示.有谁知道为什么？

在NodeJS应用程序中,我试图检查传递给函数的值是否是特定类的实例,但是我instanceof在模块之间使用以及检查类的相等性时会遇到意外行为.

endpoint.js

import SomeClass from 'utils/class';
import SomeModel from 'models/model';

const model = SomeModel.findOne({id: 'abc'});
const values = {a: 'b'};
const classInstance = new SomeClass({id: 'def'});

classInstance instanceof SomeClass //returns true
Object.getPrototypeOf(classInstance) //returns SomeClass {}

model.update(values, { a: classInstance, b: SomeClass });

当classInstance传递给更新函数时,我看到了意外的行为.

调用Object.getPrototypeOf(a)返回SomeClass,也是如此a.constructor.name.但是,a instanceof SomeClass 返回false.

此外,只检查导入的类和传递给函数的类之间的相等性返回false.

require.resolve('utils/class') 为两个导入返回相同的路径.

车型/ model.js

import SomeClass from 'utils/class';

class Model {
  async update(values, injections) {
    const { a, b } = injections;

    // checking instance …