Question

我们说我的情况如下：

班级X的字段s类型为S。

S由两个类A和B扩展，两个类都实现了我们都知道应该在S中实现的相同方法/字段，但不幸的是，这个事实并非如此。

现在我想做这样的事情：

"A or B" downcast_field;
if(s instanceof A)
    downcast_field = (A)s;
else if (s instanceof B)
     downcast_field = (B)s;

//do something common for the two cases but that need methods implemented both in A and B

问题是提前有一个静态类型（IFs之外）允许我调用这些方法。

我想由于糟糕的设计，这实际上是不可能的，我必须写两次相同的代码，这很难看，但也许有一个我现在没有看到的解决方案。

Answer 1

如果您可以更改A和B，则可以为两者添加相同的界面。这将允许您将此类型赋予downcast_field并调用方法。

如果您无法更改A和B，那么您有两种选择：

您可以撰写A2和B2。将代码从A和B复制到新类型中。这允许您修改代码（除非您无法控制这些类型的创建）。或者，您现在也可以创建扩展S2的{{1}}并将公共代码放在那里，然后从中扩展S / A2。
创建一个接口，然后创建两个实现，只是将调用委托给真实类型。

在此解决方案中，您可以
```
B2
```
您可以使两个包装器扩展相同类型并在那里移动公共代码。

Answer 2

据我所知，您的情况如下：

public class S {
}

public class A extends S {

    public void doSomething() {
        System.out.println("A is doing something ...");
    }
}

public class B extends S {

    public void doSomething() {
        System.out.println("B is doing something ...");
    }
}

实际上我认为这个设计相当糟糕。如果你有机会清理这个你应该这样做。如果这不是以下选项解决方法是可行的......引入一个声明公共API的接口并使用此界面包装您的实例...

public interface WrapperInterface {
    void doSomething();
}

然后你可以这样使用

public class Main {

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

        a.doSomething();
        b.doSomething();
    }

    private static WrapperInterface wrap(final S s) {
        WrapperInterface downcast_field=null;
        if (s instanceof A)
            downcast_field = new WrapperInterface() {
                @Override
                public void doSomething() {
                    ((A) s).doSomething();
                }
            };
        else if (s instanceof B) {
            downcast_field = new WrapperInterface() {
                @Override
                public void doSomething() {
                    ((B) s).doSomething();
                }
            };
        }
        return downcast_field;
    }
}

使用仅在运行时可获得的静态类型

2 个答案: