Question

我知道有很多类似的问题，但是如果有可能的话，我没有运气找到一个不错且干净的解决方案。我正在用抽象类型的子类实现通用接口。问题是，当我打电话给他们时，我要么必须在switch / case中键入强制类型转换，要么必须在接口实现内的每个方法中强制类型转换，而我想不出一个很好的方法...我最好写一下举一个简短的例子。

// An abstract type with 2 implementations...
public abstract class ObjTypeAbstract {}

public class ObjType extends ObjTypeAbstract {}
public class ScriptType extends ObjTypeAbstract {}

现在为两种类型的处理器提供接口

interface ProcessorInterface<T extends ObjTypeAbstract> {
    public void abcMethod(T obj);
}

public class ObjProcessor implements ProcessorInterface<ObjType> {
    public void abcMethod(ObjType obj) {}
}
public class ScriptProcessor implements ProcessorInterface<ScriptType> {
    public void abcMethod(ScriptType obj) {}
}

我正在努力的是一种基于ObjAbstractType调用那些处理器的方法。我有一个类作为中间件服务器？或该怎么称呼。

想法是通过一个开关/案例简单地获得合适的处理器：

public class Processor {
    private ProcessorInterface objProcessor = new ObjProcessor();
    private ProcessorInterface scriptProcessor = new ScriptProcessor();

    public methodAbc(ObjAbstractType obj) {
        getProcessor(obj).abcMethod(obj);
    }

    private ProcessorInterface getProcessor(ObjAbstractType obj) {
        if (obj instanceof ObjType) {
            return objectProcessor;
        } else if (obj instanceof ScriptType) {
            return scriptProcessor;
        }

        return nullProcessor;
    }
}

这是我想要的，它还负责将objAbstract的类型转换为abcMethod的实际类型，问题是它会导致RawType警告，而不会破坏代码，但我想摆脱它。

多数民众赞成在卡住...因为如果我将处理器转换为这样的特定类型：

private ProcessorInterface<ObjType> objProcessor = new ObjProcessor();
private ProcessorInterface<ScriptType> scriptProcessor = new ScriptProcessor();

我将无法从getProcessor方法返回一个抽象的接口，因此我将必须使用ObjAbstractType及其所有方法来实现这些接口，并在每个处理器的所有方法中进行类型转换，例如：

public class ScriptProcessor implements ProcessorInterface<ObjAbstractType> {
    public void abcMethod(ObjAbstractType obj) {
        ScriptType scr = (ScriptType) obj;
    }
}

另一种解决方案可能是在Processor中间件类中包含一个开关/案例，并在其中强制转换ObjAbstractType，但是我必须在abcMethod和所有其他方法中或从getProcessor方法中返回的那个开关同时返回Processor和强制转换的ObjType。。所以我必须返回包含两者的dto。：/

您是否有任何想法/模式可以帮助我摆脱RawType调用警告，而无需使用更多的switch / case或type强制转换来扩展代码？祝您有美好的一天，大卫，我很高兴进行任何讨论。

Answer 1

您需要一种存储ObjTypeAbstract类和ProcessorInterface实例之间的映射的方法。
您可以使用将Map（作为键）与ObjTypeAbstract（作为值）关联的ProcessorInterface。
关于原始类型问题，您可以对声明的变量使用ProcessorInterface<? extends ObjTypeAbstract>，但是仍然需要对ProcessorInterface<ObjTypeAbstract>执行不安全的强制转换，才能使用{{ 1}}声明的类型。
在您的实际设计中，这种转换是不可避免的。

它可能会给出类似的内容：

ProcessorInterface.abcMethod()

Answer 2

我认为没有一种更优雅的方法来绕过某种形式的instanceof逻辑。但是，如果您向getProcessor添加了一些类型，则不需要强制转换。

    public <T extends ObjTypeAbstract> ProcessorInterface<T> getProcessor(Class<T> theClass) {
        if (theClass.isAssignableFrom(ObjType.class)) {
            return objProcessor;
        } else if (theClass.isAssignableFrom(ScriptType.class)) {
            return scriptProcessor;
        }
        return null;
    }

然后可以这样称呼它：

    ProcessorInterface<ScriptType> scriptProcessor = new Processor().getProcessor(ScriptType.class);
    ProcessorInterface<ObjType> objProcessor = new Processor().getProcessor(ObjType.class);

带有抽象参数的Java通用接口调用

2 个答案: