Question

我有一个返回某个值的POJO，但现在该值可能是不同的类型：

public class ContainerA<T> {
    T value;
    public ContainerA(T value) {
       this.value = value;
    }
    public T getValue() {
       return value;
    }
    //some more methods
}

所以我想用另一个替换它，但重构工作太棒了：

public interface Container<T> {
    public T getValue() {
    //some more methods
}

public class ContainerA implements Container<String> {
    String value;
    public ContainerA(String value) {
       this.value = value;
    }
    public String getValue() {
       return value;
    }
    //implementation of those other methods
}

为了避免这种大规模的重构，我认为我可以拥有这样的东西：

public class Container<T> {
    T value;
    public Container(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
    //some other methods
}

public class ContainerA extends Container<String> {
    public ContainerA(String value) {
       super(value);
    }
}

但是，由于大多数POJO类看起来几乎相同，并且有许多其他方法，所以我想知道为什么这会有问题：

{{1}}

同样，我们的想法是添加泛型支持并避免使用大型重构。有更好的方法吗？是以上任何一个好吗？为什么？

Answer 1

我建议您使用通用接口，以便根据您的需要实现它。当您没有初步了解您的实现时，接口也很好。另一个使用接口的专家是您可以稍后添加对持续开发有用的方法。

byte[]

Answer 2

这实际上取决于您对Container的未来计划：

如果您不打算重复使用和扩展Container的方法和属性，那么继续使用它是没有用的。如果你想要多态性，可以使用一个接口（如果你不想，你可能想要保留简单的泛型）。接口将为您提供类似于从继承获得的功能（例如多态），而不要求您扩展任何内容。

此外，如果我在您的团队中工作，当我看到ContainerA时，我不知道为什么在项目已经包含Container＆lt;＆gt;时使用它。

继承主要用于two原因： Polymorphism和Code reuse。
请参阅链接以供讨论，但它指的是C ++。

Answer 3

此选项：

public class ContainerA extends Container<String> {
    public ContainerA(String value) {
       super(value);
    }
}

重构是一个非常合理的步骤，但它并不是最终目标，因为你不希望有两种方法来实现同样的目标，特别是因为它们不是100％兼容的。

e.g。如果您有这样的方法：method(Container<String> container)那么它将接受ContainerA，但反之则不然; method(ContainerA container)将不接受Container<String>

所以你现在可以做的是你可以将旧类型标记为已弃用，并花时间完成重构，安全知道，因为旧代码从新代码中下降，所以使用它是完全安全的人们会知道他们应该在新代码中使用哪两个实现：

/**
 * @deprecated Use {@link Container<String>}
 */
@Deprecated
public final class ContainerA extends Container<String> {

POJO，泛型和扩展它们

3 个答案: