标签: instanceof

在以下上下文中使用instanceof运算符是不好的做法吗？

public interface IWriter {
    public abstract void write(Dto dto);
}

public abstract class Dto {
    private long id;
    public void setId(long id) {this.id = id;}
    public long getId() {return id;}
}

public class DtoA extends Dto {
   ...
}

public class DtoB extends Dto {
   ...
}

public class MyWriterA implements IWriter {
   @Override
   public void writer(Dto dto) {
     if (!(dto instanceof DtoA))
        return;
     ...
   }
}

public class MyWriterB implements IWriter {
   @Override
   public void writer(Dto dto) { …

我有一个看似棘手的Java库任务.

我需要编写一个适配器/辅助类来处理JTable具有一些附加功能的s,如果它JTable是a JXTable.但我不想在swingx-core-1.6.2.jar上添加运行时依赖,除非我的应用程序实际使用JXTable(在这种情况下它已经要求在类路径上有SwingX jar文件)

如何解耦我的代码来实现这一目标？我甚至不知道如何测试JXTable; 如果我尝试instanceof JXTable用作测试,这意味着我的代码已经对JXTable具有无条件的运行时依赖性.

我之前编写的Java库有"可选"的运行时链接依赖项:如果我在我的库中有这个:

package com.foobar.foolib;

// import from whizbang.jar
import com.whizbang.BloatwareThingy;

public class SuperObject
{
    /* ... uses a BloatwareThingy ... */
}

并且SuperObject是唯一使用whizbang.jar的类,然后只要我的最终应用程序不使用SuperObject,那么就没有运行时依赖于whizbang.jar; 如果我的最终应用程序确实想要使用SuperObject,那么它需要在类路径中包含whizbang.jar.从应用的角度来看是可选的.效果很好.

如何编写一个方法来测试给定的JTable是否为JXTable的实例,如果应用程序仅使用JTable,则不需要依赖SwingX jar文件？

我有三个类,一个抽象用户和两个特定的:NormalUser,它包含一个或多个Address对象的ArrayList,可以是不同的(国内,国际,自定义等),然后是Admin类,它有一个返回true的方法.它们都包含更多彼此无关的方法.

abstract class User{
    public User(String username, String pw){
 ...

}

public class NormalUser extends User{
...
    private ArrayList<Address> addresses;

...

    public void addAdress(ArrayList<Address> address){
        addresses.addAll(address);
}

public class Admin extends User{

...
    public boolean getIsAdmin(){
        return true;
  }
}

现在在另一个类中,如果我像这样制作4个用户对象:

    ArrayList<User> users;

    users.add(new NormalUser( "1", "pw");
    users.add(new NormalUser( "2", "pw");
    users.add(new NormalUser( "3", "pw");
    users.add(new NormalUser( "4", "pw");
    users.add(new Admin("5", "pw"));
    users.add(new NormalUser( "6", "pw");

并说我想在NormalUser中使用addAddress方法,然后我必须将用户中的specfic用户向下转换为NormalUser,然后才能在NormalUser中使用addAddress方法,如下所示:

     if (user instanceof NormalUser){
        NormalUser normal = (NormalUser) user;
        normal.addAddress(...)
        }

我希望NormalUser和Admin都成为用户的原因是我可以在登录时一起处理它们.

我想到将addEmail添加到User类,然后在NormalUser类中重写它,但是我必须为NormalUser类中的每个方法执行此操作,而且Admin也会从User继承它,当它不需要时功能. …

class A{

    public A(){
        System.out.println("in A");
    }
}

public class SampleClass{

    public static void main(String[] args) {
        A a = new A();

        System.out.println(A.class.isInstance(a.getClass()));
    }
}

输出:

false

为什么这是假的？双方A.class并a.getClass()不能返回相同的类!

在哪种情况下我们会从isInstance()方法中得到真实的结果？

在Stoyan Stefanov的书"面向对象的javascript"中,他在第103页上有以下内容.但是,当我尝试这个时,我会得到一个不同的结果h instanceof Object.我错过了什么,JS中有什么东西改变了,或者这是书中的错误.

>>> function Hero(){}
>>> var h = new Hero();
>>> var o = {};
>>> h instanceof Hero;
true
>>> h instanceof Object;
false //true in Google Chrome
>>> o instanceof Object;
true 

我有两个类,它们是抽象类的子类A:

class X extends A {}
class Y extends A {}

我想识别A传递给函数的对象的子类.我可以看到两种选择:

void myfunction(A myobj) {
    if(myobj instanceof X)
        doXStuff((X) myobj);
    if(myobj instanceof Y)
        doYStuff((Y) myobj);
}

或添加不同类型的enumto A:

abstract class A {
    enum Type { X, Y };
    Type type;
    ...
}

class X extends A {
    type = Type.X;
    ...
}
class Y extends A {
    type = Type.Y;
    ...
}

void myfunction(A myobj) {
    if(myobj.type == Type.X)
        doXStuff((X) myobj);
    if(myobj.type …

在我的GameObject类中,我有以下方法来检查GameObject是否会在移动到指定位置时与另一个对象发生碰撞:

public boolean collisionAt(Vector2d position, Class<? extends GameObject>... exclusions) {
    if (getBounds() == null)
        return false;
    Rectangle newBounds = getBounds().clone();
    newBounds.setPosition(position);
    // Check collisions
    for (GameObject object : new ArrayList<>(gameObjects)) {
        if (object.getBounds() != null && newBounds.intersects(object.getBounds()) && object != this) {
            boolean b = true;
            for (Class<? extends GameObject> exclusion : exclusions) {
                if (object.getClass().isInstance(exclusion))
                    b = false;
            }
            if (b)
                return true;
        }
    }
    return false;
}

我想允许程序定义排除项,例如,如果我不希望此方法在与法术冲突时返回true.但由于某种原因,Class.isInstance()行始终返回false.我甚至试过这个:

System.out.println(Spell.class.isInstance(Spell.class));

并且控制台输出错误!这里发生了什么？

如果我错了,请原谅我,但我认为通过这样做:

function MyObject()
{
    return {
        key: 'value',
        hello: function() { console.log('world'); }
    };
}

var obj = new MyObject();

我创建了一个MyObject类型的新实例.

但是,如果我这样做:

obj instanceof MyObject

它返回false.这让我感到困惑,因为我认为这会回归真实.

我在这做错了什么？

这是一个测试这个的小提琴.

我认为我是新的JavaScript基础知识,但也许不是.但是,我发现的消息来源与我的发现相矛盾.

我正在编写一个函数,true如果传递给它的参数是JavaScript Map的实例,则返回该函数.

你可能已经猜到了typeof new Map()返回字符串object,我们没有得到一个方便的Map.isMap方法.

这是我到目前为止:

function isMap(v) {
  return typeof Map !== 'undefined' &&
    // gaurd for maps that were created in another window context
    Map.prototype.toString.call(v) === '[object Map]' ||
    // gaurd against toString being overridden
    v instanceof Map;
}

(function test() {
  const map = new Map();

  write(isMap(map));

  Map.prototype.toString = function myToString() {
    return 'something else';
  };

  write(isMap(map));
}());

function write(value) {
  document.write(`${value}<br />`);
}

到目前为止一切都那么好,但是当测试帧之间的映射以及何时toString() …

是否有更好的方法来处理对象(Product)的实例化,这取决于另一个对象类型(Condition)而不是使用if-else配对,instanceof如下面的代码所示？

import java.util.ArrayList;
import java.util.List;

abstract class AbstractProduct {
    private AbstractCondition condition;
    public AbstractProduct(AbstractCondition condition) {
        this.condition = condition;
    }
    public abstract void doSomething();
}

class ProductA extends AbstractProduct {
    AbstractCondition condition;
    public ProductA(AbstractCondition condition) {
        super(condition);
    }

    @Override
    public void doSomething() {
        System.out.println("I'm Product A");
    }
}

class ProductB extends AbstractProduct {    
    public ProductB(AbstractCondition condition) {
        super(condition);
    }   

    @Override
    public void doSomething() {
        System.out.println("I'm Product B");
    }
}

class AbstractCondition { }

class …