java - 子类化泛型 - 构造函数继承

Question

我正在尝试创建一个用于变量表示的类，因此我首先创建了一个参数化基类:

public abstract class DataField<Type>
{

    public enum DataTypes
    {
        STRING,
        INT,
        FLOAT,
        TIME,
        DATE
    }

    private DataTypes type=null;
    private String name=null;
    private Type value=null;

    private DataField()
    {
    }

    public DataField(String name)
    {
        setName(name);
    }

    DataField(String name, DataTypes type)
    {
        this(name);
        setType(type);
    }

    DataField(String name, DataTypes type, Type value)
    {
        this(name, type);
        setValue(value);
    }

    public DataField(String name, Type value)
    {
        this(name);
        setValue(value);
    }
    public DataField(String name, String value)
    {
        this(name);
        setStringValue(value);
    }
    public abstract void setStringValue(String strValue);
     ...
}

然后为不同类型创建子类，定义方法:

public class DataFieldInt extends DataField<Long>
 ...
public class DataFieldBoolean extends DataField<Boolean>
 ...

等等。但我对字符串有一个预期的问题:通用父类(super class)有 2 个构造函数DataField(String name, Type value) 设置变量的名称和值，以及DataField(String name, String value) 从 String 设置变量的名称和值，并将其转换为所需的类型。但对于子类，我有一个问题 - 使用什么构造函数，因为它们都是 (String, String)。所以，这段代码

public class DataFieldString extends DataField<String>
{
    public DataFieldString(String name, String value)
    {
        super(name, value);
           ...
    }

给出了关于不明确引用的错误如何解决这个问题？我看到的唯一方法是使用 StringBuilder 或 StringBuffer 之类的东西来代替 String，但很有趣，是否有“ native ”解决方案？

谢谢

Answer 1

How can this be solved?

通过提供对编译器没有任何歧义的调用。

The only method I see is to use something like StringBuilder or StringBuffer instead of String, but it's interesting, is there a "native" solution?

它可以工作，但依赖 String 构建器来传递不需要构建的 String 也显得很笨拙。

评论中建议使用 Factory 的想法不错，但根据您的设计，我认为它将需要很多更改，并使您脱离实际设计:层次结构依赖于基类的类。
因为为了使类之间的事物保持一致，您应该在每个子类中定义工厂。
此外，如果将两个构造函数保留在基类中，它不会解决歧义问题。因此，您可能应该允许子类访问基类字段以执行构造函数逻辑。

因此，为了保持符合您的实际设计，我将通过引入一个包装 Type 和 String 变量的新类来解决歧义问题。
您可以在 DataField 类中声明此类:

static class NameAndType<Type> {
    private String name;
    private Type value;
    public NameAndType(String name, Type value ){
       ....
    }
}

因此 DataField 类可以公开这两个构造函数:

public DataField(NameAndType<Type> nameAndType) {
    this(nameAndType.name);
    setValue(nameAndType.value);
}

public DataField(String name, String value) {
    this(name);
    setStringValue(value);
}

通过这种方式，您可以在 DataFieldString 中公开一个依赖于基类构造函数之一的构造函数:

public class DataFieldString extends DataField<String> {

    public DataFieldString(String name, String value) {
        super(name, value);
        //  or the other way : super(new NameAndType<>(name, value));
    }    
   ...
}

其他子类可以根据基类构造函数提出两个构造函数。
例如:

public class DataFieldInt extends DataField<Integer> {

    public DataFieldInt(String name, Integer value) {
        super(new NameAndType<>(name, value));
    }

    public DataFieldInt(String name, String value) {
        super(name, value);
    }

    ...
}

并且 NameAndType 复杂性/使用对于这些类的客户端来说是不可见的:

DataFieldInt dataFieldIntOne = new DataFieldInt("var1", 321);
DataFieldInt dataFieldIntTwo = new DataFieldInt("var1", "321");
DataFieldString dataFieldString = new DataFieldString("var1", "321");