Java 泛型转换/实例检查/排除类型参数

问题

检测

可以提供特定类型的

检测表

，如下所示

interface Detectable
{/*...*/}

interface Some_detectable extends Detectable
{/*...*/}

Detect

中的

supply

方法应能够接受任何可检测的

，并且仅在其属于特定类型时提供该方法。我想象这样描述的情况

abstract
class Detect<D extends Detectable>
{
  private final Set<D>
  DETECT= new LinkedHashSet<>();

  void
  supplying(Detectable d)
  {
    /*[ DETECT.add(d); ]*/
    /*supply d if of type D*/
  }
}

我目前正在工作，但解决问题的尝试很糟糕

abstract
class Detect<D extends Detectable>
{
  final Set<D>
  DETECT= new LinkedHashSet<>();

  void
  supplying(Detectable d)
  {
    D
    casted= try_cast(d);

    if(casted==null) {return;}
    DETECT.add(casted);
  }

  abstract protected D
  try_cast(Detectable detectable);
}

class
Some_detect
extends Detect<Some_detectable>
{
  @Override protected Some_detectable
  try_cast(Detectable d)
  {
    return d instanceof Some_detectable
           ? (Some_detectable)d
           : null;
  }
}

摘要
类检测
{
最后一组
检测=新LinkedHashSet（）；
无效的
供应（d）
{
D
铸造d=试铸（d）；
如果（casted==null）{return；}
检测。添加（铸造）；
}
抽象保护D
试铸（可检测）；
}
班
有人发现了
扩展检测
{
@覆盖保护了一些可检测的对象
试铸（d）
{
返回某个\u的d实例
？（一些）d
：null；
}
}
我建议您存储class
class
的对象，并使用它检查
d
的类。Java泛型在运行时被擦除，因此如果不存储此类，就无法编写类似于
d instanceof d
的东西

下面是示例代码（对不起，我编辑了您的代码以符合Java代码样式）：

接口可检测{}
接口{}
抽象类检测{
私人期末班；
私有最终集检测=新LinkedHashSet（）；
受保护检测（类dClass）{
this.dClass=dClass；
}
空隙供应（d）{
if（d类isInstance（d））{
检测.添加（dClass.cast（d））；
}
}
}
类SomeDetect扩展了Detect{
SomeDetect（）{
super（somenotable.class）；
}
}

通过在这种特殊情况下自动查找类型参数，可以使基类
Detect
更易于使用，因为它实际上存储在类元数据中。但这是一种脆弱的方法，我一般不推荐它。
是的，这就是我一直在寻找的！写得好！非常感谢你！
abstract
class Detect<D extends Detectable>
{
  final Set<D>
  DETECT= new LinkedHashSet<>();

  void
  supplying(Detectable d)
  {
    D
    casted= try_cast(d);

    if(casted==null) {return;}
    DETECT.add(casted);
  }

  abstract protected D
  try_cast(Detectable detectable);
}

class
Some_detect
extends Detect<Some_detectable>
{
  @Override protected Some_detectable
  try_cast(Detectable d)
  {
    return d instanceof Some_detectable
           ? (Some_detectable)d
           : null;
  }
}

interface Detectable {}
interface SomeDetectable extends Detectable {}

abstract class Detect<D extends Detectable> {
    private final Class<D> dClass;
    private final Set<D> detect = new LinkedHashSet<>();

    protected Detect(Class<D> dClass) {
        this.dClass = dClass;
    }

    void supplying(Detectable d) {
        if (dClass.isInstance(d)) {
            detect.add(dClass.cast(d));
        }
    }
}

class SomeDetect extends Detect<SomeDetectable> {
    SomeDetect() {
        super(SomeDetectable.class);
    }
}