Question

我有一个抽象类，不幸的是我不能改变它的定义，它基本上提供了一个抽象方法，有点像。

val streamConfig: Properties = {
    val properties = new Properties()
    properties.put(StreamsConfig.APPLICATION_ID_CONFIG, "stream-application")
    properties.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, BrokerHost)
    properties
}

现在，每个类都需要实现这个抽象方法，有点像。

public abstract void do(Data someData, BaseInterface interface);

现在，我可以使用转换界面，但是我必须花费很多时间来扩展这个抽象类，并且必须每次都进行转换，而转换将在同一个实现上完成，即CastTheBaseInterface。我想在我的类和超级抽象之间引入另一层并解决问题。但无法想到解决方案。我的观点是，如果我事先知道接口将被转换为哪种实现，为什么要再次使用它？试。

Answer 1

这是一个解决方案，适用于只有一个实现要转换为：

的情况

public class YourNewAbstractClass extends LegacyAbstractClass {
    @Override
    public void do(Data someData, BaseInterface interface) {
        CastTheBaseInterface obj = (CastTheBaseInterface) interface;
        doCasted(someData, obj );
    }

    public abstract doCasted(Data someData, CastTheBaseInterface interface)
}

然后你的孩子班会是这样的：

public class ChildClass extends YourNewAbstractClass {
    @Override
    public void doCasted(Data someData, CastTheBaseInterface casted) {
        casted.exec(someData);
    }
}

如果你有更多的实现，你可以使用暗魔法暗示使用泛型结合动态转换：

public class YourNewAbstractClass<T extends BaseInterface> extends LegacyAbstractClass {
    @Override
    public void do(Data someData, BaseInterface interface) {
        // getting the generic parameter that you will define in a subclass
        Class<T> clazz = (Class<T>) ((ParameterizedType) getClass()
                        .getGenericSuperclass()).getActualTypeArguments()[0];
        // dynamically casting your object to a generic type
        T casted = clazz.cast(something);
        doCasted(someData, casted);
    }

    public abstract doCasted(Data someData, T casted)
}

然后您的子课程将如下所示：

public class ChildClassOne extends YourNewAbstractClass<CastTheBaseInterface> {
    @Override
    public void doCasted(Data someData, CastTheBaseInterface casted) {
        casted.exec(someData);
    }
}

public class ChildClassTwo extends YourNewAbstractClass<AnotherCastTheBaseInterface> {
    @Override
    public void doCasted(Data someData, AnotherCastTheBaseInterfacecasted) {
        casted.doSomeOtherStuff(someData);
    }
}

希望这有帮助！

Answer 2

如果您不使用Java 8或更高版本，请创建另一个抽象类，该类派生您无法修改的抽象类，并在此新抽象类中实现该方法。
然后make子类实现新的抽象类。

如果您使用Java 8或更高版本，请创建一个接口，您可以使用公共处理声明默认方法。然后让你的子类同时实现这个接口和抽象类。你不应该在子类中再次实现它。

这些解决方案不是很漂亮＆＃34;但你有遗留约束，所以它应该是可以接受的。

在常见抽象方法的所有子类中提取常见实现的最佳方法

2 个答案: